Merge pull request #10704 from sundy-li/explain-join

feat(explain): add a simple explain join to display the join orders

Author: BohuTANG

src/query/ast/src/ast/format/ast_format.rs

@@ -692,6 +692,7 @@ impl<'ast> Visitor<'ast> for AstFormatVisitor {
             ExplainKind::Raw => "Raw",
             ExplainKind::Plan => "Plan",
             ExplainKind::Memo(_) => "Memo",
+            ExplainKind::JOIN => "JOIN",
             ExplainKind::AnalyzePlan => "Analyze",
         });
         let format_ctx = AstFormatContext::with_children(name, 1);

src/query/ast/src/ast/statements/explain.rs

@@ -25,6 +25,8 @@ pub enum ExplainKind {
     Raw,
     Plan,
 
+    JOIN,
+
     // Explain analyze plan
     AnalyzePlan,
 }

src/query/ast/src/ast/statements/statement.rs

@@ -253,7 +253,8 @@ impl Display for Statement {
                     ExplainKind::Raw => write!(f, " RAW")?,
                     ExplainKind::Plan => (),
                     ExplainKind::AnalyzePlan => write!(f, " ANALYZE")?,
-                    ExplainKind::Memo(_) => write!(f, "MEMO")?,
+                    ExplainKind::JOIN => write!(f, " JOIN")?,
+                    ExplainKind::Memo(_) => write!(f, " MEMO")?,
                 }
                 write!(f, " {query}")?;
             }

src/query/ast/src/parser/statement.rs

@@ -56,7 +56,7 @@ pub enum CreateDatabaseOption {
 pub fn statement(i: Input) -> IResult<StatementMsg> {
     let explain = map_res(
         rule! {
-            EXPLAIN ~ ( AST | SYNTAX | PIPELINE | GRAPH | FRAGMENTS | RAW | MEMO )? ~ #statement
+            EXPLAIN ~ ( AST | SYNTAX | PIPELINE | JOIN | GRAPH | FRAGMENTS | RAW | MEMO )? ~ #statement
         },
         |(_, opt_kind, statement)| {
             Ok(Statement::Explain {
@@ -72,6 +72,7 @@ pub fn statement(i: Input) -> IResult<StatementMsg> {
                         ExplainKind::Syntax(pretty_stmt)
                     }
                     Some(TokenKind::PIPELINE) => ExplainKind::Pipeline,
+                    Some(TokenKind::JOIN) => ExplainKind::JOIN,
                     Some(TokenKind::GRAPH) => ExplainKind::Graph,
                     Some(TokenKind::FRAGMENTS) => ExplainKind::Fragments,
                     Some(TokenKind::RAW) => ExplainKind::Raw,

src/query/service/src/interpreters/interpreter_explain.rs

@@ -82,6 +82,28 @@ impl Interpreter for ExplainInterpreter {
                 _ => self.explain_plan(&self.plan)?,
             },
 
+            ExplainKind::JOIN => match &self.plan {
+                Plan::Query {
+                    s_expr, metadata, ..
+                } => {
+                    let ctx = self.ctx.clone();
+                    let settings = ctx.get_settings();
+
+                    let enable_distributed_eval_index =
+                        settings.get_enable_distributed_eval_index()?;
+                    settings.set_enable_distributed_eval_index(false)?;
+                    scopeguard::defer! {
+                        let _ = settings.set_enable_distributed_eval_index(enable_distributed_eval_index);
+                    }
+                    let mut builder = PhysicalPlanBuilder::new(metadata.clone(), ctx);
+                    let plan = builder.build(s_expr).await?;
+                    self.explain_join_order(&plan, metadata)?
+                }
+                _ => Err(ErrorCode::Unimplemented(
+                    "Unsupported EXPLAIN JOIN statement",
+                ))?,
+            },
+
             ExplainKind::AnalyzePlan => match &self.plan {
                 Plan::Query {
                     s_expr,
@@ -185,6 +207,17 @@ impl ExplainInterpreter {
         Ok(vec![DataBlock::new_from_columns(vec![formatted_plan])])
     }
 
+    pub fn explain_join_order(
+        &self,
+        plan: &PhysicalPlan,
+        metadata: &MetadataRef,
+    ) -> Result<Vec<DataBlock>> {
+        let result = plan.format_join(metadata)?.format_pretty()?;
+        let line_split_result: Vec<&str> = result.lines().collect();
+        let formatted_plan = StringType::from_data(line_split_result);
+        Ok(vec![DataBlock::new_from_columns(vec![formatted_plan])])
+    }
+
     pub async fn explain_pipeline(
         &self,
         s_expr: SExpr,

src/query/sql/src/executor/format.rs

@@ -55,6 +55,59 @@ impl PhysicalPlan {
     ) -> Result<FormatTreeNode<String>> {
         to_format_tree(self, &metadata, &prof_span_set)
     }
+
+    pub fn format_join(&self, metadata: &MetadataRef) -> Result<FormatTreeNode<String>> {
+        match self {
+            PhysicalPlan::TableScan(plan) => {
+                if plan.table_index == DUMMY_TABLE_INDEX {
+                    return Ok(FormatTreeNode::with_children(
+                        format!("Scan: dummy, rows: {}", plan.source.statistics.read_rows),
+                        vec![],
+                    ));
+                }
+                let table = metadata.read().table(plan.table_index).clone();
+                let table_name =
+                    format!("{}.{}.{}", table.catalog(), table.database(), table.name());
+
+                Ok(FormatTreeNode::with_children(
+                    format!(
+                        "Scan: {}, rows: {}",
+                        table_name, plan.source.statistics.read_rows
+                    ),
+                    vec![],
+                ))
+            }
+            PhysicalPlan::HashJoin(plan) => {
+                let build_child = plan.build.format_join(metadata)?;
+                let probe_child = plan.probe.format_join(metadata)?;
+
+                let children = vec![
+                    FormatTreeNode::with_children("Build".to_string(), vec![build_child]),
+                    FormatTreeNode::with_children("Probe".to_string(), vec![probe_child]),
+                ];
+
+                Ok(FormatTreeNode::with_children(
+                    format!("HashJoin: {}", plan.join_type),
+                    children,
+                ))
+            }
+            other => {
+                let children = other
+                    .children()
+                    .map(|child| child.format_join(metadata))
+                    .collect::<Result<Vec<FormatTreeNode<String>>>>()?;
+
+                if children.len() == 1 {
+                    Ok(children[0].clone())
+                } else {
+                    Ok(FormatTreeNode::with_children(
+                        format!("{:?}", other),
+                        children,
+                    ))
+                }
+            }
+        }
+    }
 }
 
 fn to_format_tree(

tests/sqllogictests/suites/mode/standalone/explain/join_reorder/chain.test

@@ -451,5 +451,14 @@ HashJoin
     ├── push downs: [filters: [], limit: NONE]
     └── estimated rows: 10.00
 
+query T
+explain join select * from t right anti join t1 on t1.a = t.a
+----
+HashJoin: LEFT ANTI
+├── Build
+│   └── Scan: default.join_reorder.t, rows: 1
+└── Probe
+    └── Scan: default.join_reorder.t1, rows: 10
+
 statement ok
 drop database join_reorder