feat(query): pretty format for explain

Signed-off-by: Enwei Jiao <jiaoew2011@gmail.com>

query/src/sql/planner/format/indent_format.rs

@@ -37,25 +37,4 @@ where T: Display
         }
         Ok(())
     }
-
-    /// format TreeNode in a pretty way
-    pub fn format_pretty(&self) -> Result<String> {
-        let mut buf = String::new();
-        self.format_pretty_impl(0, false, &mut buf)?;
-        Ok(buf)
-    }
-
-    fn format_pretty_impl(&self, indent: usize, is_last: bool, f: &mut String) -> Result<()> {
-        if indent == 0 {
-            writeln!(f, "{}", &self.payload).unwrap()
-        } else if is_last {
-            writeln!(f, "{}└── {}", "│   ".repeat(indent - 1), &self.payload).unwrap()
-        } else {
-            writeln!(f, "{}├── {}", "│   ".repeat(indent - 1), &self.payload).unwrap()
-        }
-        for (i, child) in self.children.iter().enumerate() {
-            child.format_pretty_impl(indent + 1, i == self.children.len() - 1, f)?;
-        }
-        Ok(())
-    }
 }

query/src/sql/planner/format/mod.rs

@@ -16,6 +16,7 @@ mod display_rel_operator;
 use std::fmt::Display;
 mod display_plan;
 mod indent_format;
+mod pretty_format;
 
 pub struct FormatTreeNode<T: Display> {
     payload: T,

query/src/sql/planner/format/pretty_format.rs

@@ -0,0 +1,60 @@
+// Copyright 2022 Datafuse Labs.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::fmt::Display;
+use std::fmt::Write;
+
+use common_exception::Result;
+
+use super::FormatTreeNode;
+
+static REGULAR_PREFIX: &str = "├── ";
+static CHILD_PREFIX: &str = "│   ";
+static LAST_REGULAR_PREFIX: &str = "└── ";
+static LAST_CHILD_PREFIX: &str = "    ";
+
+impl<T> FormatTreeNode<T>
+where T: Display
+{
+    /// format TreeNode in a pretty way
+    pub fn format_pretty(&self) -> Result<String> {
+        let mut buf = String::new();
+        self.format_pretty_impl("".to_string(), "".to_string(), &mut buf)?;
+        Ok(buf)
+    }
+
+    fn format_pretty_impl(
+        &self,
+        prefix: String,
+        child_prefix: String,
+        f: &mut String,
+    ) -> Result<()> {
+        writeln!(f, "{}{}", prefix, &self.payload).unwrap();
+        if let Some((last_child, children)) = self.children.split_last() {
+            for child in children {
+                child.format_pretty_impl(
+                    (child_prefix.clone() + REGULAR_PREFIX).clone(),
+                    (child_prefix.clone() + CHILD_PREFIX).clone(),
+                    f,
+                )?;
+            }
+            last_child.format_pretty_impl(
+                (child_prefix.clone() + LAST_REGULAR_PREFIX).clone(),
+                (prefix.clone() + LAST_CHILD_PREFIX).clone(),
+                f,
+            )?;
+        }
+        Ok(())
+    }
+}