Improve the datafusion explain output

Author: jackkleeman

crates/storage-query-datafusion/src/table_providers.rs

@@ -8,7 +8,7 @@
 // the Business Source License, use of this software will be governed
 // by the Apache License, Version 2.0.
 use std::any::Any;
-use std::fmt::{Debug, Formatter};
+use std::fmt::{self, Debug, Display, Formatter};
 use std::ops::RangeInclusive;
 use std::sync::Arc;
 
@@ -403,10 +403,36 @@ where
     fn fmt_as(&self, t: DisplayFormatType, f: &mut Formatter) -> std::fmt::Result {
         match t {
             DisplayFormatType::Default | DisplayFormatType::Verbose => {
-                write!(f, "PartitionedExecutionPlan({:?})", self.scanner)
+                write!(
+                    f,
+                    "PartitionedExecutionPlan: scanner={:?}, partitions={}, projection=[{}]",
+                    self.scanner,
+                    self.logical_partitions.len(),
+                    ProjectedColumns(&self.projected_schema),
+                )?;
+                if let Some(predicate) = &self.predicate {
+                    write!(f, ", predicate={predicate}")?;
+                }
+                if let Some(limit) = self.limit {
+                    write!(f, ", limit={limit}")?;
+                }
+                Ok(())
             }
             DisplayFormatType::TreeRender => {
-                write!(f, "PartitionedExecutionPlan\nscanner={:?}", self.scanner)
+                writeln!(f, "scanner={:?}", self.scanner)?;
+                writeln!(f, "partitions={}", self.logical_partitions.len())?;
+                writeln!(
+                    f,
+                    "projection=[{}]",
+                    ProjectedColumns(&self.projected_schema)
+                )?;
+                if let Some(predicate) = &self.predicate {
+                    writeln!(f, "predicate={predicate}")?;
+                }
+                if let Some(limit) = self.limit {
+                    writeln!(f, "limit={limit}")?;
+                }
+                Ok(())
             }
         }
     }
@@ -595,11 +621,69 @@ impl DisplayAs for GenericExecutionPlan {
     fn fmt_as(&self, t: DisplayFormatType, f: &mut Formatter) -> std::fmt::Result {
         match t {
             DisplayFormatType::Default | DisplayFormatType::Verbose => {
-                write!(f, "GenericExecutionPlan()",)
+                write!(
+                    f,
+                    "GenericExecutionPlan: scanner={:?}, projection=[{}]",
+                    self.scanner,
+                    ProjectedColumns(&self.projected_schema),
+                )?;
+                if !self.filters.is_empty() {
+                    write!(f, ", filters=[{}]", ExprList(&self.filters))?;
+                }
+                if let Some(limit) = self.limit {
+                    write!(f, ", limit={limit}")?;
+                }
+                Ok(())
             }
             DisplayFormatType::TreeRender => {
-                write!(f, "GenericExecutionPlan()",)
+                writeln!(f, "scanner={:?}", self.scanner)?;
+                writeln!(
+                    f,
+                    "projection=[{}]",
+                    ProjectedColumns(&self.projected_schema)
+                )?;
+                if !self.filters.is_empty() {
+                    writeln!(f, "filters=[{}]", ExprList(&self.filters))?;
+                }
+                if let Some(limit) = self.limit {
+                    writeln!(f, "limit={limit}")?;
+                }
+                Ok(())
+            }
+        }
+    }
+}
+
+/// Display helper: comma-separated column names from a schema.
+struct ProjectedColumns<'a>(&'a SchemaRef);
+
+impl Display for ProjectedColumns<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let mut first = true;
+        for field in self.0.fields() {
+            if !first {
+                write!(f, ", ")?;
+            }
+            write!(f, "{}", field.name())?;
+            first = false;
+        }
+        Ok(())
+    }
+}
+
+/// Display helper: comma-separated logical expressions.
+struct ExprList<'a>(&'a [Expr]);
+
+impl Display for ExprList<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let mut first = true;
+        for expr in self.0 {
+            if !first {
+                write!(f, ", ")?;
             }
+            write!(f, "{expr}")?;
+            first = false;
         }
+        Ok(())
     }
 }