- SystemPlan is only produced by the SQL binder and that binder always runs in a QueryContext whose tenant is fixed to GlobalConfig::instance().query.tenant_id unless the server

    is in management mode. When management mode is enabled, ManagementModeAccess blocks Plan::System altogether so no user query can ever build a system
    action with a different tenant. As a result, the tenant field inside SystemPlan was guaranteed to equal the global config tenant and provided no extra routing information anywhere else in the stack.
- All flight actions (system_action, kill_query, set_priority, truncate_table) run inside a query server whose GlobalConfig already defines a single tenant. There is no supported deployment where a single query process serves
    multiple tenants concurrently over flight RPC. Therefore, the create_session helper in src/query/service/src/servers/flight/v1/actions/mod.rs can safely derive the tenant from GlobalConfig every time; the optional parameter was
    never used to switch context to another tenant.
- Because both ends (planner and flight handler) collapse to the same static tenant, the tenant field in SystemPlan and the Option<Tenant> parameter to create_session were redundant wiring that couldn't change behavior. Removing
    them simplifies the code without affecting any observable semantics and makes it clear that system/flight actions always run under the server's configured tenant.

Author: TCeason

src/meta/app/src/tenant/tenant.rs

@@ -24,7 +24,7 @@ use crate::app_error::TenantIsEmpty;
 /// Tenant is not stored directly in meta-store.
 ///
 /// It is just a type for use on the client side.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Tenant {
     // TODO: consider using NonEmptyString?
     pub tenant: String,

src/query/service/src/servers/flight/v1/actions/kill_query.rs

@@ -24,7 +24,7 @@ use crate::servers::flight::v1::actions::create_session;
 pub static KILL_QUERY: &str = "/actions/kill_query";
 
 pub async fn kill_query(plan: KillPlan) -> Result<bool> {
-    let session = create_session(None)?;
+    let session = create_session()?;
     let version = GlobalConfig::version();
     let query_context = session.create_query_context(version).await?;
     let interpreter = KillInterpreter::from_flight(query_context, plan)?;

src/query/service/src/servers/flight/v1/actions/mod.rs

@@ -27,7 +27,6 @@ use std::sync::Arc;
 use databend_common_catalog::session_type::SessionType;
 use databend_common_config::GlobalConfig;
 use databend_common_exception::Result;
-use databend_common_meta_app::tenant::Tenant;
 use databend_common_settings::Settings;
 pub use flight_actions::flight_actions;
 pub use flight_actions::FlightActions;
@@ -44,10 +43,10 @@ pub use truncate_table::TRUNCATE_TABLE;
 use crate::sessions::Session;
 use crate::sessions::SessionManager;
 
-pub(crate) fn create_session(tenant: Option<Tenant>) -> Result<Arc<Session>> {
+pub(crate) fn create_session() -> Result<Arc<Session>> {
     let config = GlobalConfig::instance();
-    let tenant_id = tenant.unwrap_or(config.query.tenant_id.clone());
-    let settings = Settings::create(tenant_id.clone());
+    let tenant_id = config.query.tenant_id.clone();
+    let settings = Settings::create(tenant_id);
     match SessionManager::instance().create_with_settings(SessionType::FlightRPC, settings, None) {
         Err(cause) => Err(cause),
         Ok(session) => Ok(Arc::new(session)),

src/query/service/src/servers/flight/v1/actions/set_priority.rs

@@ -24,7 +24,7 @@ use crate::servers::flight::v1::actions::create_session;
 pub static SET_PRIORITY: &str = "/actions/set_priority";
 
 pub async fn set_priority(plan: SetPriorityPlan) -> Result<bool> {
-    let session = create_session(None)?;
+    let session = create_session()?;
     let version = GlobalConfig::version();
     let query_context = session.create_query_context(version).await?;
     let interpreter = SetPriorityInterpreter::from_flight(query_context, plan)?;

src/query/service/src/servers/flight/v1/actions/system_action.rs

@@ -23,7 +23,7 @@ use crate::servers::flight::v1::actions::create_session;
 pub static SYSTEM_ACTION: &str = "/actions/system_action";
 
 pub async fn system_action(plan: SystemPlan) -> Result<()> {
-    let session = create_session(Some(plan.clone().tenant))?;
+    let session = create_session()?;
     let version = GlobalConfig::version();
     let query_context = session.create_query_context(version).await?;
     let interpreter = SystemActionInterpreter::from_flight(query_context, plan)?;

src/query/service/src/servers/flight/v1/actions/truncate_table.rs

@@ -23,7 +23,7 @@ use crate::servers::flight::v1::actions::create_session;
 pub static TRUNCATE_TABLE: &str = "/actions/truncate_table";
 
 pub async fn truncate_table(plan: TruncateTablePlan) -> Result<()> {
-    let session = create_session(None)?;
+    let session = create_session()?;
     let version = GlobalConfig::version();
     let query_context = session.create_query_context(version).await?;
     let interpreter = TruncateTableInterpreter::from_flight(query_context, plan)?;

src/query/sql/src/planner/binder/system.rs

@@ -25,15 +25,12 @@ impl Binder {
     #[async_backtrace::framed]
     pub(super) async fn bind_system(&mut self, stmt: &SystemStmt) -> Result<Plan> {
         let SystemStmt { action } = stmt;
-        let tenant = self.ctx.get_tenant();
         match action {
             AstSystemAction::Backtrace(switch) => Ok(Plan::System(Box::new(SystemPlan {
                 action: SystemAction::Backtrace(*switch),
-                tenant,
             }))),
             AstSystemAction::FlushPrivileges => Ok(Plan::System(Box::new(SystemPlan {
                 action: SystemAction::FlushPrivileges,
-                tenant,
             }))),
         }
     }

src/query/sql/src/planner/plans/system.rs

@@ -12,14 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use databend_common_meta_app::tenant::Tenant;
 use serde::Deserialize;
 use serde::Serialize;
 
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
 pub struct SystemPlan {
     pub action: SystemAction,
-    pub tenant: Tenant,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]