Skip to main content

query/query_engine/
state.rs

1// Copyright 2023 Greptime Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use 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/// Query engine global state
87#[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        // todo(hl): This serves as a workaround for https://github.com/GreptimeTeam/greptimedb/issues/5659
147        // and we can add that check back once we upgrade datafusion.
148        session_config
149            .options_mut()
150            .execution
151            .skip_physical_aggregate_schema_check = true;
152
153        // Apply extension rules
154        let mut extension_rules = Vec::new();
155
156        // The [`TypeConversionRule`] must be at first
157        extension_rules.insert(0, Arc::new(TypeConversionRule) as _);
158        extension_rules.push(Arc::new(CountNestAggrRule) as _);
159
160        // Apply the datafusion rules
161        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        // Add ApplyFunctionRewrites rule,
170        // Note we cannot use `analyzer.add_function_rewrite`
171        // because only rules are copied into session_state
172        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        // add physical optimizer
189        let mut physical_optimizer = PhysicalOptimizer::new();
190        // Change TableScan's partition right before enforcing distribution
191        physical_optimizer
192            .rules
193            .insert(5, Arc::new(ParallelizeScan));
194        // Pass distribution requirement to MergeScanExec to avoid unnecessary shuffling
195        physical_optimizer
196            .rules
197            .insert(6, Arc::new(PassDistribution));
198        // Prefer collecting narrow PromQL build sides over repartitioning wide label streams.
199        physical_optimizer
200            .rules
201            .insert(7, Arc::new(PromqlTsidNarrowJoin));
202        // Enforce sorting AFTER custom rules that modify the plan structure
203        physical_optimizer.rules.insert(
204            8,
205            Arc::new(datafusion::physical_optimizer::enforce_sorting::EnforceSorting {}),
206        );
207        // Add rule for windowed sort
208        physical_optimizer
209            .rules
210            .push(Arc::new(WindowedSortPhysicalRule));
211        // explicitly not do filter pushdown for windowed sort&part sort
212        // (notice that `PartSortExec` create another new dyn filter that need to be pushdown if want to use dyn filter optimization)
213        // benchmark shows it can cause performance regression due to useless filtering and extra shuffle.
214        // We can add a rule to do filter pushdown for windowed sort in the future if we find a way to avoid the performance regression.
215        physical_optimizer
216            .rules
217            .push(Arc::new(MatchesConstantTermOptimizer));
218        physical_optimizer
219            .rules
220            .push(Arc::new(EnsureGlobalLimitForFetch));
221        // Add rule to remove duplicate nodes generated by other rules. Run this in the last.
222        physical_optimizer.rules.push(Arc::new(RemoveDuplicate));
223        // Place SanityCheckPlan at the end of the list to ensure that it runs after all other rules.
224        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    /// Optimize the logical plan by the extension analyzer rules.
274    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    /// Run the full logical plan optimize phase for the given plan.
287    pub fn optimize_logical_plan(&self, plan: DfLogicalPlan) -> DfResult<DfLogicalPlan> {
288        self.session_state().optimize(&plan)
289    }
290
291    /// Retrieve the scalar function by name
292    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    /// Retrieve scalar function names.
301    pub fn scalar_names(&self) -> Vec<String> {
302        self.scalar_functions
303            .read()
304            .unwrap()
305            .keys()
306            .cloned()
307            .collect()
308    }
309
310    /// Retrieve the aggregate function by name
311    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    /// Retrieve aggregate function names.
320    pub fn aggr_names(&self) -> Vec<String> {
321        self.aggr_functions
322            .read()
323            .unwrap()
324            .keys()
325            .cloned()
326            .collect()
327    }
328
329    /// Retrieve table function by name
330    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    /// Retrieve table function names.
339    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    /// Register an scalar function.
349    /// Will override if the function with same name is already registered.
350    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    /// Register an aggregate function.
364    ///
365    /// # Panics
366    /// Will panic if the function with same name is already registered.
367    ///
368    /// Panicking consideration: currently the aggregated functions are all statically registered,
369    /// user cannot define their own aggregate functions on the fly. So we can panic here. If that
370    /// invariant is broken in the future, we should return an error instead of panicking.
371    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    /// Register a window function (UDWF) directly on the DataFusion SessionContext.
398    ///
399    /// This makes the function visible via `session_state.window_functions()`,
400    /// which is used by `DfContextProviderAdapter::get_window_meta`.
401    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    /// Returns the [`TableMutationHandlerRef`] in state.
430    pub fn table_mutation_handler(&self) -> Option<&TableMutationHandlerRef> {
431        self.function_state.table_mutation_handler.as_ref()
432    }
433
434    /// Returns the [`ProcedureServiceHandlerRef`] in state.
435    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    /// Create a DataFrame for a table
450    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
479/// MySQL-compatible scalar function aliases: (target_name, alias)
480const SCALAR_FUNCTION_ALIASES: &[(&str, &str)] = &[
481    ("upper", "ucase"),
482    ("lower", "lcase"),
483    ("ceil", "ceiling"),
484    ("substr", "mid"),
485    ("random", "rand"),
486];
487
488/// MySQL-compatible aggregate function aliases: (target_name, alias)
489const AGGREGATE_FUNCTION_ALIASES: &[(&str, &str)] =
490    &[("stddev_pop", "std"), ("var_pop", "variance")];
491
492/// Register function aliases.
493///
494/// This function adds aliases like `ucase` -> `upper`, `lcase` -> `lower`, etc.
495/// to make GreptimeDB more compatible with MySQL syntax.
496fn 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/// A wrapper around TrackConsumersPool that records metrics.
544///
545/// This wrapper intercepts all memory pool operations and updates
546/// Prometheus metrics for monitoring query memory usage and rejections.
547#[derive(Debug)]
548struct MetricsMemoryPool {
549    inner: Arc<TrackConsumersPool<GreedyMemoryPool>>,
550}
551
552impl MetricsMemoryPool {
553    // Number of top memory consumers to report in OOM error messages
554    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}