Skip to main content

frontend/
instance.rs

1// Copyright 2023 Greptime Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15pub mod builder;
16mod dashboard;
17mod grpc;
18mod influxdb;
19mod jaeger;
20mod log_handler;
21mod logs;
22mod opentsdb;
23mod otlp;
24pub mod prom_store;
25mod promql;
26mod region_query;
27pub mod standalone;
28
29use std::collections::HashSet;
30use std::pin::Pin;
31use std::sync::atomic::AtomicBool;
32use std::sync::{Arc, atomic};
33use std::time::{Duration, SystemTime};
34
35use async_stream::stream;
36use async_trait::async_trait;
37use auth::{
38    PermissionChecker, PermissionCheckerRef, PermissionReq, PermissionTableTarget,
39    PermissionTableTargets,
40};
41use catalog::CatalogManagerRef;
42use catalog::process_manager::{
43    ProcessManagerRef, QueryStatement as CatalogQueryStatement, SlowQueryTimer,
44};
45use client::OutputData;
46use common_base::Plugins;
47use common_base::cancellation::CancellableFuture;
48use common_error::ext::{BoxedError, ErrorExt};
49use common_event_recorder::EventRecorderRef;
50use common_meta::cache::TableFlownodeSetCacheRef;
51use common_meta::cache_invalidator::CacheInvalidatorRef;
52use common_meta::key::TableMetadataManagerRef;
53use common_meta::key::table_name::TableNameKey;
54use common_meta::node_manager::NodeManagerRef;
55use common_meta::procedure_executor::ProcedureExecutorRef;
56use common_query::Output;
57use common_recordbatch::RecordBatchStreamWrapper;
58use common_recordbatch::error::StreamTimeoutSnafu;
59use common_telemetry::logging::SlowQueryOptions;
60use common_telemetry::{debug, error, tracing};
61use dashmap::DashMap;
62use datafusion_expr::LogicalPlan;
63use futures::{Stream, StreamExt, future};
64use lazy_static::lazy_static;
65use operator::delete::DeleterRef;
66use operator::insert::InserterRef;
67use operator::statement::{StatementExecutor, StatementExecutorRef};
68use partition::manager::PartitionRuleManagerRef;
69use pipeline::pipeline_operator::PipelineOperator;
70use prometheus::HistogramTimer;
71use promql_parser::label::Matcher;
72use query::QueryEngineRef;
73use query::metrics::OnDone;
74use query::parser::{PromQuery, QueryStatement};
75use query::query_engine::DescribeResult;
76use query::query_engine::options::{QueryOptions, validate_catalog_and_schema};
77use servers::error::{
78    self as server_error, AuthSnafu, CommonMetaSnafu, ExecuteQuerySnafu,
79    OtlpMetricModeIncompatibleSnafu, UnexpectedResultSnafu,
80};
81use servers::interceptor::{
82    PromQueryInterceptor, PromQueryInterceptorRef, SqlQueryInterceptor, SqlQueryInterceptorRef,
83};
84use servers::otlp::metrics::legacy_normalize_otlp_name;
85use servers::prometheus_handler::{
86    ParsedPromQuery, PrometheusHandler, resolve_schema_from_matchers,
87};
88use servers::query_handler::sql::SqlQueryHandler;
89use session::context::{Channel, QueryContextRef};
90use session::table_name::table_idents_to_full_name;
91use snafu::prelude::*;
92use sql::ast::ObjectNamePartExt;
93use sql::dialect::Dialect;
94use sql::parser::{ParseOptions, ParserContext};
95use sql::statements::comment::CommentObject;
96use sql::statements::copy::{CopyDatabase, CopyTable};
97use sql::statements::statement::Statement;
98use sql::statements::tql::Tql;
99use sql::util::{extract_tables_from_prom_expr_checked, extract_tables_from_statement_checked};
100use sqlparser::ast::{AnalyzeFormat, ObjectName};
101pub use standalone::StandaloneDatanodeManager;
102use table::requests::{OTLP_METRIC_COMPAT_KEY, OTLP_METRIC_COMPAT_PROM};
103use tracing::Span;
104
105use crate::error::{
106    self, CollectRecordbatchSnafu, Error, ExecLogicalPlanSnafu, ExecutePromqlSnafu, ExternalSnafu,
107    InvalidSqlSnafu, ParseSqlSnafu, PermissionSnafu, PlanStatementSnafu, Result,
108    SqlExecInterceptedSnafu, StatementTimeoutSnafu, TableOperationSnafu,
109};
110use crate::service_config::InfluxdbMergeMode;
111use crate::stream_wrapper::CancellableStreamWrapper;
112
113lazy_static! {
114    static ref OTLP_LEGACY_DEFAULT_VALUE: String = "legacy".to_string();
115}
116
117/// The frontend instance contains necessary components, and implements many
118/// traits, like [`servers::query_handler::grpc::GrpcQueryHandler`],
119/// [`servers::query_handler::sql::SqlQueryHandler`], etc.
120#[derive(Clone)]
121pub struct Instance {
122    frontend_peer_addr: String,
123    catalog_manager: CatalogManagerRef,
124    pipeline_operator: Arc<PipelineOperator>,
125    statement_executor: Arc<StatementExecutor>,
126    query_engine: QueryEngineRef,
127    plugins: Plugins,
128    inserter: InserterRef,
129    deleter: DeleterRef,
130    table_metadata_manager: TableMetadataManagerRef,
131    event_recorder: EventRecorderRef,
132    slow_query_recorder: EventRecorderRef,
133    process_manager: ProcessManagerRef,
134    slow_query_options: SlowQueryOptions,
135    influxdb_default_merge_mode: InfluxdbMergeMode,
136    trace_ingest_chunk_size: usize,
137    suspend: Arc<AtomicBool>,
138
139    // cache for otlp metrics
140    // first layer key: db-string
141    // key: direct input metric name
142    // value: if runs in legacy mode
143    otlp_metrics_table_legacy_cache: DashMap<String, DashMap<String, bool>>,
144}
145
146impl Instance {
147    pub fn frontend_peer_addr(&self) -> &str {
148        &self.frontend_peer_addr
149    }
150
151    pub fn catalog_manager(&self) -> &CatalogManagerRef {
152        &self.catalog_manager
153    }
154
155    pub fn query_engine(&self) -> &QueryEngineRef {
156        &self.query_engine
157    }
158
159    pub fn plugins(&self) -> &Plugins {
160        &self.plugins
161    }
162
163    pub fn statement_executor(&self) -> &StatementExecutorRef {
164        &self.statement_executor
165    }
166
167    pub fn table_metadata_manager(&self) -> &TableMetadataManagerRef {
168        &self.table_metadata_manager
169    }
170
171    pub fn inserter(&self) -> &InserterRef {
172        &self.inserter
173    }
174
175    pub fn process_manager(&self) -> &ProcessManagerRef {
176        &self.process_manager
177    }
178
179    /// Returns the event recorder configured for this frontend instance.
180    pub fn event_recorder(&self) -> EventRecorderRef {
181        self.event_recorder.clone()
182    }
183
184    pub fn node_manager(&self) -> &NodeManagerRef {
185        self.inserter.node_manager()
186    }
187
188    pub fn partition_manager(&self) -> &PartitionRuleManagerRef {
189        self.inserter.partition_manager()
190    }
191
192    pub fn table_flownode_set_cache(&self) -> &TableFlownodeSetCacheRef {
193        self.inserter.table_flownode_set_cache()
194    }
195
196    pub fn cache_invalidator(&self) -> &CacheInvalidatorRef {
197        self.statement_executor.cache_invalidator()
198    }
199
200    pub fn procedure_executor(&self) -> &ProcedureExecutorRef {
201        self.statement_executor.procedure_executor()
202    }
203
204    pub fn suspend_state(&self) -> Arc<AtomicBool> {
205        self.suspend.clone()
206    }
207
208    pub(crate) fn is_suspended(&self) -> bool {
209        self.suspend.load(atomic::Ordering::Relaxed)
210    }
211}
212
213fn parse_stmt(sql: &str, dialect: &(dyn Dialect + Send + Sync)) -> Result<Vec<Statement>> {
214    ParserContext::create_with_dialect(sql, dialect, ParseOptions::default()).context(ParseSqlSnafu)
215}
216
217fn validate_analyze_stream_statement(stmt: &mut Statement) -> Result<()> {
218    let Statement::Explain(explain) = stmt else {
219        return InvalidSqlSnafu {
220            err_msg: "only EXPLAIN ANALYZE VERBOSE statement is supported",
221        }
222        .fail();
223    };
224    ensure!(
225        explain.analyze && explain.verbose,
226        InvalidSqlSnafu {
227            err_msg: "statement must be EXPLAIN ANALYZE VERBOSE"
228        }
229    );
230    match explain.format {
231        None | Some(AnalyzeFormat::JSON) => {
232            // Keep explicit FORMAT JSON accepted, but pass JSON through
233            // QueryContext.explain_format instead of the statement to avoid the
234            // planner's current `EXPLAIN VERBOSE with FORMAT` limitation.
235            explain.format = None;
236            Ok(())
237        }
238        Some(_) => InvalidSqlSnafu {
239            err_msg: "only FORMAT JSON is supported for analyze stream",
240        }
241        .fail(),
242    }
243}
244
245impl Instance {
246    fn statement_slow_query_timer(
247        &self,
248        stmt: &Statement,
249        schema_name: String,
250    ) -> Option<SlowQueryTimer> {
251        if !stmt.is_readonly() || !self.slow_query_options.enable {
252            return None;
253        }
254
255        Some(SlowQueryTimer::new(
256            CatalogQueryStatement::Sql(stmt.clone()),
257            schema_name,
258            self.slow_query_options.threshold,
259            self.slow_query_options.sample_ratio,
260            self.slow_query_options.record_type,
261            self.slow_query_recorder.clone(),
262        ))
263    }
264
265    async fn query_statement(&self, stmt: Statement, query_ctx: QueryContextRef) -> Result<Output> {
266        check_permission(self.plugins.clone(), &stmt, &query_ctx)?;
267
268        let query_interceptor = self.plugins.get::<SqlQueryInterceptorRef<Error>>();
269        let query_interceptor = query_interceptor.as_ref();
270
271        if should_track_statement_process(&stmt) {
272            let catalog_name = query_ctx.current_catalog().to_string();
273            let schema_name = query_ctx.current_schema();
274            let slow_query_timer = self.statement_slow_query_timer(&stmt, schema_name.clone());
275
276            let ticket = self.process_manager.register_query(
277                catalog_name,
278                vec![schema_name],
279                stmt.to_string(),
280                query_ctx.conn_info().to_string(),
281                Some(query_ctx.process_id()),
282                slow_query_timer,
283            );
284
285            let query_fut = self.exec_statement_with_timeout(stmt, query_ctx, query_interceptor);
286
287            CancellableFuture::new(query_fut, ticket.cancellation_handle.clone())
288                .await
289                .map_err(|_| error::CancelledSnafu.build())?
290                .map(|output| {
291                    let Output { meta, data } = output;
292
293                    let data = match data {
294                        OutputData::Stream(stream) => OutputData::Stream(Box::pin(
295                            CancellableStreamWrapper::new(stream, ticket),
296                        )),
297                        other => other,
298                    };
299                    Output { data, meta }
300                })
301        } else {
302            self.exec_statement_with_timeout(stmt, query_ctx, query_interceptor)
303                .await
304        }
305    }
306
307    async fn exec_statement_with_timeout(
308        &self,
309        stmt: Statement,
310        query_ctx: QueryContextRef,
311        query_interceptor: Option<&SqlQueryInterceptorRef<Error>>,
312    ) -> Result<Output> {
313        let timeout = derive_timeout(&stmt, &query_ctx);
314        match timeout {
315            Some(timeout) => {
316                let start = tokio::time::Instant::now();
317                let output = tokio::time::timeout(
318                    timeout,
319                    self.exec_statement(stmt, query_ctx, query_interceptor),
320                )
321                .await
322                .map_err(|_| StatementTimeoutSnafu.build())??;
323                let output = map_query_output(output)?;
324                // compute remaining timeout
325                let remaining_timeout = timeout.checked_sub(start.elapsed()).unwrap_or_default();
326                attach_timeout(output, remaining_timeout)
327            }
328            None => self
329                .exec_statement(stmt, query_ctx, query_interceptor)
330                .await
331                .and_then(map_query_output),
332        }
333    }
334
335    async fn exec_statement(
336        &self,
337        stmt: Statement,
338        query_ctx: QueryContextRef,
339        query_interceptor: Option<&SqlQueryInterceptorRef<Error>>,
340    ) -> Result<Output> {
341        match stmt {
342            Statement::Query(_) | Statement::Explain(_) | Statement::Delete(_) => {
343                // TODO: remove this when format is supported in datafusion
344                if let Statement::Explain(explain) = &stmt
345                    && let Some(format) = explain.format()
346                {
347                    query_ctx.set_explain_format(format.to_string());
348                }
349
350                self.plan_and_exec_sql(stmt, &query_ctx, query_interceptor)
351                    .await
352            }
353            Statement::Tql(tql) => {
354                self.plan_and_exec_tql(&query_ctx, query_interceptor, tql)
355                    .await
356            }
357            _ => {
358                query_interceptor.pre_execute(Some(&stmt), None, query_ctx.clone())?;
359                self.statement_executor
360                    .execute_sql(stmt, query_ctx)
361                    .await
362                    .context(TableOperationSnafu)
363            }
364        }
365    }
366
367    async fn plan_and_exec_sql(
368        &self,
369        stmt: Statement,
370        query_ctx: &QueryContextRef,
371        query_interceptor: Option<&SqlQueryInterceptorRef<Error>>,
372    ) -> Result<Output> {
373        let stmt = QueryStatement::Sql(stmt);
374        let plan = self
375            .statement_executor
376            .plan(&stmt, query_ctx.clone())
377            .await?;
378        let QueryStatement::Sql(stmt) = stmt else {
379            unreachable!()
380        };
381        query_interceptor.pre_execute(Some(&stmt), Some(&plan), query_ctx.clone())?;
382
383        self.statement_executor
384            .exec_plan(plan, query_ctx.clone())
385            .await
386            .context(TableOperationSnafu)
387    }
388
389    async fn plan_and_exec_tql(
390        &self,
391        query_ctx: &QueryContextRef,
392        query_interceptor: Option<&SqlQueryInterceptorRef<Error>>,
393        tql: Tql,
394    ) -> Result<Output> {
395        let plan = self
396            .statement_executor
397            .plan_tql(tql.clone(), query_ctx)
398            .await?;
399        query_interceptor.pre_execute(
400            Some(&Statement::Tql(tql)),
401            Some(&plan),
402            query_ctx.clone(),
403        )?;
404        self.statement_executor
405            .exec_plan(plan, query_ctx.clone())
406            .await
407            .context(TableOperationSnafu)
408    }
409
410    async fn check_otlp_legacy(
411        &self,
412        names: &[String],
413        ctx: &QueryContextRef,
414    ) -> server_error::Result<bool> {
415        let db_string = ctx.get_db_string();
416        // fast cache check
417        let cache = self
418            .otlp_metrics_table_legacy_cache
419            .entry(db_string.clone())
420            .or_default();
421        if let Some(flag) = fast_legacy_check(&cache, names)? {
422            return Ok(flag);
423        }
424        // release cache reference to avoid lock contention
425        drop(cache);
426
427        let catalog = ctx.current_catalog();
428        let schema = ctx.current_schema();
429
430        // query legacy table names
431        let normalized_names = names
432            .iter()
433            .map(|n| legacy_normalize_otlp_name(n))
434            .collect::<Vec<_>>();
435        let table_names = normalized_names
436            .iter()
437            .map(|n| TableNameKey::new(catalog, &schema, n))
438            .collect::<Vec<_>>();
439        let table_values = self
440            .table_metadata_manager()
441            .table_name_manager()
442            .batch_get(table_names)
443            .await
444            .context(CommonMetaSnafu)?;
445        let table_ids = table_values
446            .into_iter()
447            .filter_map(|v| v.map(|vi| vi.table_id()))
448            .collect::<Vec<_>>();
449
450        // means no existing table is found, use new mode
451        if table_ids.is_empty() {
452            return Ok(false);
453        }
454
455        // has existing table, check table options
456        let table_infos = self
457            .table_metadata_manager()
458            .table_info_manager()
459            .batch_get(&table_ids)
460            .await
461            .context(CommonMetaSnafu)?;
462        let options = table_infos
463            .values()
464            .map(|info| {
465                info.table_info
466                    .meta
467                    .options
468                    .extra_options
469                    .get(OTLP_METRIC_COMPAT_KEY)
470                    .unwrap_or(&OTLP_LEGACY_DEFAULT_VALUE)
471            })
472            .collect::<Vec<_>>();
473        if !options.is_empty() {
474            // check value consistency
475            let has_prom = options.iter().any(|opt| *opt == OTLP_METRIC_COMPAT_PROM);
476            let has_legacy = options
477                .iter()
478                .any(|opt| *opt == OTLP_LEGACY_DEFAULT_VALUE.as_str());
479            ensure!(!(has_prom && has_legacy), OtlpMetricModeIncompatibleSnafu);
480            Ok(has_legacy)
481        } else {
482            // no table info, use new mode
483            Ok(false)
484        }
485    }
486
487    fn cache_otlp_legacy(
488        &self,
489        names: &[String],
490        ctx: &QueryContextRef,
491        is_legacy: bool,
492    ) -> server_error::Result<()> {
493        let cache = self
494            .otlp_metrics_table_legacy_cache
495            .entry(ctx.get_db_string())
496            .or_default();
497        cache_legacy_mode(&cache, names, is_legacy)
498    }
499}
500
501fn fast_legacy_check(
502    cache: &DashMap<String, bool>,
503    names: &[String],
504) -> server_error::Result<Option<bool>> {
505    let hit_cache = names
506        .iter()
507        .filter_map(|name| cache.get(name))
508        .collect::<Vec<_>>();
509    if !hit_cache.is_empty() {
510        let hit_legacy = hit_cache.iter().any(|en| *en.value());
511        let hit_prom = hit_cache.iter().any(|en| !*en.value());
512
513        // hit but have true and false, means both legacy and new mode are used
514        // we cannot handle this case, so return error
515        // add doc links in err msg later
516        ensure!(!(hit_legacy && hit_prom), OtlpMetricModeIncompatibleSnafu);
517
518        Ok(Some(hit_legacy))
519    } else {
520        Ok(None)
521    }
522}
523
524fn cache_legacy_mode(
525    cache: &DashMap<String, bool>,
526    names: &[String],
527    is_legacy: bool,
528) -> server_error::Result<()> {
529    for name in names {
530        let cached = cache.entry(name.clone()).or_insert(is_legacy);
531        ensure!(*cached == is_legacy, OtlpMetricModeIncompatibleSnafu);
532    }
533    Ok(())
534}
535
536/// If the relevant variables are set, the timeout is enforced for all PostgreSQL statements.
537/// For MySQL, it applies only to read-only statements.
538fn derive_timeout(stmt: &Statement, query_ctx: &QueryContextRef) -> Option<Duration> {
539    let query_timeout = query_ctx.query_timeout()?;
540    if query_timeout.is_zero() {
541        return None;
542    }
543    match query_ctx.channel() {
544        Channel::Mysql if stmt.is_readonly() => Some(query_timeout),
545        Channel::Postgres => Some(query_timeout),
546        _ => None,
547    }
548}
549
550/// Derives timeout for plan execution.
551fn derive_timeout_for_plan(plan: &LogicalPlan, query_ctx: &QueryContextRef) -> Option<Duration> {
552    let query_timeout = query_ctx.query_timeout()?;
553    if query_timeout.is_zero() {
554        return None;
555    }
556    match query_ctx.channel() {
557        Channel::Mysql if is_readonly_plan(plan) => Some(query_timeout),
558        Channel::Postgres => Some(query_timeout),
559        _ => None,
560    }
561}
562
563fn attach_timeout(output: Output, mut timeout: Duration) -> Result<Output> {
564    if timeout.is_zero() {
565        return StatementTimeoutSnafu.fail();
566    }
567
568    let output = match output.data {
569        OutputData::AffectedRows(_) | OutputData::RecordBatches(_) => output,
570        OutputData::Stream(mut stream) => {
571            let schema = stream.schema();
572            let s = Box::pin(stream! {
573                let mut start = tokio::time::Instant::now();
574                while let Some(item) = tokio::time::timeout(timeout, stream.next()).await.map_err(|_| StreamTimeoutSnafu.build())? {
575                    yield item;
576
577                    let now = tokio::time::Instant::now();
578                    timeout = timeout.checked_sub(now - start).unwrap_or(Duration::ZERO);
579                    start = now;
580                    // tokio::time::timeout may not return an error immediately when timeout is 0.
581                    if timeout.is_zero() {
582                        StreamTimeoutSnafu.fail()?;
583                    }
584                }
585            }) as Pin<Box<dyn Stream<Item = _> + Send>>;
586            let stream = RecordBatchStreamWrapper {
587                schema,
588                stream: s,
589                output_ordering: None,
590                metrics: Default::default(),
591                span: Span::current(),
592            };
593            Output::new(OutputData::Stream(Box::pin(stream)), output.meta)
594        }
595    };
596
597    Ok(output)
598}
599
600impl Instance {
601    async fn check_sql_permission(
602        &self,
603        stmt: &Statement,
604        query_ctx: &QueryContextRef,
605    ) -> Result<()> {
606        self.plugins
607            .get::<PermissionCheckerRef>()
608            .as_ref()
609            .check_permission_with_context(
610                query_ctx.current_user(),
611                PermissionReq::SqlStatement(stmt),
612                Some(&query_ctx.current_schema()),
613            )
614            .context(PermissionSnafu)?;
615
616        let targets = match extract_tables_from_statement_checked(stmt) {
617            Some(tables) => PermissionTableTargets::resolved(
618                tables
619                    .map(|name| {
620                        table_idents_to_full_name(&name, query_ctx).map(
621                            |(catalog, schema, table)| {
622                                PermissionTableTarget::new(catalog, schema, table)
623                            },
624                        )
625                    })
626                    .collect::<std::result::Result<Vec<_>, _>>()
627                    .map_err(BoxedError::new)
628                    .context(ExternalSnafu)?,
629            ),
630            None => PermissionTableTargets::Unresolved,
631        };
632        let targets = self
633            .resolve_query_permission_targets(targets, query_ctx)
634            .await
635            .map_err(BoxedError::new)
636            .context(ExternalSnafu)?;
637        self.check_table_permission(query_ctx, PermissionReq::SqlStatement(stmt), targets)
638            .context(PermissionSnafu)?;
639        Ok(())
640    }
641
642    #[tracing::instrument(skip_all, name = "SqlQueryHandler::do_analyze_stream_query")]
643    async fn do_analyze_stream_query_inner(
644        &self,
645        query: &str,
646        query_ctx: QueryContextRef,
647    ) -> Result<Output> {
648        ensure!(!self.is_suspended(), error::SuspendedSnafu);
649
650        let query_interceptor_opt = self.plugins.get::<SqlQueryInterceptorRef<Error>>();
651        let query_interceptor = query_interceptor_opt.as_ref();
652        let query = query_interceptor.pre_parsing(query, query_ctx.clone())?;
653        let mut stmts = parse_stmt(query.as_ref(), query_ctx.sql_dialect())
654            .and_then(|stmts| query_interceptor.post_parsing(stmts, query_ctx.clone()))?;
655
656        ensure!(
657            stmts.len() == 1,
658            InvalidSqlSnafu {
659                err_msg: "only single EXPLAIN ANALYZE VERBOSE statement is supported"
660            }
661        );
662        let mut stmt = stmts.remove(0);
663        validate_analyze_stream_statement(&mut stmt)?;
664        query_ctx.set_explain_format(AnalyzeFormat::JSON.to_string());
665
666        self.check_sql_permission(&stmt, &query_ctx).await?;
667        check_permission(self.plugins.clone(), &stmt, &query_ctx)?;
668        let catalog_name = query_ctx.current_catalog().to_string();
669        let schema_name = query_ctx.current_schema();
670        let slow_query_timer = self.statement_slow_query_timer(&stmt, schema_name.clone());
671        let ticket = self.process_manager.register_query(
672            catalog_name,
673            vec![schema_name],
674            stmt.to_string(),
675            query_ctx.conn_info().to_string(),
676            Some(query_ctx.process_id()),
677            slow_query_timer,
678        );
679        let query_fut =
680            self.exec_statement_with_timeout(stmt, query_ctx.clone(), query_interceptor);
681        let output = CancellableFuture::new(query_fut, ticket.cancellation_handle.clone())
682            .await
683            .map_err(|_| error::CancelledSnafu.build())??;
684        let Output { meta, data } = output;
685        let data = match data {
686            OutputData::Stream(stream) => OutputData::Stream(Box::pin(
687                CancellableStreamWrapper::new_cancel_on_drop(stream, ticket),
688            )),
689            other => other,
690        };
691        query_interceptor.post_execute(Output { data, meta }, query_ctx)
692    }
693
694    #[tracing::instrument(skip_all, name = "SqlQueryHandler::do_query")]
695    async fn do_query_inner(&self, query: &str, query_ctx: QueryContextRef) -> Vec<Result<Output>> {
696        if self.is_suspended() {
697            return vec![error::SuspendedSnafu {}.fail()];
698        }
699
700        let query_interceptor_opt = self.plugins.get::<SqlQueryInterceptorRef<Error>>();
701        let query_interceptor = query_interceptor_opt.as_ref();
702        let query = match query_interceptor.pre_parsing(query, query_ctx.clone()) {
703            Ok(q) => q,
704            Err(e) => return vec![Err(e)],
705        };
706
707        match parse_stmt(query.as_ref(), query_ctx.sql_dialect())
708            .and_then(|stmts| query_interceptor.post_parsing(stmts, query_ctx.clone()))
709        {
710            Ok(stmts) => {
711                if stmts.is_empty() {
712                    return vec![
713                        InvalidSqlSnafu {
714                            err_msg: "empty statements",
715                        }
716                        .fail(),
717                    ];
718                }
719
720                let mut results = Vec::with_capacity(stmts.len());
721                for stmt in stmts {
722                    if let Err(e) = self.check_sql_permission(&stmt, &query_ctx).await {
723                        results.push(Err(e));
724                        break;
725                    }
726
727                    match self.query_statement(stmt.clone(), query_ctx.clone()).await {
728                        Ok(output) => {
729                            let output_result =
730                                query_interceptor.post_execute(output, query_ctx.clone());
731                            results.push(output_result);
732                        }
733                        Err(e) => {
734                            if e.status_code().should_log_error() {
735                                error!(e; "Failed to execute query: {stmt}");
736                            } else {
737                                debug!("Failed to execute query: {stmt}, {e}");
738                            }
739                            results.push(Err(e));
740                            break;
741                        }
742                    }
743                }
744                results
745            }
746            Err(e) => {
747                vec![Err(e)]
748            }
749        }
750    }
751
752    async fn exec_plan(&self, plan: LogicalPlan, query_ctx: QueryContextRef) -> Result<Output> {
753        self.query_engine
754            .execute(plan, query_ctx)
755            .await
756            .context(ExecLogicalPlanSnafu)
757    }
758
759    async fn exec_plan_with_timeout(
760        &self,
761        plan: LogicalPlan,
762        query_ctx: QueryContextRef,
763    ) -> Result<Output> {
764        let timeout = derive_timeout_for_plan(&plan, &query_ctx);
765        match timeout {
766            Some(timeout) => {
767                let start = tokio::time::Instant::now();
768                let output = tokio::time::timeout(timeout, self.exec_plan(plan, query_ctx))
769                    .await
770                    .map_err(|_| StatementTimeoutSnafu.build())??;
771                let output = map_query_output(output)?;
772                let remaining_timeout = timeout.checked_sub(start.elapsed()).unwrap_or_default();
773                attach_timeout(output, remaining_timeout)
774            }
775            None => self
776                .exec_plan(plan, query_ctx)
777                .await
778                .and_then(map_query_output),
779        }
780    }
781
782    async fn do_exec_plan_inner(
783        &self,
784        plan: LogicalPlan,
785        stmt: Option<Statement>,
786        query_ctx: QueryContextRef,
787    ) -> Result<Output> {
788        ensure!(!self.is_suspended(), error::SuspendedSnafu);
789
790        let query_interceptor_opt = self.plugins.get::<SqlQueryInterceptorRef<Error>>();
791        let query_interceptor = query_interceptor_opt.as_ref();
792
793        query_interceptor.pre_execute(stmt.as_ref(), Some(&plan), query_ctx.clone())?;
794
795        let query = stmt
796            .as_ref()
797            .map(|s| s.to_string())
798            .unwrap_or_else(|| plan.display_indent().to_string());
799
800        let plan_is_readonly = is_readonly_plan(&plan);
801        let result = if should_track_plan_process(stmt.as_ref(), &plan) {
802            let catalog_name = query_ctx.current_catalog().to_string();
803            let schema_name = query_ctx.current_schema();
804            let slow_query_timer = if plan_is_readonly {
805                self.slow_query_options.enable.then(|| {
806                    SlowQueryTimer::new(
807                        CatalogQueryStatement::Plan(query.clone()),
808                        schema_name.clone(),
809                        self.slow_query_options.threshold,
810                        self.slow_query_options.sample_ratio,
811                        self.slow_query_options.record_type,
812                        self.slow_query_recorder.clone(),
813                    )
814                })
815            } else {
816                None
817            };
818
819            let ticket = self.process_manager.register_query(
820                catalog_name,
821                vec![schema_name],
822                query,
823                query_ctx.conn_info().to_string(),
824                Some(query_ctx.process_id()),
825                slow_query_timer,
826            );
827
828            let query_fut = self.exec_plan_with_timeout(plan, query_ctx.clone());
829
830            CancellableFuture::new(query_fut, ticket.cancellation_handle.clone())
831                .await
832                .map_err(|_| error::CancelledSnafu.build())?
833                .map(|output| {
834                    let Output { meta, data } = output;
835
836                    let data = match data {
837                        OutputData::Stream(stream) => OutputData::Stream(Box::pin(
838                            CancellableStreamWrapper::new(stream, ticket),
839                        )),
840                        other => other,
841                    };
842                    Output { data, meta }
843                })
844        } else {
845            self.exec_plan_with_timeout(plan, query_ctx.clone()).await
846        };
847
848        result.and_then(|output| query_interceptor.post_execute(output, query_ctx))
849    }
850
851    #[tracing::instrument(skip_all, name = "SqlQueryHandler::do_promql_query")]
852    async fn do_promql_query_inner(
853        &self,
854        query: &PromQuery,
855        query_ctx: QueryContextRef,
856    ) -> Vec<Result<Output>> {
857        if self.is_suspended() {
858            return vec![error::SuspendedSnafu {}.fail()];
859        }
860
861        // check will be done in prometheus handler's do_query
862        let result = PrometheusHandler::do_query(self, query, query_ctx)
863            .await
864            .with_context(|_| ExecutePromqlSnafu {
865                query: format!("{query:?}"),
866            });
867        vec![result]
868    }
869
870    async fn do_describe_inner(
871        &self,
872        stmt: Statement,
873        query_ctx: QueryContextRef,
874    ) -> Result<Option<DescribeResult>> {
875        ensure!(!self.is_suspended(), error::SuspendedSnafu);
876
877        // EXPLAIN / EXPLAIN ANALYZE wrap an inner statement; describe them when the
878        // wrapped statement is something we already plan (so that bind parameters
879        // in the inner query get their types inferred). See #8029.
880        let is_inner_plannable = |s: &Statement| {
881            matches!(
882                s,
883                Statement::Insert(_) | Statement::Query(_) | Statement::Delete(_)
884            )
885        };
886        let plannable = is_inner_plannable(&stmt)
887            || matches!(&stmt, Statement::Explain(explain) if is_inner_plannable(explain.statement.as_ref()));
888
889        if plannable {
890            self.check_sql_permission(&stmt, &query_ctx).await?;
891
892            let plan = self
893                .query_engine
894                .planner()
895                .plan(&QueryStatement::Sql(stmt), query_ctx.clone())
896                .await
897                .context(PlanStatementSnafu)?;
898            self.query_engine
899                .describe(plan, query_ctx)
900                .await
901                .map(Some)
902                .context(error::DescribeStatementSnafu)
903        } else {
904            Ok(None)
905        }
906    }
907
908    async fn is_valid_schema_inner(&self, catalog: &str, schema: &str) -> Result<bool> {
909        self.catalog_manager
910            .schema_exists(catalog, schema, None)
911            .await
912            .context(error::CatalogSnafu)
913    }
914}
915
916#[async_trait]
917impl SqlQueryHandler for Instance {
918    async fn do_query(
919        &self,
920        query: &str,
921        query_ctx: QueryContextRef,
922    ) -> Vec<server_error::Result<Output>> {
923        self.do_query_inner(query, query_ctx)
924            .await
925            .into_iter()
926            .map(|result| result.map_err(BoxedError::new).context(ExecuteQuerySnafu))
927            .collect()
928    }
929
930    async fn do_analyze_stream_query(
931        &self,
932        query: &str,
933        query_ctx: QueryContextRef,
934    ) -> server_error::Result<Output> {
935        self.do_analyze_stream_query_inner(query, query_ctx)
936            .await
937            .map_err(BoxedError::new)
938            .context(ExecuteQuerySnafu)
939    }
940
941    async fn do_exec_plan(
942        &self,
943        plan: LogicalPlan,
944        stmt: Option<Statement>,
945        query_ctx: QueryContextRef,
946    ) -> server_error::Result<Output> {
947        self.do_exec_plan_inner(plan, stmt, query_ctx)
948            .await
949            .map_err(BoxedError::new)
950            .context(server_error::ExecutePlanSnafu)
951    }
952
953    async fn do_promql_query(
954        &self,
955        query: &PromQuery,
956        query_ctx: QueryContextRef,
957    ) -> Vec<server_error::Result<Output>> {
958        self.do_promql_query_inner(query, query_ctx)
959            .await
960            .into_iter()
961            .map(|result| result.map_err(BoxedError::new).context(ExecuteQuerySnafu))
962            .collect()
963    }
964
965    async fn do_describe(
966        &self,
967        stmt: Statement,
968        query_ctx: QueryContextRef,
969    ) -> server_error::Result<Option<DescribeResult>> {
970        self.do_describe_inner(stmt, query_ctx)
971            .await
972            .map_err(BoxedError::new)
973            .context(server_error::DescribeStatementSnafu)
974    }
975
976    async fn is_valid_schema(&self, catalog: &str, schema: &str) -> server_error::Result<bool> {
977        self.is_valid_schema_inner(catalog, schema)
978            .await
979            .map_err(BoxedError::new)
980            .context(server_error::CheckDatabaseValiditySnafu)
981    }
982}
983
984/// Expands scan-time dictionaries only when a query result leaves the frontend.
985pub(crate) fn map_query_output(output: Output) -> Result<Output> {
986    output
987        .map_dictionary_to_values()
988        .context(CollectRecordbatchSnafu)
989}
990
991/// Attaches a timer to the output and observes it once the output is exhausted.
992pub fn attach_timer(output: Output, timer: HistogramTimer) -> Output {
993    match output.data {
994        OutputData::AffectedRows(_) | OutputData::RecordBatches(_) => output,
995        OutputData::Stream(stream) => {
996            let stream = OnDone::new(stream, move || {
997                timer.observe_duration();
998            });
999            Output::new(OutputData::Stream(Box::pin(stream)), output.meta)
1000        }
1001    }
1002}
1003
1004impl Instance {
1005    fn check_prom_query_privilege(&self, query_ctx: &QueryContextRef) -> server_error::Result<()> {
1006        self.plugins
1007            .get::<PermissionCheckerRef>()
1008            .as_ref()
1009            .check_permission(query_ctx.current_user(), PermissionReq::PromQuery)
1010            .context(AuthSnafu)?;
1011        Ok(())
1012    }
1013
1014    fn prom_expr_permission_targets(
1015        &self,
1016        expr: &promql_parser::parser::Expr,
1017        query_ctx: &QueryContextRef,
1018    ) -> server_error::Result<Option<Vec<PermissionTableTarget>>> {
1019        extract_tables_from_prom_expr_checked(expr)
1020            .map(|tables| {
1021                tables
1022                    .map(|name| {
1023                        table_idents_to_full_name(&name, query_ctx).map(
1024                            |(catalog, schema, table)| {
1025                                PermissionTableTarget::new(catalog, schema, table)
1026                            },
1027                        )
1028                    })
1029                    .collect::<std::result::Result<Vec<_>, _>>()
1030                    .map_err(BoxedError::new)
1031                    .context(ExecuteQuerySnafu)
1032            })
1033            .transpose()
1034    }
1035
1036    async fn is_physical_query_permission_target(
1037        &self,
1038        target: &PermissionTableTarget,
1039        query_ctx: &QueryContextRef,
1040    ) -> server_error::Result<bool> {
1041        self.catalog_manager
1042            .table(
1043                &target.catalog,
1044                &target.schema,
1045                &target.table,
1046                Some(query_ctx),
1047            )
1048            .await
1049            .map(|table| table.is_some_and(|table| table.table_info().is_physical_table()))
1050            .map_err(BoxedError::new)
1051            .context(ExecuteQuerySnafu)
1052    }
1053
1054    async fn resolve_query_permission_targets(
1055        &self,
1056        targets: PermissionTableTargets,
1057        query_ctx: &QueryContextRef,
1058    ) -> server_error::Result<PermissionTableTargets> {
1059        const CONCURRENCY: usize = 8;
1060
1061        let checker = self.plugins.get::<PermissionCheckerRef>();
1062        if !checker.as_ref().uses_table_targets() {
1063            return Ok(targets);
1064        }
1065
1066        let PermissionTableTargets::Resolved(mut targets) = targets else {
1067            return Ok(PermissionTableTargets::Unresolved);
1068        };
1069        if targets.len() > 1 {
1070            let mut seen = HashSet::with_capacity(targets.len());
1071            targets.retain(|target| seen.insert(target.clone()));
1072        }
1073        if let [target] = targets.as_slice() {
1074            return if self
1075                .is_physical_query_permission_target(target, query_ctx)
1076                .await?
1077            {
1078                Ok(PermissionTableTargets::Unresolved)
1079            } else {
1080                Ok(PermissionTableTargets::resolved(targets))
1081            };
1082        }
1083
1084        // Bound catalog load and inspect results in target order to preserve serial semantics.
1085        for chunk in targets.chunks(CONCURRENCY) {
1086            let results = future::join_all(
1087                chunk
1088                    .iter()
1089                    .map(|target| self.is_physical_query_permission_target(target, query_ctx)),
1090            )
1091            .await;
1092            for result in results {
1093                if result? {
1094                    return Ok(PermissionTableTargets::Unresolved);
1095                }
1096            }
1097        }
1098
1099        Ok(PermissionTableTargets::resolved(targets))
1100    }
1101
1102    fn prom_queries_permission_targets(
1103        &self,
1104        queries: &[ParsedPromQuery],
1105        query_ctx: &QueryContextRef,
1106    ) -> server_error::Result<PermissionTableTargets> {
1107        let mut targets = Vec::new();
1108        let mut resolved = true;
1109
1110        for query in queries {
1111            let QueryStatement::Promql(eval_stmt, _) = query.statement() else {
1112                unreachable!("query is parsed from promql");
1113            };
1114
1115            if let Some(query_targets) =
1116                self.prom_expr_permission_targets(&eval_stmt.expr, query_ctx)?
1117            {
1118                targets.extend(query_targets);
1119            } else {
1120                resolved = false;
1121            }
1122        }
1123
1124        Ok(if resolved {
1125            PermissionTableTargets::resolved(targets)
1126        } else {
1127            PermissionTableTargets::Unresolved
1128        })
1129    }
1130}
1131
1132#[async_trait]
1133impl PrometheusHandler for Instance {
1134    #[tracing::instrument(skip_all)]
1135    async fn do_query(
1136        &self,
1137        query: &PromQuery,
1138        query_ctx: QueryContextRef,
1139    ) -> server_error::Result<Output> {
1140        let query = ParsedPromQuery::parse(query.clone(), &query_ctx)?;
1141        self.do_query_parsed(query, query_ctx).await
1142    }
1143
1144    #[tracing::instrument(skip_all)]
1145    async fn do_query_parsed(
1146        &self,
1147        query: ParsedPromQuery,
1148        query_ctx: QueryContextRef,
1149    ) -> server_error::Result<Output> {
1150        let interceptor = self
1151            .plugins
1152            .get::<PromQueryInterceptorRef<server_error::Error>>();
1153
1154        self.check_prom_query_privilege(&query_ctx)?;
1155
1156        let targets =
1157            self.prom_queries_permission_targets(std::slice::from_ref(&query), &query_ctx)?;
1158        self.check_query_target_permission(targets, &query_ctx)
1159            .await?;
1160
1161        let (query, stmt) = query.into_parts();
1162
1163        let QueryStatement::Promql(eval_stmt, _) = &stmt else {
1164            unreachable!("query is parsed from promql");
1165        };
1166
1167        let plan = self
1168            .statement_executor
1169            .plan(&stmt, query_ctx.clone())
1170            .await
1171            .map_err(BoxedError::new)
1172            .context(ExecuteQuerySnafu)?;
1173
1174        interceptor.pre_execute(&query, &eval_stmt.expr, Some(&plan), query_ctx.clone())?;
1175
1176        // Take the EvalStmt from the original QueryStatement and use it to create the CatalogQueryStatement.
1177        let query_statement = if let QueryStatement::Promql(eval_stmt, alias) = stmt {
1178            CatalogQueryStatement::Promql(eval_stmt, alias)
1179        } else {
1180            // It should not happen since the query is already parsed successfully.
1181            return UnexpectedResultSnafu {
1182                reason: "The query should always be promql.".to_string(),
1183            }
1184            .fail();
1185        };
1186        let raw_query = query_statement.to_string();
1187
1188        let slow_query_timer = self.slow_query_options.enable.then(|| {
1189            SlowQueryTimer::new(
1190                query_statement,
1191                query_ctx.current_schema(),
1192                self.slow_query_options.threshold,
1193                self.slow_query_options.sample_ratio,
1194                self.slow_query_options.record_type,
1195                self.slow_query_recorder.clone(),
1196            )
1197        });
1198
1199        let ticket = self.process_manager.register_query(
1200            query_ctx.current_catalog().to_string(),
1201            vec![query_ctx.current_schema()],
1202            raw_query,
1203            query_ctx.conn_info().to_string(),
1204            Some(query_ctx.process_id()),
1205            slow_query_timer,
1206        );
1207
1208        let query_fut = self.statement_executor.exec_plan(plan, query_ctx.clone());
1209
1210        let output = CancellableFuture::new(query_fut, ticket.cancellation_handle.clone())
1211            .await
1212            .map_err(|_| servers::error::CancelledSnafu.build())?
1213            .map_err(BoxedError::new)
1214            .context(ExecuteQuerySnafu)?;
1215        let output = map_query_output(output)
1216            .map_err(BoxedError::new)
1217            .context(ExecuteQuerySnafu)?;
1218        let Output { meta, data } = output;
1219        let data = match data {
1220            OutputData::Stream(stream) => {
1221                OutputData::Stream(Box::pin(CancellableStreamWrapper::new(stream, ticket)))
1222            }
1223            other => other,
1224        };
1225        let output = Output { data, meta };
1226        Ok(interceptor.post_execute(output, query_ctx)?)
1227    }
1228
1229    async fn check_query_permission(
1230        &self,
1231        queries: &[PromQuery],
1232        query_ctx: &QueryContextRef,
1233    ) -> server_error::Result<()> {
1234        let queries = queries
1235            .iter()
1236            .cloned()
1237            .map(|query| ParsedPromQuery::parse(query, query_ctx))
1238            .collect::<server_error::Result<Vec<_>>>()?;
1239        self.check_query_permission_parsed(&queries, query_ctx)
1240            .await
1241    }
1242
1243    async fn check_query_permission_parsed(
1244        &self,
1245        queries: &[ParsedPromQuery],
1246        query_ctx: &QueryContextRef,
1247    ) -> server_error::Result<()> {
1248        self.check_prom_query_privilege(query_ctx)?;
1249        let targets = self.prom_queries_permission_targets(queries, query_ctx)?;
1250        self.check_query_target_permission(targets, query_ctx).await
1251    }
1252
1253    async fn check_query_target_permission(
1254        &self,
1255        targets: PermissionTableTargets,
1256        query_ctx: &QueryContextRef,
1257    ) -> server_error::Result<()> {
1258        let targets = self
1259            .resolve_query_permission_targets(targets, query_ctx)
1260            .await?;
1261        self.check_table_permission(query_ctx, PermissionReq::PromQuery, targets)
1262            .context(AuthSnafu)?;
1263        Ok(())
1264    }
1265
1266    async fn filter_metadata_metric_names(
1267        &self,
1268        metric_names: Vec<String>,
1269        schema: &str,
1270        query_ctx: &QueryContextRef,
1271    ) -> server_error::Result<Vec<String>> {
1272        let checker = self.plugins.get::<PermissionCheckerRef>();
1273        if !checker.as_ref().uses_table_targets() {
1274            let Some(metric) = metric_names.first() else {
1275                return Ok(metric_names);
1276            };
1277            let target =
1278                PermissionTableTarget::new(query_ctx.current_catalog(), schema, metric.as_str());
1279            let result = checker
1280                .as_ref()
1281                .check_permission_with_table_targets(
1282                    query_ctx.current_user(),
1283                    PermissionReq::PromQuery,
1284                    PermissionTableTargets::resolved(vec![target]),
1285                )
1286                .context(AuthSnafu);
1287            return match result {
1288                Ok(_) => Ok(metric_names),
1289                Err(error)
1290                    if error.status_code()
1291                        == common_error::status_code::StatusCode::PermissionDenied =>
1292                {
1293                    Ok(Vec::new())
1294                }
1295                Err(error) => Err(error),
1296            };
1297        }
1298
1299        let mut allowed = Vec::with_capacity(metric_names.len());
1300        for metric in metric_names {
1301            let target =
1302                PermissionTableTarget::new(query_ctx.current_catalog(), schema, metric.as_str());
1303            match checker
1304                .as_ref()
1305                .check_permission_with_table_targets(
1306                    query_ctx.current_user(),
1307                    PermissionReq::PromQuery,
1308                    PermissionTableTargets::resolved(vec![target]),
1309                )
1310                .context(AuthSnafu)
1311            {
1312                Ok(_) => allowed.push(metric),
1313                Err(error)
1314                    if error.status_code()
1315                        == common_error::status_code::StatusCode::PermissionDenied => {}
1316                Err(error) => return Err(error),
1317            }
1318        }
1319        Ok(allowed)
1320    }
1321
1322    async fn query_metric_names(
1323        &self,
1324        matchers: Vec<Matcher>,
1325        schema: &str,
1326        ctx: &QueryContextRef,
1327    ) -> server_error::Result<Vec<String>> {
1328        self.handle_query_metric_names(matchers, schema, ctx)
1329            .await
1330            .map_err(BoxedError::new)
1331            .context(ExecuteQuerySnafu)
1332    }
1333
1334    async fn query_label_values(
1335        &self,
1336        metric: String,
1337        label_name: String,
1338        matchers: Vec<Matcher>,
1339        start: SystemTime,
1340        end: SystemTime,
1341        ctx: &QueryContextRef,
1342    ) -> server_error::Result<Vec<String>> {
1343        let schema =
1344            resolve_schema_from_matchers(&matchers)?.unwrap_or_else(|| ctx.current_schema());
1345        let target = PermissionTableTarget::new(ctx.current_catalog(), schema.as_str(), &metric);
1346        self.check_query_target_permission(
1347            PermissionTableTargets::resolved(vec![target.clone()]),
1348            ctx,
1349        )
1350        .await?;
1351
1352        self.handle_query_label_values(target, label_name, matchers, start, end, ctx)
1353            .await
1354            .map_err(BoxedError::new)
1355            .context(ExecuteQuerySnafu)
1356    }
1357
1358    fn catalog_manager(&self) -> CatalogManagerRef {
1359        self.catalog_manager.clone()
1360    }
1361}
1362
1363/// Validate `stmt.database` permission if it's presented.
1364macro_rules! validate_db_permission {
1365    ($stmt: expr, $query_ctx: expr) => {
1366        if let Some(database) = &$stmt.database {
1367            validate_catalog_and_schema($query_ctx.current_catalog(), database, $query_ctx)
1368                .map_err(BoxedError::new)
1369                .context(SqlExecInterceptedSnafu)?;
1370        }
1371    };
1372}
1373
1374pub fn check_permission(
1375    plugins: Plugins,
1376    stmt: &Statement,
1377    query_ctx: &QueryContextRef,
1378) -> Result<()> {
1379    let need_validate = plugins
1380        .get::<QueryOptions>()
1381        .map(|opts| opts.disallow_cross_catalog_query)
1382        .unwrap_or_default();
1383
1384    if !need_validate {
1385        return Ok(());
1386    }
1387
1388    match stmt {
1389        // Will be checked in execution.
1390        // TODO(dennis): add a hook for admin commands.
1391        Statement::Admin(_) => {}
1392        // These are executed by query engine, and will be checked there.
1393        Statement::Query(_)
1394        | Statement::Explain(_)
1395        | Statement::Tql(_)
1396        | Statement::Delete(_)
1397        | Statement::DeclareCursor(_)
1398        | Statement::Copy(sql::statements::copy::Copy::CopyQueryTo(_)) => {}
1399        // database ops won't be checked
1400        Statement::CreateDatabase(_)
1401        | Statement::ShowDatabases(_)
1402        | Statement::DropDatabase(_)
1403        | Statement::AlterDatabase(_)
1404        | Statement::DropFlow(_)
1405        | Statement::Use(_) => {}
1406        #[cfg(feature = "enterprise")]
1407        Statement::DropTrigger(_) => {}
1408        Statement::ShowCreateDatabase(stmt) => {
1409            validate_database(&stmt.database_name, query_ctx)?;
1410        }
1411        Statement::ShowCreateTable(stmt) => {
1412            validate_param(&stmt.table_name, query_ctx)?;
1413        }
1414        Statement::ShowCreateFlow(stmt) => {
1415            validate_flow(&stmt.flow_name, query_ctx)?;
1416        }
1417        #[cfg(feature = "enterprise")]
1418        Statement::ShowCreateTrigger(stmt) => {
1419            validate_param(&stmt.trigger_name, query_ctx)?;
1420        }
1421        Statement::ShowCreateView(stmt) => {
1422            validate_param(&stmt.view_name, query_ctx)?;
1423        }
1424        Statement::CreateExternalTable(stmt) => {
1425            validate_param(&stmt.name, query_ctx)?;
1426        }
1427        Statement::CreateFlow(stmt) => {
1428            // TODO: should also validate source table name here?
1429            validate_param(&stmt.sink_table_name, query_ctx)?;
1430        }
1431        #[cfg(feature = "enterprise")]
1432        Statement::CreateTrigger(stmt) => {
1433            validate_param(&stmt.trigger_name, query_ctx)?;
1434        }
1435        Statement::CreateView(stmt) => {
1436            validate_param(&stmt.name, query_ctx)?;
1437        }
1438        Statement::AlterTable(stmt) => {
1439            validate_param(stmt.table_name(), query_ctx)?;
1440        }
1441        #[cfg(feature = "enterprise")]
1442        Statement::AlterTrigger(_) => {}
1443        // set/show variable now only alter/show variable in session
1444        Statement::SetVariables(_) | Statement::ShowVariables(_) => {}
1445        // show charset and show collation won't be checked
1446        Statement::ShowCharset(_) | Statement::ShowCollation(_) => {}
1447
1448        Statement::Comment(comment) => match &comment.object {
1449            CommentObject::Table(table) => validate_param(table, query_ctx)?,
1450            CommentObject::Column { table, .. } => validate_param(table, query_ctx)?,
1451            CommentObject::Flow(flow) => validate_flow(flow, query_ctx)?,
1452        },
1453
1454        Statement::Insert(insert) => {
1455            let name = insert.table_name().context(ParseSqlSnafu)?;
1456            validate_param(name, query_ctx)?;
1457        }
1458        Statement::CreateTable(stmt) => {
1459            validate_param(&stmt.name, query_ctx)?;
1460        }
1461        Statement::CreateTableLike(stmt) => {
1462            validate_param(&stmt.table_name, query_ctx)?;
1463            validate_param(&stmt.source_name, query_ctx)?;
1464        }
1465        Statement::DropTable(drop_stmt) => {
1466            for table_name in drop_stmt.table_names() {
1467                validate_param(table_name, query_ctx)?;
1468            }
1469        }
1470        Statement::UndropTable(stmt) => {
1471            validate_param(stmt.table_name(), query_ctx)?;
1472        }
1473        Statement::DropView(stmt) => {
1474            validate_param(&stmt.view_name, query_ctx)?;
1475        }
1476        Statement::ShowTables(stmt) => {
1477            validate_db_permission!(stmt, query_ctx);
1478        }
1479        Statement::ShowTableStatus(stmt) => {
1480            validate_db_permission!(stmt, query_ctx);
1481        }
1482        Statement::ShowColumns(stmt) => {
1483            validate_db_permission!(stmt, query_ctx);
1484        }
1485        Statement::ShowIndex(stmt) => {
1486            validate_db_permission!(stmt, query_ctx);
1487        }
1488        Statement::ShowRegion(stmt) => {
1489            validate_db_permission!(stmt, query_ctx);
1490        }
1491        Statement::ShowViews(stmt) => {
1492            validate_db_permission!(stmt, query_ctx);
1493        }
1494        Statement::ShowFlows(stmt) => {
1495            validate_db_permission!(stmt, query_ctx);
1496        }
1497        #[cfg(feature = "enterprise")]
1498        Statement::ShowTriggers(_stmt) => {
1499            // The trigger is organized based on the catalog dimension, so there
1500            // is no need to check the permission of the database(schema).
1501        }
1502        Statement::ShowStatus(_stmt) => {}
1503        Statement::ShowSearchPath(_stmt) => {}
1504        Statement::DescribeTable(stmt) => {
1505            validate_param(stmt.name(), query_ctx)?;
1506        }
1507        Statement::Copy(sql::statements::copy::Copy::CopyTable(stmt)) => match stmt {
1508            CopyTable::To(copy_table_to) => validate_param(&copy_table_to.table_name, query_ctx)?,
1509            CopyTable::From(copy_table_from) => {
1510                validate_param(&copy_table_from.table_name, query_ctx)?
1511            }
1512        },
1513        Statement::Copy(sql::statements::copy::Copy::CopyDatabase(copy_database)) => {
1514            match copy_database {
1515                CopyDatabase::To(stmt) => validate_database(&stmt.database_name, query_ctx)?,
1516                CopyDatabase::From(stmt) => validate_database(&stmt.database_name, query_ctx)?,
1517            }
1518        }
1519        Statement::TruncateTable(stmt) => {
1520            validate_param(stmt.table_name(), query_ctx)?;
1521        }
1522        // cursor operations are always allowed once it's created
1523        Statement::FetchCursor(_) | Statement::CloseCursor(_) => {}
1524        // User can only kill process in their own catalog.
1525        Statement::Kill(_) => {}
1526        // SHOW PROCESSLIST
1527        Statement::ShowProcesslist(_) => {}
1528    }
1529    Ok(())
1530}
1531
1532fn validate_param(name: &ObjectName, query_ctx: &QueryContextRef) -> Result<()> {
1533    let (catalog, schema, _) = table_idents_to_full_name(name, query_ctx)
1534        .map_err(BoxedError::new)
1535        .context(ExternalSnafu)?;
1536
1537    validate_catalog_and_schema(&catalog, &schema, query_ctx)
1538        .map_err(BoxedError::new)
1539        .context(SqlExecInterceptedSnafu)
1540}
1541
1542fn validate_flow(name: &ObjectName, query_ctx: &QueryContextRef) -> Result<()> {
1543    let catalog = match &name.0[..] {
1544        [_flow] => query_ctx.current_catalog().to_string(),
1545        [catalog, _flow] => catalog.to_string_unquoted(),
1546        _ => {
1547            return InvalidSqlSnafu {
1548                err_msg: format!(
1549                    "expect flow name to be <catalog>.<flow_name> or <flow_name>, actual: {name}",
1550                ),
1551            }
1552            .fail();
1553        }
1554    };
1555
1556    let schema = query_ctx.current_schema();
1557
1558    validate_catalog_and_schema(&catalog, &schema, query_ctx)
1559        .map_err(BoxedError::new)
1560        .context(SqlExecInterceptedSnafu)
1561}
1562
1563fn validate_database(name: &ObjectName, query_ctx: &QueryContextRef) -> Result<()> {
1564    let (catalog, schema) = match &name.0[..] {
1565        [schema] => (
1566            query_ctx.current_catalog().to_string(),
1567            schema.to_string_unquoted(),
1568        ),
1569        [catalog, schema] => (catalog.to_string_unquoted(), schema.to_string_unquoted()),
1570        _ => InvalidSqlSnafu {
1571            err_msg: format!(
1572                "expect database name to be <catalog>.<schema> or <schema>, actual: {name}",
1573            ),
1574        }
1575        .fail()?,
1576    };
1577
1578    validate_catalog_and_schema(&catalog, &schema, query_ctx)
1579        .map_err(BoxedError::new)
1580        .context(SqlExecInterceptedSnafu)
1581}
1582
1583fn is_readonly_plan(plan: &LogicalPlan) -> bool {
1584    !matches!(plan, LogicalPlan::Dml(_) | LogicalPlan::Ddl(_))
1585}
1586
1587fn should_track_statement_process(stmt: &Statement) -> bool {
1588    stmt.is_readonly()
1589        || matches!(stmt, Statement::Insert(insert) if insert.has_non_values_query_source())
1590}
1591
1592fn should_track_plan_process(stmt: Option<&Statement>, plan: &LogicalPlan) -> bool {
1593    is_readonly_plan(plan)
1594        || matches!(stmt, Some(Statement::Insert(insert)) if insert.has_non_values_query_source())
1595}
1596
1597#[cfg(test)]
1598mod tests {
1599    use std::collections::HashMap;
1600    use std::future::Future;
1601    use std::pin::Pin;
1602    use std::sync::Arc;
1603    use std::task::{Context, Poll};
1604    use std::time::Duration;
1605
1606    use api::prom_store::remote::label_matcher::Type as PromMatcherType;
1607    use api::prom_store::remote::{LabelMatcher, Query as RemoteQuery, ReadRequest};
1608    use api::v1::meta::{ProcedureDetailResponse, ReconcileRequest, ReconcileResponse};
1609    use auth::{PermissionResp, UserInfoRef};
1610    use catalog::process_manager::ProcessManager;
1611    use common_base::Plugins;
1612    use common_error::ext::{BoxedError, PlainError};
1613    use common_error::status_code::StatusCode;
1614    use common_meta::cache::LayeredCacheRegistryBuilder;
1615    use common_meta::kv_backend::memory::MemoryKvBackend;
1616    use common_meta::procedure_executor::{ExecutorContext, ProcedureExecutor};
1617    use common_meta::rpc::ddl::{SubmitDdlTaskRequest, SubmitDdlTaskResponse};
1618    use common_meta::rpc::procedure::{
1619        MigrateRegionRequest, MigrateRegionResponse, ProcedureStateResponse,
1620    };
1621    use common_query::Output;
1622    use common_recordbatch::{
1623        OrderOption, RecordBatch, RecordBatchStream, SendableRecordBatchStream,
1624    };
1625    use datafusion::arrow::datatypes::{DataType, Field, Schema, SchemaRef};
1626    use datafusion_expr::dml::InsertOp;
1627    use datafusion_expr::{LogicalPlanBuilder, LogicalTableSource};
1628    use datatypes::prelude::ConcreteDataType;
1629    use datatypes::schema::{ColumnSchema, Schema as GtSchema, SchemaRef as GtSchemaRef};
1630    use datatypes::vectors::{StringVector, VectorRef};
1631    use log_query::LogQuery;
1632    use query::query_engine::options::QueryOptions;
1633    use servers::query_handler::{LogQueryHandler, PromStoreProtocolHandler};
1634    use session::context::{Channel, ConnInfo, QueryContext, QueryContextBuilder};
1635    use snafu::{Location, Snafu};
1636    use sql::dialect::GreptimeDbDialect;
1637    use store_api::data_source::DataSource;
1638    use store_api::metric_engine_consts::{
1639        LOGICAL_TABLE_METADATA_KEY, METRIC_ENGINE_NAME, PHYSICAL_TABLE_METADATA_KEY,
1640    };
1641    use store_api::storage::ScanRequest;
1642    use strfmt::Format;
1643    use table::metadata::{FilterPushDownType, TableInfo, TableInfoBuilder, TableMetaBuilder};
1644    use table::table_name::TableName;
1645    use table::test_util::{EmptyTable, MemTable};
1646    use table::{Table, TableRef};
1647    use tokio::sync::{mpsc, oneshot};
1648
1649    use super::*;
1650    use crate::frontend::FrontendOptions;
1651    use crate::instance::builder::FrontendBuilder;
1652
1653    fn parse_test_sql(sql: &str) -> Vec<Statement> {
1654        parse_stmt(sql, &GreptimeDbDialect {}).unwrap()
1655    }
1656
1657    #[test]
1658    fn test_validate_analyze_stream_statement_strictness() {
1659        for sql in [
1660            "select 1",
1661            "explain analyze select 1",
1662            "explain analyze verbose format text select 1",
1663            "explain analyze verbose format graphviz select 1",
1664        ] {
1665            let mut stmts = parse_test_sql(sql);
1666            assert!(
1667                validate_analyze_stream_statement(&mut stmts[0]).is_err(),
1668                "{sql}"
1669            );
1670        }
1671
1672        for sql in [
1673            "explain analyze verbose select 1",
1674            "explain analyze verbose format json select 1",
1675        ] {
1676            let mut stmts = parse_test_sql(sql);
1677            assert!(
1678                validate_analyze_stream_statement(&mut stmts[0]).is_ok(),
1679                "{sql}"
1680            );
1681            let Statement::Explain(explain) = &stmts[0] else {
1682                unreachable!();
1683            };
1684            assert!(explain.format.is_none());
1685        }
1686
1687        assert_eq!(
1688            parse_test_sql("explain analyze verbose select 1; select 2").len(),
1689            2
1690        );
1691    }
1692
1693    #[derive(Debug, Snafu)]
1694    enum TestError {
1695        #[snafu(display("Failed to build test cache registry"))]
1696        BuildCacheRegistry {
1697            source: cache::error::Error,
1698            #[snafu(implicit)]
1699            location: Location,
1700        },
1701
1702        #[snafu(display("Failed to build test table meta for table: {table_name}"))]
1703        BuildTableMeta {
1704            table_name: String,
1705            source: table::metadata::TableMetaBuilderError,
1706            #[snafu(implicit)]
1707            location: Location,
1708        },
1709
1710        #[snafu(display("Failed to build test table info for table: {table_name}"))]
1711        BuildTableInfo {
1712            table_name: String,
1713            source: table::metadata::TableInfoBuilderError,
1714            #[snafu(implicit)]
1715            location: Location,
1716        },
1717
1718        #[snafu(display("Failed to register test table: {table_name}"))]
1719        RegisterTable {
1720            table_name: String,
1721            source: catalog::error::Error,
1722            #[snafu(implicit)]
1723            location: Location,
1724        },
1725
1726        #[snafu(display("Failed to build test frontend instance"))]
1727        BuildFrontend {
1728            source: crate::error::Error,
1729            #[snafu(implicit)]
1730            location: Location,
1731        },
1732
1733        #[snafu(display("Expected exactly one output for SQL `{sql}`, got {actual}"))]
1734        UnexpectedOutputCount {
1735            sql: String,
1736            actual: usize,
1737            #[snafu(implicit)]
1738            location: Location,
1739        },
1740
1741        #[snafu(display("Failed to execute SQL `{sql}`"))]
1742        ExecuteSql {
1743            sql: String,
1744            source: crate::error::Error,
1745            #[snafu(implicit)]
1746            location: Location,
1747        },
1748
1749        #[snafu(display("Timed out waiting for insert-select start notification"))]
1750        InsertStartTimeout {
1751            source: tokio::time::error::Elapsed,
1752            #[snafu(implicit)]
1753            location: Location,
1754        },
1755
1756        #[snafu(display("Insert-select start notification channel closed"))]
1757        InsertStartChannelClosed {
1758            #[snafu(implicit)]
1759            location: Location,
1760        },
1761
1762        #[snafu(display("Failed to release blocking insert-select interceptor"))]
1763        ReleaseBlockedInsert {
1764            #[snafu(implicit)]
1765            location: Location,
1766        },
1767
1768        #[snafu(display("Timed out waiting for insert-select source to be polled"))]
1769        SourcePollTimeout {
1770            source: tokio::time::error::Elapsed,
1771            #[snafu(implicit)]
1772            location: Location,
1773        },
1774
1775        #[snafu(display("Insert-select source poll notification channel closed"))]
1776        SourcePollChannelClosed {
1777            source: oneshot::error::RecvError,
1778            #[snafu(implicit)]
1779            location: Location,
1780        },
1781
1782        #[snafu(display("Timed out waiting for insert task to finish"))]
1783        InsertTaskTimeout {
1784            source: tokio::time::error::Elapsed,
1785            #[snafu(implicit)]
1786            location: Location,
1787        },
1788
1789        #[snafu(display("Insert task panicked"))]
1790        InsertTaskPanic {
1791            source: tokio::task::JoinError,
1792            #[snafu(implicit)]
1793            location: Location,
1794        },
1795
1796        #[snafu(display("Expected insert-select to be cancelled"))]
1797        InsertSelectNotCancelled {
1798            #[snafu(implicit)]
1799            location: Location,
1800        },
1801    }
1802
1803    type TestResult<T> = std::result::Result<T, TestError>;
1804
1805    fn parse_one_sql(sql: &str) -> Statement {
1806        parse_stmt(sql, &GreptimeDbDialect {}).unwrap().remove(0)
1807    }
1808
1809    fn test_query_ctx(process_id: u32) -> QueryContextRef {
1810        Arc::new(
1811            QueryContextBuilder::default()
1812                .channel(Channel::Mysql)
1813                .conn_info(ConnInfo::new(None, Channel::Mysql))
1814                .process_id(process_id)
1815                .build(),
1816        )
1817    }
1818
1819    struct RejectUnresolvedPermissionChecker;
1820
1821    impl PermissionChecker for RejectUnresolvedPermissionChecker {
1822        fn check_permission(
1823            &self,
1824            _user_info: UserInfoRef,
1825            _req: PermissionReq,
1826        ) -> auth::error::Result<PermissionResp> {
1827            Ok(PermissionResp::Allow)
1828        }
1829
1830        fn check_permission_with_table_targets(
1831            &self,
1832            _user_info: UserInfoRef,
1833            _req: PermissionReq,
1834            targets: PermissionTableTargets,
1835        ) -> auth::error::Result<PermissionResp> {
1836            let reject = match targets {
1837                PermissionTableTargets::Unresolved => true,
1838                PermissionTableTargets::Resolved(targets) => {
1839                    targets.iter().any(|target| target.table == "denied")
1840                }
1841            };
1842            Ok(if reject {
1843                PermissionResp::Reject
1844            } else {
1845                PermissionResp::Allow
1846            })
1847        }
1848    }
1849
1850    #[derive(Default)]
1851    struct TargetIndependentPermissionChecker {
1852        checks: atomic::AtomicUsize,
1853    }
1854
1855    impl PermissionChecker for TargetIndependentPermissionChecker {
1856        fn check_permission(
1857            &self,
1858            _user_info: UserInfoRef,
1859            _req: PermissionReq,
1860        ) -> auth::error::Result<PermissionResp> {
1861            self.checks.fetch_add(1, atomic::Ordering::Relaxed);
1862            Ok(PermissionResp::Allow)
1863        }
1864
1865        fn uses_table_targets(&self) -> bool {
1866            false
1867        }
1868
1869        fn check_permission_with_table_targets(
1870            &self,
1871            user_info: UserInfoRef,
1872            req: PermissionReq,
1873            _targets: PermissionTableTargets,
1874        ) -> auth::error::Result<PermissionResp> {
1875            self.check_permission(user_info, req)
1876        }
1877    }
1878
1879    struct BlockingInsertSelectInterceptor {
1880        started_tx: mpsc::UnboundedSender<()>,
1881        finish_rx: std::sync::Mutex<Option<oneshot::Receiver<()>>>,
1882    }
1883
1884    impl BlockingInsertSelectInterceptor {
1885        fn new(started_tx: mpsc::UnboundedSender<()>, finish_rx: oneshot::Receiver<()>) -> Self {
1886            Self {
1887                started_tx,
1888                finish_rx: std::sync::Mutex::new(Some(finish_rx)),
1889            }
1890        }
1891    }
1892
1893    impl SqlQueryInterceptor for BlockingInsertSelectInterceptor {
1894        type Error = Error;
1895
1896        fn pre_execute(
1897            &self,
1898            statement: Option<&Statement>,
1899            _plan: Option<&LogicalPlan>,
1900            _query_ctx: QueryContextRef,
1901        ) -> Result<()> {
1902            let Some(Statement::Insert(insert)) = statement else {
1903                return Ok(());
1904            };
1905            if !insert.has_non_values_query_source() {
1906                return Ok(());
1907            }
1908
1909            let finish_rx = self.finish_rx.lock().unwrap().take().unwrap();
1910            let _ = self.started_tx.send(());
1911            tokio::task::block_in_place(|| {
1912                tokio::runtime::Handle::current()
1913                    .block_on(finish_rx)
1914                    .unwrap();
1915            });
1916            Ok(())
1917        }
1918    }
1919
1920    struct PendingRecordBatchStream {
1921        schema: GtSchemaRef,
1922        polled_tx: Option<oneshot::Sender<()>>,
1923        _finish_tx: oneshot::Sender<()>,
1924        finish_rx: Pin<Box<oneshot::Receiver<()>>>,
1925    }
1926
1927    impl RecordBatchStream for PendingRecordBatchStream {
1928        fn schema(&self) -> GtSchemaRef {
1929            self.schema.clone()
1930        }
1931
1932        fn output_ordering(&self) -> Option<&[OrderOption]> {
1933            None
1934        }
1935
1936        fn metrics(&self) -> Option<common_recordbatch::adapter::RecordBatchMetrics> {
1937            None
1938        }
1939    }
1940
1941    impl Stream for PendingRecordBatchStream {
1942        type Item = common_recordbatch::error::Result<RecordBatch>;
1943
1944        fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
1945            if let Some(polled_tx) = self.polled_tx.take() {
1946                let _ = polled_tx.send(());
1947            }
1948
1949            match self.finish_rx.as_mut().poll(cx) {
1950                Poll::Ready(_) => Poll::Ready(None),
1951                Poll::Pending => Poll::Pending,
1952            }
1953        }
1954    }
1955
1956    impl Unpin for PendingRecordBatchStream {}
1957
1958    struct PendingDataSource {
1959        schema: GtSchemaRef,
1960        polled_tx: std::sync::Mutex<Option<oneshot::Sender<()>>>,
1961    }
1962
1963    impl DataSource for PendingDataSource {
1964        fn get_stream(
1965            &self,
1966            _request: ScanRequest,
1967        ) -> std::result::Result<SendableRecordBatchStream, BoxedError> {
1968            let (finish_tx, finish_rx) = oneshot::channel();
1969            let mut polled_tx = self.polled_tx.lock().map_err(|_| {
1970                BoxedError::new(PlainError::new(
1971                    "pending data source lock poisoned".to_string(),
1972                    StatusCode::Unexpected,
1973                ))
1974            })?;
1975            Ok(Box::pin(PendingRecordBatchStream {
1976                schema: self.schema.clone(),
1977                polled_tx: polled_tx.take(),
1978                _finish_tx: finish_tx,
1979                finish_rx: Box::pin(finish_rx),
1980            }))
1981        }
1982    }
1983
1984    struct NoopProcedureExecutor;
1985
1986    #[async_trait::async_trait]
1987    impl ProcedureExecutor for NoopProcedureExecutor {
1988        async fn submit_ddl_task(
1989            &self,
1990            _ctx: &ExecutorContext,
1991            _request: SubmitDdlTaskRequest,
1992        ) -> common_meta::error::Result<SubmitDdlTaskResponse> {
1993            common_meta::error::UnsupportedSnafu {
1994                operation: "submit_ddl_task",
1995            }
1996            .fail()
1997        }
1998
1999        async fn migrate_region(
2000            &self,
2001            _ctx: &ExecutorContext,
2002            _request: MigrateRegionRequest,
2003        ) -> common_meta::error::Result<MigrateRegionResponse> {
2004            common_meta::error::UnsupportedSnafu {
2005                operation: "migrate_region",
2006            }
2007            .fail()
2008        }
2009
2010        async fn reconcile(
2011            &self,
2012            _ctx: &ExecutorContext,
2013            _request: ReconcileRequest,
2014        ) -> common_meta::error::Result<ReconcileResponse> {
2015            common_meta::error::UnsupportedSnafu {
2016                operation: "reconcile",
2017            }
2018            .fail()
2019        }
2020
2021        async fn query_procedure_state(
2022            &self,
2023            _ctx: &ExecutorContext,
2024            _pid: &str,
2025        ) -> common_meta::error::Result<ProcedureStateResponse> {
2026            common_meta::error::UnsupportedSnafu {
2027                operation: "query_procedure_state",
2028            }
2029            .fail()
2030        }
2031
2032        async fn list_procedures(
2033            &self,
2034            _ctx: &ExecutorContext,
2035        ) -> common_meta::error::Result<ProcedureDetailResponse> {
2036            common_meta::error::UnsupportedSnafu {
2037                operation: "list_procedures",
2038            }
2039            .fail()
2040        }
2041    }
2042
2043    fn test_cache_registry(
2044        kv_backend: common_meta::kv_backend::KvBackendRef,
2045    ) -> TestResult<common_meta::cache::LayeredCacheRegistryRef> {
2046        Ok(Arc::new(
2047            cache::with_default_composite_cache_registry(
2048                LayeredCacheRegistryBuilder::default()
2049                    .add_cache_registry(cache::build_fundamental_cache_registry(kv_backend)),
2050            )
2051            .context(BuildCacheRegistrySnafu)?
2052            .build(),
2053        ))
2054    }
2055
2056    fn test_table_info(table_id: u32, table_name: &str) -> TestResult<TableInfo> {
2057        let schema = Arc::new(GtSchema::new(vec![
2058            ColumnSchema::new("id", ConcreteDataType::int32_datatype(), false),
2059            ColumnSchema::new(
2060                "ts",
2061                ConcreteDataType::timestamp_millisecond_datatype(),
2062                false,
2063            )
2064            .with_time_index(true),
2065        ]));
2066        let table_meta = TableMetaBuilder::empty()
2067            .schema(schema)
2068            .primary_key_indices(vec![0])
2069            .value_indices(vec![1])
2070            .next_column_id(1024)
2071            .build()
2072            .with_context(|_| BuildTableMetaSnafu {
2073                table_name: table_name.to_string(),
2074            })?;
2075
2076        TableInfoBuilder::new(table_name, table_meta)
2077            .table_id(table_id)
2078            .build()
2079            .with_context(|_| BuildTableInfoSnafu {
2080                table_name: table_name.to_string(),
2081            })
2082    }
2083
2084    fn test_table(table_id: u32, table_name: &str) -> TestResult<table::TableRef> {
2085        let table_info = test_table_info(table_id, table_name)?;
2086        Ok(EmptyTable::from_table_info(&table_info))
2087    }
2088
2089    fn test_physical_table(table_id: u32, table_name: &str) -> TestResult<table::TableRef> {
2090        let mut table_info = test_table_info(table_id, table_name)?;
2091        table_info
2092            .meta
2093            .options
2094            .extra_options
2095            .insert(PHYSICAL_TABLE_METADATA_KEY.to_string(), String::new());
2096        Ok(EmptyTable::from_table_info(&table_info))
2097    }
2098
2099    fn test_logical_table(table_id: u32, table_name: &str) -> TestResult<table::TableRef> {
2100        let mut table_info = test_table_info(table_id, table_name)?;
2101        table_info.meta.engine = METRIC_ENGINE_NAME.to_string();
2102        table_info.meta.options.extra_options.insert(
2103            LOGICAL_TABLE_METADATA_KEY.to_string(),
2104            "physical_metric".to_string(),
2105        );
2106        Ok(EmptyTable::from_table_info(&table_info))
2107    }
2108
2109    fn test_metric_names_table() -> TableRef {
2110        let schema = Arc::new(GtSchema::new(vec![
2111            ColumnSchema::new("table_catalog", ConcreteDataType::string_datatype(), false),
2112            ColumnSchema::new("table_schema", ConcreteDataType::string_datatype(), false),
2113            ColumnSchema::new("table_name", ConcreteDataType::string_datatype(), false),
2114            ColumnSchema::new("engine", ConcreteDataType::string_datatype(), false),
2115            ColumnSchema::new("create_options", ConcreteDataType::string_datatype(), false),
2116        ]));
2117        let columns: Vec<VectorRef> = vec![
2118            Arc::new(StringVector::from(vec!["greptime", "greptime"])),
2119            Arc::new(StringVector::from(vec!["public", "public"])),
2120            Arc::new(StringVector::from(vec!["denied", "target"])),
2121            Arc::new(StringVector::from(vec!["metric", "metric"])),
2122            Arc::new(StringVector::from(vec![
2123                "on_physical_table=physical_metric",
2124                "on_physical_table=physical_metric",
2125            ])),
2126        ];
2127        let record_batch = RecordBatch::new(schema, columns).unwrap();
2128        MemTable::new_with_catalog(
2129            "tables",
2130            record_batch,
2131            2048,
2132            "greptime".to_string(),
2133            "information_schema".to_string(),
2134        )
2135    }
2136
2137    fn pending_table(
2138        table_id: u32,
2139        table_name: &str,
2140        polled_tx: oneshot::Sender<()>,
2141    ) -> TestResult<table::TableRef> {
2142        let table_info = test_table_info(table_id, table_name)?;
2143        let data_source = Arc::new(PendingDataSource {
2144            schema: table_info.meta.schema.clone(),
2145            polled_tx: std::sync::Mutex::new(Some(polled_tx)),
2146        });
2147
2148        Ok(Arc::new(Table::new(
2149            Arc::new(table_info),
2150            FilterPushDownType::Unsupported,
2151            data_source,
2152        )))
2153    }
2154
2155    async fn test_instance_with_tables(
2156        source_table: TableRef,
2157        target_table: TableRef,
2158    ) -> TestResult<Instance> {
2159        test_instance_with_plugins(source_table, target_table, Plugins::new()).await
2160    }
2161
2162    async fn test_instance_with_insert_select_interceptor(
2163        interceptor: SqlQueryInterceptorRef<Error>,
2164    ) -> TestResult<Instance> {
2165        let plugins = Plugins::new();
2166        plugins.insert::<SqlQueryInterceptorRef<Error>>(interceptor);
2167
2168        test_instance_with_plugins(
2169            test_table(1024, "source")?,
2170            test_table(1025, "target")?,
2171            plugins,
2172        )
2173        .await
2174    }
2175
2176    async fn test_instance_with_plugins(
2177        source_table: TableRef,
2178        target_table: TableRef,
2179        plugins: Plugins,
2180    ) -> TestResult<Instance> {
2181        test_instance_with_plugins_and_metric_names(source_table, target_table, plugins, None).await
2182    }
2183
2184    async fn test_instance_with_plugins_and_metric_names(
2185        source_table: TableRef,
2186        target_table: TableRef,
2187        plugins: Plugins,
2188        metric_names_table: Option<TableRef>,
2189    ) -> TestResult<Instance> {
2190        let kv_backend = Arc::new(MemoryKvBackend::new());
2191        let process_manager = Arc::new(ProcessManager::new("test-frontend".to_string(), None));
2192        let catalog_manager = catalog::memory::MemoryCatalogManager::new_with_table(source_table);
2193        let target_table_name = "target";
2194        catalog_manager
2195            .register_table_sync(catalog::RegisterTableRequest {
2196                catalog: "greptime".to_string(),
2197                schema: "public".to_string(),
2198                table_name: target_table_name.to_string(),
2199                table_id: 1025,
2200                table: target_table,
2201            })
2202            .with_context(|_| RegisterTableSnafu {
2203                table_name: target_table_name.to_string(),
2204            })?;
2205        if let Some(table) = metric_names_table {
2206            catalog_manager
2207                .deregister_table_sync(catalog::DeregisterTableRequest {
2208                    catalog: "greptime".to_string(),
2209                    schema: "information_schema".to_string(),
2210                    table_name: "tables".to_string(),
2211                })
2212                .unwrap();
2213            catalog_manager
2214                .register_table_sync(catalog::RegisterTableRequest {
2215                    catalog: "greptime".to_string(),
2216                    schema: "information_schema".to_string(),
2217                    table_name: "tables".to_string(),
2218                    table_id: 2048,
2219                    table,
2220                })
2221                .unwrap();
2222        }
2223        catalog_manager.register_process_list_table(process_manager.clone());
2224
2225        let cache_registry = test_cache_registry(kv_backend.clone())?;
2226
2227        FrontendBuilder::new(
2228            FrontendOptions::default(),
2229            kv_backend,
2230            cache_registry,
2231            catalog_manager,
2232            Arc::new(client::client_manager::NodeClients::default()),
2233            Arc::new(NoopProcedureExecutor),
2234            process_manager,
2235        )
2236        .with_plugin(plugins)
2237        .try_build()
2238        .await
2239        .context(BuildFrontendSnafu)
2240    }
2241
2242    async fn execute_one_sql(
2243        instance: &Instance,
2244        sql: &str,
2245        query_ctx: QueryContextRef,
2246    ) -> TestResult<Output> {
2247        let mut results = instance.do_query_inner(sql, query_ctx).await;
2248        ensure!(
2249            results.len() == 1,
2250            UnexpectedOutputCountSnafu {
2251                sql: sql.to_string(),
2252                actual: results.len(),
2253            }
2254        );
2255        results.remove(0).with_context(|_| ExecuteSqlSnafu {
2256            sql: sql.to_string(),
2257        })
2258    }
2259
2260    #[tokio::test]
2261    async fn test_event_recorder_is_exposed() -> TestResult<()> {
2262        let instance =
2263            test_instance_with_tables(test_table(1024, "source")?, test_table(1025, "target")?)
2264                .await?;
2265
2266        let _event_recorder = instance.event_recorder();
2267
2268        Ok(())
2269    }
2270
2271    #[tokio::test]
2272    async fn test_target_independent_checker_skips_target_resolution() -> TestResult<()> {
2273        let physical_table = "physical_metric";
2274        let checker = Arc::new(TargetIndependentPermissionChecker::default());
2275        let plugins = Plugins::new();
2276        plugins.insert::<PermissionCheckerRef>(checker.clone());
2277        let instance = test_instance_with_plugins(
2278            test_physical_table(1024, physical_table)?,
2279            test_table(1025, "target")?,
2280            plugins,
2281        )
2282        .await?;
2283
2284        let ctx = test_query_ctx(1);
2285        let physical_target = PermissionTableTarget::new("greptime", "public", physical_table);
2286        assert_eq!(
2287            PermissionTableTargets::Resolved(vec![physical_target.clone()]),
2288            instance
2289                .resolve_query_permission_targets(
2290                    PermissionTableTargets::resolved(vec![physical_target]),
2291                    &ctx,
2292                )
2293                .await
2294                .unwrap()
2295        );
2296        assert_eq!(
2297            vec![physical_table.to_string(), "target".to_string()],
2298            PrometheusHandler::filter_metadata_metric_names(
2299                &instance,
2300                vec![physical_table.to_string(), "target".to_string()],
2301                "public",
2302                &ctx,
2303            )
2304            .await
2305            .unwrap()
2306        );
2307        assert_eq!(1, checker.checks.load(atomic::Ordering::Relaxed));
2308
2309        Ok(())
2310    }
2311
2312    #[tokio::test]
2313    async fn test_query_permission_targets_are_deduplicated() -> TestResult<()> {
2314        let plugins = Plugins::new();
2315        plugins.insert::<PermissionCheckerRef>(Arc::new(RejectUnresolvedPermissionChecker));
2316        let instance = test_instance_with_plugins(
2317            test_table(1024, "source")?,
2318            test_table(1025, "target")?,
2319            plugins,
2320        )
2321        .await?;
2322        let ctx = test_query_ctx(1);
2323        let target = PermissionTableTarget::new("greptime", "public", "target");
2324
2325        assert_eq!(
2326            PermissionTableTargets::Resolved(vec![target.clone()]),
2327            instance
2328                .resolve_query_permission_targets(
2329                    PermissionTableTargets::resolved(vec![target.clone(), target]),
2330                    &ctx,
2331                )
2332                .await
2333                .unwrap()
2334        );
2335
2336        Ok(())
2337    }
2338
2339    #[tokio::test]
2340    async fn test_physical_query_targets_fail_closed() -> TestResult<()> {
2341        let physical_table = "physical_metric";
2342        let plugins = Plugins::new();
2343        plugins.insert::<PermissionCheckerRef>(Arc::new(RejectUnresolvedPermissionChecker));
2344        let instance = test_instance_with_plugins(
2345            test_physical_table(1024, physical_table)?,
2346            test_table(1025, "target")?,
2347            plugins,
2348        )
2349        .await?;
2350
2351        let ctx = test_query_ctx(1);
2352        let logical_target = PermissionTableTarget::new("greptime", "public", "target");
2353        assert_eq!(
2354            PermissionTableTargets::Resolved(vec![logical_target.clone()]),
2355            instance
2356                .resolve_query_permission_targets(
2357                    PermissionTableTargets::resolved(vec![logical_target.clone()]),
2358                    &ctx,
2359                )
2360                .await
2361                .unwrap()
2362        );
2363        let physical_target = PermissionTableTarget::new("greptime", "public", physical_table);
2364        assert_eq!(
2365            PermissionTableTargets::Unresolved,
2366            instance
2367                .resolve_query_permission_targets(
2368                    PermissionTableTargets::resolved(
2369                        vec![logical_target, physical_target.clone(),]
2370                    ),
2371                    &ctx,
2372                )
2373                .await
2374                .unwrap()
2375        );
2376        assert_eq!(
2377            vec!["target".to_string()],
2378            PrometheusHandler::filter_metadata_metric_names(
2379                &instance,
2380                vec!["target".to_string(), "denied".to_string()],
2381                "public",
2382                &ctx,
2383            )
2384            .await
2385            .unwrap()
2386        );
2387
2388        let query = PromQuery {
2389            query: physical_table.to_string(),
2390            ..Default::default()
2391        };
2392        let err = PrometheusHandler::check_query_target_permission(
2393            &instance,
2394            PermissionTableTargets::resolved(vec![physical_target]),
2395            &ctx,
2396        )
2397        .await
2398        .unwrap_err();
2399        assert_eq!(StatusCode::PermissionDenied, err.status_code());
2400        let err = PrometheusHandler::check_query_permission(
2401            &instance,
2402            std::slice::from_ref(&query),
2403            &ctx,
2404        )
2405        .await
2406        .unwrap_err();
2407        assert_eq!(StatusCode::PermissionDenied, err.status_code());
2408        let err = PrometheusHandler::do_query(&instance, &query, ctx.clone())
2409            .await
2410            .unwrap_err();
2411        assert_eq!(StatusCode::PermissionDenied, err.status_code());
2412
2413        for sql in [
2414            "SELECT * FROM physical_metric",
2415            "TQL EVAL (0, 10, '5s') physical_metric",
2416            "INSERT INTO target SELECT * FROM physical_metric",
2417        ] {
2418            let mut results = instance.do_query_inner(sql, ctx.clone()).await;
2419            assert_eq!(1, results.len(), "{sql}");
2420            let err = results.remove(0).unwrap_err();
2421            assert_eq!(StatusCode::PermissionDenied, err.status_code(), "{sql}");
2422        }
2423        let err = LogQueryHandler::query(
2424            &instance,
2425            LogQuery {
2426                table: TableName::new("greptime", "public", physical_table),
2427                ..Default::default()
2428            },
2429            ctx.clone(),
2430        )
2431        .await
2432        .unwrap_err();
2433        assert_eq!(StatusCode::PermissionDenied, err.status_code());
2434        let err = instance
2435            .do_describe_inner(parse_one_sql("SELECT * FROM physical_metric"), ctx.clone())
2436            .await
2437            .unwrap_err();
2438        assert_eq!(StatusCode::PermissionDenied, err.status_code());
2439
2440        let request = ReadRequest {
2441            queries: vec![RemoteQuery {
2442                matchers: vec![LabelMatcher {
2443                    r#type: PromMatcherType::Eq as i32,
2444                    name: servers::prom_store::METRIC_NAME_LABEL.to_string(),
2445                    value: physical_table.to_string(),
2446                }],
2447                ..Default::default()
2448            }],
2449            ..Default::default()
2450        };
2451        let Err(err) = PromStoreProtocolHandler::read(&instance, request, ctx.clone()).await else {
2452            panic!("physical remote-read target must be rejected");
2453        };
2454        assert_eq!(StatusCode::PermissionDenied, err.status_code());
2455
2456        let err = PrometheusHandler::query_label_values(
2457            &instance,
2458            physical_table.to_string(),
2459            "host".to_string(),
2460            vec![],
2461            SystemTime::UNIX_EPOCH,
2462            SystemTime::UNIX_EPOCH,
2463            &ctx,
2464        )
2465        .await
2466        .unwrap_err();
2467        assert_eq!(StatusCode::PermissionDenied, err.status_code());
2468
2469        Ok(())
2470    }
2471
2472    #[tokio::test]
2473    async fn test_non_exact_query_discovery_keeps_denied_targets_for_batch_check() -> TestResult<()>
2474    {
2475        let plugins = Plugins::new();
2476        plugins.insert::<PermissionCheckerRef>(Arc::new(RejectUnresolvedPermissionChecker));
2477        let instance = test_instance_with_plugins_and_metric_names(
2478            test_logical_table(1024, "denied")?,
2479            test_logical_table(1025, "target")?,
2480            plugins,
2481            Some(test_metric_names_table()),
2482        )
2483        .await?;
2484        let ctx = test_query_ctx(1);
2485
2486        let mut metric_names = PrometheusHandler::query_metric_names(
2487            &instance,
2488            vec![Matcher::new(
2489                promql_parser::label::MatchOp::NotEqual,
2490                "__name__",
2491                "",
2492            )],
2493            "public",
2494            &ctx,
2495        )
2496        .await
2497        .unwrap();
2498        metric_names.sort_unstable();
2499        assert_eq!(
2500            vec!["denied".to_string(), "target".to_string()],
2501            metric_names
2502        );
2503
2504        let queries = metric_names
2505            .into_iter()
2506            .map(|query| PromQuery {
2507                query,
2508                ..Default::default()
2509            })
2510            .collect::<Vec<_>>();
2511        let err = PrometheusHandler::check_query_permission(&instance, &queries, &ctx)
2512            .await
2513            .unwrap_err();
2514        assert_eq!(StatusCode::PermissionDenied, err.status_code());
2515
2516        Ok(())
2517    }
2518
2519    #[test]
2520    fn test_fast_legacy_check_is_read_only() {
2521        let cache = DashMap::new();
2522        cache.insert("metric1".to_string(), true);
2523
2524        let names = vec!["metric1".to_string(), "metric2".to_string()];
2525        assert_eq!(Some(true), fast_legacy_check(&cache, &names).unwrap());
2526        assert!(!cache.contains_key("metric2"));
2527
2528        cache_legacy_mode(&cache, &names, true).unwrap();
2529        assert!(*cache.get("metric2").unwrap().value());
2530        assert!(cache_legacy_mode(&cache, &names, false).is_err());
2531        assert!(*cache.get("metric2").unwrap().value());
2532
2533        let cache_incompatible = DashMap::new();
2534        cache_incompatible.insert("metric1".to_string(), true);
2535        cache_incompatible.insert("metric2".to_string(), false);
2536        assert!(fast_legacy_check(&cache_incompatible, &names).is_err());
2537    }
2538
2539    #[test]
2540    fn test_should_track_statement_process() {
2541        assert!(should_track_statement_process(&parse_one_sql(
2542            "SELECT * FROM demo"
2543        )));
2544        assert!(should_track_statement_process(&parse_one_sql(
2545            "INSERT INTO demo SELECT * FROM source"
2546        )));
2547        assert!(!should_track_statement_process(&parse_one_sql(
2548            "INSERT INTO demo VALUES (1)"
2549        )));
2550        assert!(!should_track_statement_process(&parse_one_sql(
2551            "INSERT INTO demo VALUES (now())"
2552        )));
2553    }
2554
2555    #[test]
2556    fn test_should_track_plan_process() {
2557        let select_stmt = parse_one_sql("SELECT * FROM demo");
2558        let insert_select_stmt = parse_one_sql("INSERT INTO demo SELECT * FROM source");
2559        let insert_values_stmt = parse_one_sql("INSERT INTO demo VALUES (now())");
2560
2561        let empty_plan = LogicalPlanBuilder::empty(false).build().unwrap();
2562        assert!(should_track_plan_process(Some(&select_stmt), &empty_plan));
2563        assert!(should_track_plan_process(
2564            Some(&insert_select_stmt),
2565            &insert_dml_plan()
2566        ));
2567        assert!(!should_track_plan_process(
2568            Some(&insert_values_stmt),
2569            &insert_dml_plan()
2570        ));
2571        assert!(!should_track_plan_process(None, &insert_dml_plan()));
2572    }
2573
2574    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2575    async fn test_insert_select_is_visible_in_show_processlist() -> TestResult<()> {
2576        let insert_sql = "INSERT INTO target SELECT * FROM source";
2577        let (started_tx, mut started_rx) = mpsc::unbounded_channel();
2578        let (finish_tx, finish_rx) = oneshot::channel();
2579        let interceptor = Arc::new(BlockingInsertSelectInterceptor::new(started_tx, finish_rx));
2580        let instance = Arc::new(test_instance_with_insert_select_interceptor(interceptor).await?);
2581
2582        let insert_task = tokio::spawn({
2583            let instance = instance.clone();
2584            async move { execute_one_sql(&instance, insert_sql, test_query_ctx(4242)).await }
2585        });
2586
2587        tokio::time::timeout(Duration::from_secs(5), started_rx.recv())
2588            .await
2589            .context(InsertStartTimeoutSnafu)?
2590            .context(InsertStartChannelClosedSnafu)?;
2591
2592        let output = execute_one_sql(&instance, "SHOW PROCESSLIST", test_query_ctx(43)).await?;
2593        let process_list = output.data.pretty_print().await;
2594        assert!(
2595            process_list.contains(insert_sql),
2596            "process list did not contain running insert:\n{process_list}"
2597        );
2598
2599        finish_tx
2600            .send(())
2601            .map_err(|_| ReleaseBlockedInsertSnafu.build())?;
2602        insert_task.await.context(InsertTaskPanicSnafu)??;
2603
2604        Ok(())
2605    }
2606
2607    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2608    async fn test_kill_query_cancels_insert_select() -> TestResult<()> {
2609        assert_kill_cancels_insert_select("KILL QUERY 4242").await
2610    }
2611
2612    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2613    async fn test_kill_process_id_cancels_insert_select() -> TestResult<()> {
2614        assert_kill_cancels_insert_select("KILL 'test-frontend/4242'").await
2615    }
2616
2617    async fn assert_kill_cancels_insert_select(kill_sql: &str) -> TestResult<()> {
2618        let insert_sql = "INSERT INTO target SELECT * FROM source";
2619        let (source_polled_tx, source_polled_rx) = oneshot::channel();
2620        let instance = Arc::new(
2621            test_instance_with_tables(
2622                pending_table(1024, "source", source_polled_tx)?,
2623                test_table(1025, "target")?,
2624            )
2625            .await?,
2626        );
2627
2628        let insert_task = tokio::spawn({
2629            let instance = instance.clone();
2630            async move { execute_one_sql(&instance, insert_sql, test_query_ctx(4242)).await }
2631        });
2632
2633        tokio::time::timeout(Duration::from_secs(5), source_polled_rx)
2634            .await
2635            .context(SourcePollTimeoutSnafu)?
2636            .context(SourcePollChannelClosedSnafu)?;
2637
2638        let output = execute_one_sql(&instance, kill_sql, test_query_ctx(43)).await?;
2639        assert!(matches!(output.data, OutputData::AffectedRows(1)));
2640
2641        let insert_result = tokio::time::timeout(Duration::from_secs(5), insert_task)
2642            .await
2643            .context(InsertTaskTimeoutSnafu)?
2644            .context(InsertTaskPanicSnafu)?;
2645        let err = match insert_result {
2646            Ok(_) => return InsertSelectNotCancelledSnafu.fail(),
2647            Err(TestError::ExecuteSql { source, .. }) => source,
2648            Err(err) => return Err(err),
2649        };
2650        assert_eq!(StatusCode::Cancelled, err.status_code());
2651
2652        let output = execute_one_sql(&instance, "SHOW PROCESSLIST", test_query_ctx(43)).await?;
2653        let process_list = output.data.pretty_print().await;
2654        assert!(
2655            !process_list.contains(insert_sql),
2656            "process list still contains killed insert:\n{process_list}"
2657        );
2658
2659        Ok(())
2660    }
2661
2662    fn insert_dml_plan() -> LogicalPlan {
2663        let schema = SchemaRef::new(Schema::new(vec![Field::new(
2664            "value",
2665            DataType::Int64,
2666            true,
2667        )]));
2668        let target = Arc::new(LogicalTableSource::new(schema));
2669        let input = LogicalPlanBuilder::empty(false).build().unwrap();
2670
2671        LogicalPlanBuilder::insert_into(input, "demo", target, InsertOp::Append)
2672            .unwrap()
2673            .build()
2674            .unwrap()
2675    }
2676
2677    #[test]
2678    fn test_exec_validation() {
2679        let query_ctx = QueryContext::arc();
2680        let plugins: Plugins = Plugins::new();
2681        plugins.insert(QueryOptions {
2682            disallow_cross_catalog_query: true,
2683        });
2684
2685        let sql = r#"
2686        SELECT * FROM demo;
2687        EXPLAIN SELECT * FROM demo;
2688        CREATE DATABASE test_database;
2689        SHOW DATABASES;
2690        "#;
2691        let stmts = parse_stmt(sql, &GreptimeDbDialect {}).unwrap();
2692        assert_eq!(stmts.len(), 4);
2693        for stmt in stmts {
2694            let re = check_permission(plugins.clone(), &stmt, &query_ctx);
2695            re.unwrap();
2696        }
2697
2698        let sql = r#"
2699        SHOW CREATE TABLE demo;
2700        ALTER TABLE demo ADD COLUMN new_col INT;
2701        "#;
2702        let stmts = parse_stmt(sql, &GreptimeDbDialect {}).unwrap();
2703        assert_eq!(stmts.len(), 2);
2704        for stmt in stmts {
2705            let re = check_permission(plugins.clone(), &stmt, &query_ctx);
2706            re.unwrap();
2707        }
2708
2709        fn replace_test(template_sql: &str, plugins: Plugins, query_ctx: &QueryContextRef) {
2710            // test right
2711            let right = vec![("", ""), ("", "public."), ("greptime.", "public.")];
2712            for (catalog, schema) in right {
2713                let sql = do_fmt(template_sql, catalog, schema);
2714                do_test(&sql, plugins.clone(), query_ctx, true);
2715            }
2716
2717            let wrong = vec![
2718                ("wrongcatalog.", "public."),
2719                ("wrongcatalog.", "wrongschema."),
2720            ];
2721            for (catalog, schema) in wrong {
2722                let sql = do_fmt(template_sql, catalog, schema);
2723                do_test(&sql, plugins.clone(), query_ctx, false);
2724            }
2725        }
2726
2727        fn do_fmt(template: &str, catalog: &str, schema: &str) -> String {
2728            let vars = HashMap::from([
2729                ("catalog".to_string(), catalog),
2730                ("schema".to_string(), schema),
2731            ]);
2732            template.format(&vars).unwrap()
2733        }
2734
2735        fn do_test(sql: &str, plugins: Plugins, query_ctx: &QueryContextRef, is_ok: bool) {
2736            let stmt = &parse_stmt(sql, &GreptimeDbDialect {}).unwrap()[0];
2737            let re = check_permission(plugins, stmt, query_ctx);
2738            if is_ok {
2739                re.unwrap();
2740            } else {
2741                assert!(re.is_err());
2742            }
2743        }
2744
2745        // test insert
2746        let sql = "INSERT INTO {catalog}{schema}monitor(host) VALUES ('host1');";
2747        replace_test(sql, plugins.clone(), &query_ctx);
2748
2749        // test create table
2750        let sql = r#"CREATE TABLE {catalog}{schema}demo(
2751                            host STRING,
2752                            ts TIMESTAMP,
2753                            TIME INDEX (ts),
2754                            PRIMARY KEY(host)
2755                        ) engine=mito;"#;
2756        replace_test(sql, plugins.clone(), &query_ctx);
2757
2758        // test drop table
2759        let sql = "DROP TABLE {catalog}{schema}demo;";
2760        replace_test(sql, plugins.clone(), &query_ctx);
2761
2762        // test undrop table
2763        let sql = "UNDROP TABLE {catalog}{schema}demo;";
2764        replace_test(sql, plugins.clone(), &query_ctx);
2765
2766        // test show tables
2767        let sql = "SHOW TABLES FROM public";
2768        let stmt = parse_stmt(sql, &GreptimeDbDialect {}).unwrap();
2769        check_permission(plugins.clone(), &stmt[0], &query_ctx).unwrap();
2770
2771        let sql = "SHOW TABLES FROM private";
2772        let stmt = parse_stmt(sql, &GreptimeDbDialect {}).unwrap();
2773        let re = check_permission(plugins.clone(), &stmt[0], &query_ctx);
2774        assert!(re.is_ok());
2775
2776        // test describe table
2777        let sql = "DESC TABLE {catalog}{schema}demo;";
2778        replace_test(sql, plugins.clone(), &query_ctx);
2779
2780        let comment_flow_cases = [
2781            ("COMMENT ON FLOW my_flow IS 'comment';", true),
2782            ("COMMENT ON FLOW greptime.my_flow IS 'comment';", true),
2783            ("COMMENT ON FLOW wrongcatalog.my_flow IS 'comment';", false),
2784        ];
2785        for (sql, is_ok) in comment_flow_cases {
2786            let stmt = &parse_stmt(sql, &GreptimeDbDialect {}).unwrap()[0];
2787            let result = check_permission(plugins.clone(), stmt, &query_ctx);
2788            assert_eq!(result.is_ok(), is_ok);
2789        }
2790
2791        let show_flow_cases = [
2792            ("SHOW CREATE FLOW my_flow;", true),
2793            ("SHOW CREATE FLOW greptime.my_flow;", true),
2794            ("SHOW CREATE FLOW wrongcatalog.my_flow;", false),
2795        ];
2796        for (sql, is_ok) in show_flow_cases {
2797            let stmt = &parse_stmt(sql, &GreptimeDbDialect {}).unwrap()[0];
2798            let result = check_permission(plugins.clone(), stmt, &query_ctx);
2799            assert_eq!(result.is_ok(), is_ok);
2800        }
2801    }
2802}