Merge pull request #7737 from leiysky/fix-explain-ast

fix(planner): Fix `EXPLAIN AST` for invalid query

Author: mergify[bot]

src/query/service/src/interpreters/access/privilege_access.rs

@@ -212,6 +212,8 @@ impl AccessChecker for PrivilegeAccess {
             Plan::ShowShares(_) => {}
             Plan::ShowObjectGrantPrivileges(_) => {}
             Plan::ShowGrantTenantsOfShare(_) => {}
+            Plan::ExplainAst { .. } => {}
+            Plan::ExplainSyntax { .. } => {}
         }
 
         Ok(())

src/query/service/src/interpreters/interpreter_factory.rs

@@ -39,10 +39,10 @@ impl InterpreterFactory {
     pub async fn get(ctx: Arc<QueryContext>, plan: PlanNode) -> Result<Arc<dyn Interpreter>> {
         // Check the access permission.
         let access_checker = Accessor::create(ctx.clone());
-        access_checker
-            .check(&plan)
-            .await
-            .map(|e| error!("Access.denied(v1): {:?}", e))?;
+        access_checker.check(&plan).await.map_err(|e| {
+            error!("Access.denied(v1): {:?}", e);
+            e
+        })?;
 
         let inner = Self::create_interpreter(ctx.clone(), &plan)?;
         let query_kind = plan.name().to_string();

src/query/service/src/interpreters/interpreter_factory_v2.rs

@@ -14,6 +14,7 @@
 
 use std::sync::Arc;
 
+use common_ast::ast::ExplainKind;
 use common_exception::Result;
 use tracing::error;
 
@@ -46,10 +47,10 @@ impl InterpreterFactoryV2 {
     pub async fn get(ctx: Arc<QueryContext>, plan: &Plan) -> Result<InterpreterPtr> {
         // Check the access permission.
         let access_checker = Accessor::create(ctx.clone());
-        access_checker
-            .check_new(plan)
-            .await
-            .map(|e| error!("Access.denied(v2): {:?}", e))?;
+        access_checker.check_new(plan).await.map_err(|e| {
+            error!("Access.denied(v2): {:?}", e);
+            e
+        })?;
 
         let inner = InterpreterFactoryV2::create_interpreter(ctx.clone(), plan)?;
 
@@ -78,6 +79,20 @@ impl InterpreterFactoryV2 {
                 *plan.clone(),
                 kind.clone(),
             )?)),
+            Plan::ExplainAst { formatted_string } => {
+                Ok(Arc::new(ExplainInterpreterV2::try_create(
+                    ctx,
+                    plan.clone(),
+                    ExplainKind::Ast(formatted_string.clone()),
+                )?))
+            }
+            Plan::ExplainSyntax { formatted_sql } => {
+                Ok(Arc::new(ExplainInterpreterV2::try_create(
+                    ctx,
+                    plan.clone(),
+                    ExplainKind::Syntax(formatted_sql.clone()),
+                )?))
+            }
 
             Plan::Call(plan) => Ok(Arc::new(CallInterpreter::try_create(ctx, *plan.clone())?)),
 

src/query/service/src/servers/mysql/mysql_interactive_worker.rs

@@ -64,6 +64,8 @@ fn has_result_set_by_plan(plan: &Plan) -> bool {
         plan,
         Plan::Query { .. }
             | Plan::Explain { .. }
+            | Plan::ExplainAst { .. }
+            | Plan::ExplainSyntax { .. }
             | Plan::Call(_)
             | Plan::ShowCreateDatabase(_)
             | Plan::ShowCreateTable(_)
@@ -221,10 +223,10 @@ impl<W: AsyncWrite + Send + Sync + Unpin> AsyncMysqlShim<W> for InteractiveWorke
         let mut writer = DFQueryResultWriter::create(writer);
 
         let instant = Instant::now();
-        let blocks = self.base.do_query(query).await;
+        let query_result = self.base.do_query(query).await;
 
         let format = self.base.session.get_format_settings()?;
-        let mut write_result = writer.write(blocks, &format).await;
+        let mut write_result = writer.write(query_result, &format).await;
 
         if let Err(cause) = write_result {
             let suffix = format!("(while in query {})", query);

src/query/service/src/sql/planner/binder/mod.rs

@@ -16,6 +16,7 @@ use std::sync::Arc;
 
 pub use aggregate::AggregateInfo;
 pub use bind_context::*;
+use common_ast::ast::ExplainKind;
 use common_ast::ast::Statement;
 use common_ast::parser::parse_sql;
 use common_ast::parser::tokenize_sql;
@@ -118,10 +119,13 @@ impl<'a> Binder {
                 }
             }
 
-            Statement::Explain { query, kind } => Plan::Explain {
-                kind: kind.clone(),
-                plan: Box::new(self.bind_statement(bind_context, query).await?),
-            },
+            Statement::Explain { query, kind } => {
+                match kind {
+                    ExplainKind::Ast(formatted_stmt) => Plan::ExplainAst { formatted_string: formatted_stmt.clone() },
+                    ExplainKind::Syntax(formatted_sql) => Plan::ExplainSyntax { formatted_sql: formatted_sql.clone() },
+                    _ => Plan::Explain { kind: kind.clone(), plan: Box::new(self.bind_statement(bind_context, query).await?) },
+                }
+            }
 
             Statement::ShowFunctions { limit } => {
                 self.bind_show_functions(bind_context, limit).await?

src/query/service/src/sql/planner/format/display_plan.rs

@@ -26,6 +26,8 @@ impl Plan {
                 let result = plan.format_indent()?;
                 Ok(format!("{:?}:\n{}", kind, result))
             }
+            Plan::ExplainAst { .. } => Ok("ExplainAst".to_string()),
+            Plan::ExplainSyntax { .. } => Ok("ExplainSyntax".to_string()),
 
             Plan::Copy(plan) => Ok(format!("{:?}", plan)),
 

src/query/service/src/sql/planner/plans/mod.rs

@@ -43,8 +43,7 @@ use common_datavalues::DataField;
 use common_datavalues::DataSchema;
 use common_datavalues::DataSchemaRef;
 use common_datavalues::DataSchemaRefExt;
-use common_datavalues::ToDataType;
-use common_datavalues::Vu8;
+use common_datavalues::StringType;
 use common_legacy_planners::AlterTableClusterKeyPlan;
 use common_legacy_planners::AlterUserPlan;
 use common_legacy_planners::AlterUserUDFPlan;
@@ -133,6 +132,12 @@ pub enum Plan {
         kind: ExplainKind,
         plan: Box<Plan>,
     },
+    ExplainAst {
+        formatted_string: String,
+    },
+    ExplainSyntax {
+        formatted_sql: String,
+    },
 
     // Copy
     Copy(Box<CopyPlanV2>),
@@ -293,6 +298,8 @@ impl Display for Plan {
             Plan::ShowShares(_) => write!(f, "ShowShares"),
             Plan::ShowObjectGrantPrivileges(_) => write!(f, "ShowObjectGrantPrivileges"),
             Plan::ShowGrantTenantsOfShare(_) => write!(f, "ShowGrantTenantsOfShare"),
+            Plan::ExplainAst { .. } => write!(f, "ExplainAst"),
+            Plan::ExplainSyntax { .. } => write!(f, "ExplainSyntax"),
         }
     }
 }
@@ -307,8 +314,8 @@ impl Plan {
                 bind_context,
                 ..
             } => bind_context.output_schema(),
-            Plan::Explain { kind: _, plan: _ } => {
-                DataSchemaRefExt::create(vec![DataField::new("explain", Vu8::to_data_type())])
+            Plan::Explain { .. } | Plan::ExplainAst { .. } | Plan::ExplainSyntax { .. } => {
+                DataSchemaRefExt::create(vec![DataField::new("explain", StringType::new_impl())])
             }
             Plan::Copy(_) => Arc::new(DataSchema::empty()),
             Plan::ShowCreateDatabase(plan) => plan.schema(),

tests/logictest/suites/mode/standalone/explain/explain.test

@@ -498,6 +498,21 @@ CreateUser (children 3)
 ├── AuthType sha256_password
 └── Password "new_password"
 
+statement query T
+explain ast select unknown_table.a + 1 from unknown_table1;
+
+----
+Query (children 1)
+└── QueryBody (children 1)
+    └── SelectQuery (children 2)
+        ├── SelectList (children 1)
+        │   └── Target (children 1)
+        │       └── Function + (children 2)
+        │           ├── ColumnIdentifier unknown_table.a
+        │           └── Literal Integer(1)
+        └── TableList (children 1)
+            └── TableIdentifier unknown_table1
+
 statement ok
 drop table t1;