chore(query): unify the accessor check

Author: BohuTANG

Makefile

@@ -18,13 +18,14 @@ fmt:
 
 lint:
 	cargo fmt --all
+	cargo clippy --workspace --all-targets -- -D warnings
+
 	# Cargo.toml file formatter(make setup to install)
 	taplo fmt
 	# Python file formatter(make setup to install)
 	yapf -ri tests/
 	# Bash file formatter(make setup to install)
 	shfmt -l -w scripts/*
-	cargo clippy --workspace --all-targets -- -D warnings
 
 lint-yaml:
 	yamllint -f auto .

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

@@ -0,0 +1,58 @@
+// 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::collections::HashMap;
+use std::sync::Arc;
+
+use common_exception::Result;
+use common_legacy_planners::PlanNode;
+
+use crate::interpreters::ManagementModeAccess;
+use crate::sessions::QueryContext;
+use crate::sql::plans::Plan;
+
+pub trait AccessChecker: Sync + Send {
+    // Check the access permission for the old plan.
+    // TODO(bohu): Remove after new plan done.
+    fn check(&self, plan: &PlanNode) -> Result<()>;
+
+    // Check the access permission for the old plan.
+    fn check_new(&self, _plan: &Plan) -> Result<()>;
+}
+
+pub struct Accessor {
+    accessors: HashMap<String, Box<dyn AccessChecker>>,
+}
+
+impl Accessor {
+    pub fn create(ctx: Arc<QueryContext>) -> Self {
+        let mut accessors: HashMap<String, Box<dyn AccessChecker>> = Default::default();
+        accessors.insert("management".to_string(), ManagementModeAccess::create(ctx));
+        Accessor { accessors }
+    }
+
+    pub fn check(&self, new_plan: &Option<Plan>, plan: &PlanNode) -> Result<()> {
+        for accessor in self.accessors.values() {
+            match new_plan {
+                None => {
+                    accessor.check(plan)?;
+                }
+                Some(new) => {
+                    accessor.check_new(new)?;
+                }
+            }
+        }
+        Ok(())
+    }
+}

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

@@ -18,6 +18,7 @@ use common_exception::ErrorCode;
 use common_exception::Result;
 use common_legacy_planners::PlanNode;
 
+use crate::interpreters::access::AccessChecker;
 use crate::sessions::QueryContext;
 use crate::sessions::TableContext;
 use crate::sql::plans::Plan;
@@ -27,12 +28,14 @@ pub struct ManagementModeAccess {
 }
 
 impl ManagementModeAccess {
-    pub fn create(ctx: Arc<QueryContext>) -> Self {
-        ManagementModeAccess { ctx }
+    pub fn create(ctx: Arc<QueryContext>) -> Box<dyn AccessChecker> {
+        Box::new(ManagementModeAccess { ctx })
     }
+}
 
+impl AccessChecker for ManagementModeAccess {
     // Check what we can do if in management mode.
-    pub fn check(&self, plan: &PlanNode) -> Result<()> {
+    fn check(&self, plan: &PlanNode) -> Result<()> {
         // Allows for management-mode.
         if self.ctx.get_config().query.management_mode {
             return match plan {
@@ -47,7 +50,7 @@ impl ManagementModeAccess {
     }
 
     // Check what we can do if in management mode.
-    pub fn check_new(&self, plan: &Plan) -> Result<()> {
+    fn check_new(&self, plan: &Plan) -> Result<()> {
         // Allows for management-mode.
         if self.ctx.get_config().query.management_mode {
             let ok = match plan {

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

@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+mod accessor;
 mod management_mode_access;
 
+pub use accessor::AccessChecker;
+pub use accessor::Accessor;
 pub use management_mode_access::ManagementModeAccess;

src/query/service/src/interpreters/interpreter_factory_interceptor.rs

@@ -23,7 +23,7 @@ use common_streams::ProgressStream;
 use common_streams::SendableDataBlockStream;
 use parking_lot::Mutex;
 
-use crate::interpreters::access::ManagementModeAccess;
+use crate::interpreters::access::Accessor;
 use crate::interpreters::Interpreter;
 use crate::interpreters::InterpreterPtr;
 use crate::interpreters::InterpreterQueryLog;
@@ -41,7 +41,7 @@ pub struct InterceptorInterpreter {
     inner: InterpreterPtr,
     query_log: InterpreterQueryLog,
     source_pipe_builder: Mutex<Option<SourcePipeBuilder>>,
-    management_mode_access: ManagementModeAccess,
+    accessor_checker: Accessor,
 }
 
 impl InterceptorInterpreter {
@@ -59,7 +59,7 @@ impl InterceptorInterpreter {
             inner,
             query_log: InterpreterQueryLog::create(ctx.clone(), query_kind),
             source_pipe_builder: Mutex::new(None),
-            management_mode_access: ManagementModeAccess::create(ctx),
+            accessor_checker: Accessor::create(ctx),
         }
     }
 }
@@ -75,11 +75,8 @@ impl Interpreter for InterceptorInterpreter {
     }
 
     async fn execute(&self, ctx: Arc<QueryContext>) -> Result<SendableDataBlockStream> {
-        // Management mode access check.
-        match &self.new_plan {
-            Some(p) => self.management_mode_access.check_new(p)?,
-            _ => self.management_mode_access.check(&self.plan)?,
-        }
+        // Access check.
+        self.accessor_checker.check(&self.new_plan, &self.plan)?;
 
         let _ = self
             .inner