1pub 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#[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 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 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 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 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 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 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 drop(cache);
426
427 let catalog = ctx.current_catalog();
428 let schema = ctx.current_schema();
429
430 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 if table_ids.is_empty() {
452 return Ok(false);
453 }
454
455 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 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 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 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
536fn 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
550fn 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 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 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 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
984pub(crate) fn map_query_output(output: Output) -> Result<Output> {
986 output
987 .map_dictionary_to_values()
988 .context(CollectRecordbatchSnafu)
989}
990
991pub 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 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 let query_statement = if let QueryStatement::Promql(eval_stmt, alias) = stmt {
1178 CatalogQueryStatement::Promql(eval_stmt, alias)
1179 } else {
1180 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
1363macro_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 Statement::Admin(_) => {}
1392 Statement::Query(_)
1394 | Statement::Explain(_)
1395 | Statement::Tql(_)
1396 | Statement::Delete(_)
1397 | Statement::DeclareCursor(_)
1398 | Statement::Copy(sql::statements::copy::Copy::CopyQueryTo(_)) => {}
1399 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 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 Statement::SetVariables(_) | Statement::ShowVariables(_) => {}
1445 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 }
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(©_table_to.table_name, query_ctx)?,
1509 CopyTable::From(copy_table_from) => {
1510 validate_param(©_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 Statement::FetchCursor(_) | Statement::CloseCursor(_) => {}
1524 Statement::Kill(_) => {}
1526 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 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 let sql = "INSERT INTO {catalog}{schema}monitor(host) VALUES ('host1');";
2747 replace_test(sql, plugins.clone(), &query_ctx);
2748
2749 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 let sql = "DROP TABLE {catalog}{schema}demo;";
2760 replace_test(sql, plugins.clone(), &query_ctx);
2761
2762 let sql = "UNDROP TABLE {catalog}{schema}demo;";
2764 replace_test(sql, plugins.clone(), &query_ctx);
2765
2766 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 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}