1use std::collections::HashMap;
16use std::fmt;
17use std::num::NonZeroUsize;
18use std::sync::{Arc, RwLock};
19
20use async_trait::async_trait;
21use catalog::CatalogManagerRef;
22use common_base::Plugins;
23use common_function::aggrs::aggr_wrapper::fix_order::FixStateUdafOrderingAnalyzer;
24use common_function::function_factory::ScalarFunctionFactory;
25use common_function::function_registry::FUNCTION_REGISTRY;
26use common_function::handlers::{
27 FlowServiceHandlerRef, ProcedureServiceHandlerRef, TableMutationHandlerRef,
28};
29use common_function::state::FunctionState;
30use common_stat::get_total_memory_bytes;
31use common_telemetry::warn;
32use datafusion::catalog::TableFunction;
33use datafusion::dataframe::DataFrame;
34use datafusion::error::Result as DfResult;
35use datafusion::execution::SessionStateBuilder;
36use datafusion::execution::context::{QueryPlanner, SessionConfig, SessionContext, SessionState};
37use datafusion::execution::memory_pool::{
38 GreedyMemoryPool, MemoryConsumer, MemoryLimit, MemoryPool, MemoryReservation,
39 TrackConsumersPool,
40};
41use datafusion::execution::runtime_env::{RuntimeEnv, RuntimeEnvBuilder};
42use datafusion::physical_optimizer::PhysicalOptimizerRule;
43use datafusion::physical_optimizer::optimizer::PhysicalOptimizer;
44use datafusion::physical_optimizer::sanity_checker::SanityCheckPlan;
45use datafusion::physical_plan::ExecutionPlan;
46use datafusion::physical_planner::{DefaultPhysicalPlanner, ExtensionPlanner, PhysicalPlanner};
47use datafusion_expr::{AggregateUDF, LogicalPlan as DfLogicalPlan, WindowUDF};
48use datafusion_optimizer::Analyzer;
49use datafusion_optimizer::analyzer::function_rewrite::ApplyFunctionRewrites;
50use datafusion_optimizer::optimizer::Optimizer;
51use partition::manager::PartitionRuleManagerRef;
52use promql::extension_plan::PromExtensionPlanner;
53use session::context::QueryContextRef;
54use table::TableRef;
55use table::table::adapter::DfTableProviderAdapter;
56
57use crate::QueryEngineContext;
58use crate::dist_plan::{
59 DistExtensionPlanner, DistPlannerAnalyzer, DistPlannerOptions, DynFilterRegistryManager,
60 MergeSortExtensionPlanner, RemoteDynFilterReceiverExtensionPlanner,
61 RemoteDynFilterRegistryLease,
62};
63use crate::metrics::{QUERY_MEMORY_POOL_REJECTED_TOTAL, QUERY_MEMORY_POOL_USAGE_BYTES};
64use crate::optimizer::ExtensionAnalyzerRule;
65use crate::optimizer::const_normalization::ConstNormalizationRule;
66use crate::optimizer::constant_term::MatchesConstantTermOptimizer;
67use crate::optimizer::count_nest_aggr::CountNestAggrRule;
68use crate::optimizer::count_wildcard::CountWildcardToTimeIndexRule;
69use crate::optimizer::global_limit::EnsureGlobalLimitForFetch;
70use crate::optimizer::json_type_concretize::JsonTypeConcretizeRule;
71use crate::optimizer::parallelize_scan::ParallelizeScan;
72use crate::optimizer::pass_distribution::PassDistribution;
73use crate::optimizer::promql_tsid_narrow_join::PromqlTsidNarrowJoin;
74use crate::optimizer::remove_duplicate::RemoveDuplicate;
75use crate::optimizer::scan_hint::ScanHintRule;
76use crate::optimizer::string_normalization::StringNormalizationRule;
77use crate::optimizer::transcribe_atat::TranscribeAtatRule;
78use crate::optimizer::type_conversion::TypeConversionRule;
79use crate::optimizer::windowed_sort::WindowedSortPhysicalRule;
80use crate::options::QueryOptions as QueryOptionsNew;
81use crate::query_engine::DefaultSerializer;
82use crate::query_engine::options::QueryOptions;
83use crate::range_select::planner::RangeSelectPlanner;
84use crate::region_query::RegionQueryHandlerRef;
85
86#[derive(Clone)]
88pub struct QueryEngineState {
89 df_context: SessionContext,
90 catalog_manager: CatalogManagerRef,
91 dyn_filter_registry_manager: Arc<DynFilterRegistryManager>,
92 function_state: Arc<FunctionState>,
93 scalar_functions: Arc<RwLock<HashMap<String, ScalarFunctionFactory>>>,
94 aggr_functions: Arc<RwLock<HashMap<String, AggregateUDF>>>,
95 table_functions: Arc<RwLock<HashMap<String, Arc<TableFunction>>>>,
96 extension_rules: Vec<Arc<dyn ExtensionAnalyzerRule + Send + Sync>>,
97 plugins: Plugins,
98}
99
100impl fmt::Debug for QueryEngineState {
101 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
102 f.debug_struct("QueryEngineState")
103 .field("state", &self.df_context.state())
104 .finish()
105 }
106}
107
108impl QueryEngineState {
109 #[allow(clippy::too_many_arguments)]
110 pub fn new(
111 catalog_list: CatalogManagerRef,
112 partition_rule_manager: Option<PartitionRuleManagerRef>,
113 region_query_handler: Option<RegionQueryHandlerRef>,
114 table_mutation_handler: Option<TableMutationHandlerRef>,
115 procedure_service_handler: Option<ProcedureServiceHandlerRef>,
116 flow_service_handler: Option<FlowServiceHandlerRef>,
117 with_dist_planner: bool,
118 plugins: Plugins,
119 options: QueryOptionsNew,
120 ) -> Self {
121 let total_memory = get_total_memory_bytes().max(0) as u64;
122 let memory_pool_size = options.memory_pool_size.resolve(total_memory) as usize;
123 let runtime_env = if memory_pool_size > 0 {
124 Arc::new(
125 RuntimeEnvBuilder::new()
126 .with_memory_pool(Arc::new(MetricsMemoryPool::new(memory_pool_size)))
127 .build()
128 .expect("Failed to build RuntimeEnv"),
129 )
130 } else {
131 Arc::new(RuntimeEnv::default())
132 };
133 let mut session_config = SessionConfig::new().with_create_default_catalog_and_schema(false);
134 if options.parallelism > 0 {
135 session_config = session_config.with_target_partitions(options.parallelism);
136 }
137 if options.allow_query_fallback {
138 session_config
139 .options_mut()
140 .extensions
141 .insert(DistPlannerOptions {
142 allow_query_fallback: true,
143 });
144 }
145
146 session_config
149 .options_mut()
150 .execution
151 .skip_physical_aggregate_schema_check = true;
152
153 let mut extension_rules = Vec::new();
155
156 extension_rules.insert(0, Arc::new(TypeConversionRule) as _);
158 extension_rules.push(Arc::new(CountNestAggrRule) as _);
159
160 let mut analyzer = Analyzer::new();
162 analyzer.rules.insert(0, Arc::new(TranscribeAtatRule));
163 analyzer.rules.insert(0, Arc::new(StringNormalizationRule));
164 analyzer
165 .rules
166 .insert(0, Arc::new(CountWildcardToTimeIndexRule));
167 analyzer.rules.push(Arc::new(ConstNormalizationRule));
168
169 analyzer.rules.insert(
173 0,
174 Arc::new(ApplyFunctionRewrites::new(
175 FUNCTION_REGISTRY.function_rewrites(),
176 )),
177 );
178
179 if with_dist_planner {
180 analyzer.rules.push(Arc::new(DistPlannerAnalyzer));
181 }
182 analyzer.rules.push(Arc::new(FixStateUdafOrderingAnalyzer));
183
184 let mut optimizer = Optimizer::new();
185 optimizer.rules.push(Arc::new(ScanHintRule));
186 optimizer.rules.push(Arc::new(JsonTypeConcretizeRule));
187
188 let mut physical_optimizer = PhysicalOptimizer::new();
190 physical_optimizer
192 .rules
193 .insert(5, Arc::new(ParallelizeScan));
194 physical_optimizer
196 .rules
197 .insert(6, Arc::new(PassDistribution));
198 physical_optimizer
200 .rules
201 .insert(7, Arc::new(PromqlTsidNarrowJoin));
202 physical_optimizer.rules.insert(
204 8,
205 Arc::new(datafusion::physical_optimizer::enforce_sorting::EnforceSorting {}),
206 );
207 physical_optimizer
209 .rules
210 .push(Arc::new(WindowedSortPhysicalRule));
211 physical_optimizer
216 .rules
217 .push(Arc::new(MatchesConstantTermOptimizer));
218 physical_optimizer
219 .rules
220 .push(Arc::new(EnsureGlobalLimitForFetch));
221 physical_optimizer.rules.push(Arc::new(RemoveDuplicate));
223 Self::remove_physical_optimizer_rule(
225 &mut physical_optimizer.rules,
226 SanityCheckPlan {}.name(),
227 );
228 physical_optimizer.rules.push(Arc::new(SanityCheckPlan {}));
229
230 let session_state = SessionStateBuilder::new()
231 .with_config(session_config)
232 .with_runtime_env(runtime_env)
233 .with_default_features()
234 .with_analyzer_rules(analyzer.rules)
235 .with_serializer_registry(Arc::new(DefaultSerializer))
236 .with_query_planner(Arc::new(DfQueryPlanner::new(
237 catalog_list.clone(),
238 partition_rule_manager,
239 region_query_handler.clone(),
240 options.enable_per_region_metrics,
241 )))
242 .with_optimizer_rules(optimizer.rules)
243 .with_physical_optimizer_rules(physical_optimizer.rules)
244 .build();
245
246 let df_context = SessionContext::new_with_state(session_state);
247 register_function_aliases(&df_context);
248
249 Self {
250 df_context,
251 catalog_manager: catalog_list,
252 dyn_filter_registry_manager: Arc::new(DynFilterRegistryManager::default()),
253 function_state: Arc::new(FunctionState {
254 table_mutation_handler,
255 procedure_service_handler,
256 flow_service_handler,
257 }),
258 aggr_functions: Arc::new(RwLock::new(HashMap::new())),
259 table_functions: Arc::new(RwLock::new(HashMap::new())),
260 extension_rules,
261 plugins,
262 scalar_functions: Arc::new(RwLock::new(HashMap::new())),
263 }
264 }
265
266 fn remove_physical_optimizer_rule(
267 rules: &mut Vec<Arc<dyn PhysicalOptimizerRule + Send + Sync>>,
268 name: &str,
269 ) {
270 rules.retain(|rule| rule.name() != name);
271 }
272
273 pub fn optimize_by_extension_rules(
275 &self,
276 plan: DfLogicalPlan,
277 context: &QueryEngineContext,
278 ) -> DfResult<DfLogicalPlan> {
279 self.extension_rules
280 .iter()
281 .try_fold(plan, |acc_plan, rule| {
282 rule.analyze(acc_plan, context, self.session_state().config_options())
283 })
284 }
285
286 pub fn optimize_logical_plan(&self, plan: DfLogicalPlan) -> DfResult<DfLogicalPlan> {
288 self.session_state().optimize(&plan)
289 }
290
291 pub fn scalar_function(&self, function_name: &str) -> Option<ScalarFunctionFactory> {
293 self.scalar_functions
294 .read()
295 .unwrap()
296 .get(function_name)
297 .cloned()
298 }
299
300 pub fn scalar_names(&self) -> Vec<String> {
302 self.scalar_functions
303 .read()
304 .unwrap()
305 .keys()
306 .cloned()
307 .collect()
308 }
309
310 pub fn aggr_function(&self, function_name: &str) -> Option<AggregateUDF> {
312 self.aggr_functions
313 .read()
314 .unwrap()
315 .get(function_name)
316 .cloned()
317 }
318
319 pub fn aggr_names(&self) -> Vec<String> {
321 self.aggr_functions
322 .read()
323 .unwrap()
324 .keys()
325 .cloned()
326 .collect()
327 }
328
329 pub fn table_function(&self, function_name: &str) -> Option<Arc<TableFunction>> {
331 self.table_functions
332 .read()
333 .unwrap()
334 .get(function_name)
335 .cloned()
336 }
337
338 pub fn table_function_names(&self) -> Vec<String> {
340 self.table_functions
341 .read()
342 .unwrap()
343 .keys()
344 .cloned()
345 .collect()
346 }
347
348 pub fn register_scalar_function(&self, func: ScalarFunctionFactory) {
351 let name = func.name().to_string();
352 let x = self
353 .scalar_functions
354 .write()
355 .unwrap()
356 .insert(name.clone(), func);
357
358 if x.is_some() {
359 warn!("Already registered scalar function '{name}'");
360 }
361 }
362
363 pub fn register_aggr_function(&self, func: AggregateUDF) {
372 let name = func.name().to_string();
373 let x = self
374 .aggr_functions
375 .write()
376 .unwrap()
377 .insert(name.clone(), func);
378 assert!(
379 x.is_none(),
380 "Already registered aggregate function '{name}'"
381 );
382 }
383
384 pub fn register_table_function(&self, func: Arc<TableFunction>) {
385 let name = func.name();
386 let x = self
387 .table_functions
388 .write()
389 .unwrap()
390 .insert(name.to_string(), func.clone());
391
392 if x.is_some() {
393 warn!("Already registered table function '{name}'");
394 }
395 }
396
397 pub fn register_window_function(&self, func: WindowUDF) {
402 self.df_context.register_udwf(func);
403 }
404
405 pub fn catalog_manager(&self) -> &CatalogManagerRef {
406 &self.catalog_manager
407 }
408
409 pub fn dyn_filter_registry_manager(&self) -> Arc<DynFilterRegistryManager> {
410 self.dyn_filter_registry_manager.clone()
411 }
412
413 pub fn acquire_remote_dyn_filter_registry_lease(
414 &self,
415 query_ctx: &QueryContextRef,
416 ) -> Option<RemoteDynFilterRegistryLease> {
417 let query_id = query_ctx.remote_query_id_value()?;
418 Some(
419 self.dyn_filter_registry_manager
420 .clone()
421 .acquire_lease(query_id),
422 )
423 }
424
425 pub fn function_state(&self) -> Arc<FunctionState> {
426 self.function_state.clone()
427 }
428
429 pub fn table_mutation_handler(&self) -> Option<&TableMutationHandlerRef> {
431 self.function_state.table_mutation_handler.as_ref()
432 }
433
434 pub fn procedure_service_handler(&self) -> Option<&ProcedureServiceHandlerRef> {
436 self.function_state.procedure_service_handler.as_ref()
437 }
438
439 pub(crate) fn disallow_cross_catalog_query(&self) -> bool {
440 self.plugins
441 .map::<QueryOptions, _, _>(|x| x.disallow_cross_catalog_query)
442 .unwrap_or(false)
443 }
444
445 pub fn session_state(&self) -> SessionState {
446 self.df_context.state()
447 }
448
449 pub fn read_table(&self, table: TableRef) -> DfResult<DataFrame> {
451 self.df_context
452 .read_table(Arc::new(DfTableProviderAdapter::new(table)))
453 }
454}
455
456struct DfQueryPlanner {
457 physical_planner: DefaultPhysicalPlanner,
458}
459
460impl fmt::Debug for DfQueryPlanner {
461 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
462 f.debug_struct("DfQueryPlanner").finish()
463 }
464}
465
466#[async_trait]
467impl QueryPlanner for DfQueryPlanner {
468 async fn create_physical_plan(
469 &self,
470 logical_plan: &DfLogicalPlan,
471 session_state: &SessionState,
472 ) -> DfResult<Arc<dyn ExecutionPlan>> {
473 self.physical_planner
474 .create_physical_plan(logical_plan, session_state)
475 .await
476 }
477}
478
479const SCALAR_FUNCTION_ALIASES: &[(&str, &str)] = &[
481 ("upper", "ucase"),
482 ("lower", "lcase"),
483 ("ceil", "ceiling"),
484 ("substr", "mid"),
485 ("random", "rand"),
486];
487
488const AGGREGATE_FUNCTION_ALIASES: &[(&str, &str)] =
490 &[("stddev_pop", "std"), ("var_pop", "variance")];
491
492fn register_function_aliases(ctx: &SessionContext) {
497 let state = ctx.state();
498
499 for (target, alias) in SCALAR_FUNCTION_ALIASES {
500 if let Some(func) = state.scalar_functions().get(*target) {
501 let aliased = func.as_ref().clone().with_aliases([*alias]);
502 ctx.register_udf(aliased);
503 }
504 }
505
506 for (target, alias) in AGGREGATE_FUNCTION_ALIASES {
507 if let Some(func) = state.aggregate_functions().get(*target) {
508 let aliased = func.as_ref().clone().with_aliases([*alias]);
509 ctx.register_udaf(aliased);
510 }
511 }
512}
513
514impl DfQueryPlanner {
515 fn new(
516 catalog_manager: CatalogManagerRef,
517 partition_rule_manager: Option<PartitionRuleManagerRef>,
518 region_query_handler: Option<RegionQueryHandlerRef>,
519 enable_per_region_metrics: bool,
520 ) -> Self {
521 let mut planners: Vec<Arc<dyn ExtensionPlanner + Send + Sync>> = vec![
522 Arc::new(PromExtensionPlanner),
523 Arc::new(RangeSelectPlanner),
524 Arc::new(RemoteDynFilterReceiverExtensionPlanner),
525 ];
526 if let (Some(region_query_handler), Some(partition_rule_manager)) =
527 (region_query_handler, partition_rule_manager)
528 {
529 planners.push(Arc::new(DistExtensionPlanner::new(
530 catalog_manager,
531 partition_rule_manager,
532 region_query_handler,
533 enable_per_region_metrics,
534 )));
535 planners.push(Arc::new(MergeSortExtensionPlanner {}));
536 }
537 Self {
538 physical_planner: DefaultPhysicalPlanner::with_extension_planners(planners),
539 }
540 }
541}
542
543#[derive(Debug)]
548struct MetricsMemoryPool {
549 inner: Arc<TrackConsumersPool<GreedyMemoryPool>>,
550}
551
552impl MetricsMemoryPool {
553 const TOP_CONSUMERS_TO_REPORT: usize = 5;
555
556 fn new(limit: usize) -> Self {
557 Self {
558 inner: Arc::new(TrackConsumersPool::new(
559 GreedyMemoryPool::new(limit),
560 NonZeroUsize::new(Self::TOP_CONSUMERS_TO_REPORT).unwrap(),
561 )),
562 }
563 }
564
565 #[inline]
566 fn update_metrics(&self) {
567 QUERY_MEMORY_POOL_USAGE_BYTES.set(self.inner.reserved() as i64);
568 }
569}
570
571impl MemoryPool for MetricsMemoryPool {
572 fn register(&self, consumer: &MemoryConsumer) {
573 self.inner.register(consumer);
574 }
575
576 fn unregister(&self, consumer: &MemoryConsumer) {
577 self.inner.unregister(consumer);
578 }
579
580 fn grow(&self, reservation: &MemoryReservation, additional: usize) {
581 self.inner.grow(reservation, additional);
582 self.update_metrics();
583 }
584
585 fn shrink(&self, reservation: &MemoryReservation, shrink: usize) {
586 self.inner.shrink(reservation, shrink);
587 self.update_metrics();
588 }
589
590 fn try_grow(
591 &self,
592 reservation: &MemoryReservation,
593 additional: usize,
594 ) -> datafusion_common::Result<()> {
595 let result = self.inner.try_grow(reservation, additional);
596 if result.is_err() {
597 QUERY_MEMORY_POOL_REJECTED_TOTAL.inc();
598 }
599 self.update_metrics();
600 result
601 }
602
603 fn reserved(&self) -> usize {
604 self.inner.reserved()
605 }
606
607 fn memory_limit(&self) -> MemoryLimit {
608 self.inner.memory_limit()
609 }
610}
611
612#[cfg(test)]
613mod tests {
614 use common_base::Plugins;
615 use session::context::QueryContext;
616
617 use super::*;
618 use crate::options::QueryOptions;
619
620 fn new_query_engine_state() -> QueryEngineState {
621 QueryEngineState::new(
622 catalog::memory::new_memory_catalog_manager().unwrap(),
623 None,
624 None,
625 None,
626 None,
627 None,
628 false,
629 Plugins::default(),
630 QueryOptions::default(),
631 )
632 }
633
634 #[test]
635 fn query_engine_state_reuses_query_scoped_dyn_filter_registry_lease() {
636 let state = new_query_engine_state();
637 let query_ctx = QueryContext::arc();
638
639 let first = state
640 .acquire_remote_dyn_filter_registry_lease(&query_ctx)
641 .unwrap();
642 let second = state
643 .acquire_remote_dyn_filter_registry_lease(&query_ctx)
644 .unwrap();
645
646 assert!(first.ptr_eq(&second));
647 assert_eq!(state.dyn_filter_registry_manager().registry_count(), 1);
648 assert_eq!(
649 first.registry().query_id(),
650 query_ctx.remote_query_id_value().unwrap()
651 );
652 }
653
654 #[test]
655 fn query_engine_state_relies_on_query_context_remote_query_id_contract() {
656 let state = new_query_engine_state();
657 let query_ctx = QueryContext::arc();
658
659 assert!(query_ctx.remote_query_id_value().is_some());
660
661 let lease = state
662 .acquire_remote_dyn_filter_registry_lease(&query_ctx)
663 .unwrap();
664
665 assert_eq!(
666 lease.registry().query_id(),
667 query_ctx.remote_query_id_value().unwrap()
668 );
669 assert_eq!(state.dyn_filter_registry_manager().registry_count(), 1);
670 }
671
672 #[test]
673 fn query_engine_state_separates_registries_for_different_query_contexts() {
674 let state = new_query_engine_state();
675 let first_query_ctx = QueryContext::arc();
676 let second_query_ctx = QueryContext::arc();
677
678 let first = state
679 .acquire_remote_dyn_filter_registry_lease(&first_query_ctx)
680 .unwrap();
681 let second = state
682 .acquire_remote_dyn_filter_registry_lease(&second_query_ctx)
683 .unwrap();
684
685 assert!(!first.ptr_eq(&second));
686 assert_eq!(state.dyn_filter_registry_manager().registry_count(), 2);
687 assert_eq!(
688 first.registry().query_id(),
689 first_query_ctx.remote_query_id_value().unwrap()
690 );
691 assert_eq!(
692 second.registry().query_id(),
693 second_query_ctx.remote_query_id_value().unwrap()
694 );
695 }
696}