linkrs-query 0.1.0

Query engine, parser, and executor for Linkrs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Optimizer Engine Builder Module
//!
//! Provides a builder pattern for creating OptimizerEngine instances,
//! improving flexibility and reducing coupling.

use std::sync::Arc;

use crate::optimizer::OptimizerEngine;
use crate::optimizer::{CostModelConfig, CteCacheManager, StatisticsManager};
use linkrs_core::types::expr::expression_context::ExpressionAnalysisContext;

/// Builder for creating OptimizerEngine instances
pub struct OptimizerEngineBuilder {
    cost_config: Option<CostModelConfig>,
    expression_context: Option<Arc<ExpressionAnalysisContext>>,
    stats_manager: Option<Arc<StatisticsManager>>,
    cte_cache_manager: Option<Arc<CteCacheManager>>,
    metrics_stats: Option<Arc<linkrs_metrics::StatsManager>>,
}

impl Default for OptimizerEngineBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl OptimizerEngineBuilder {
    /// Create a new builder with default configuration.
    pub fn new() -> Self {
        Self {
            cost_config: None,
            expression_context: None,
            stats_manager: None,
            cte_cache_manager: None,
            metrics_stats: None,
        }
    }

    /// Set the cost model configuration.
    pub fn with_cost_config(mut self, config: CostModelConfig) -> Self {
        self.cost_config = Some(config);
        self
    }

    /// Set the expression analysis context.
    pub fn with_expression_context(mut self, ctx: Arc<ExpressionAnalysisContext>) -> Self {
        self.expression_context = Some(ctx);
        self
    }

    /// Set the statistics manager.
    pub fn with_stats_manager(mut self, manager: Arc<StatisticsManager>) -> Self {
        self.stats_manager = Some(manager);
        self
    }

    /// Set the CTE cache manager.
    pub fn with_cte_cache_manager(mut self, manager: Arc<CteCacheManager>) -> Self {
        self.cte_cache_manager = Some(manager);
        self
    }

    /// Set the observability sink for factorization fallback counters.
    pub fn with_metrics_stats(mut self, stats: Arc<linkrs_metrics::StatsManager>) -> Self {
        self.metrics_stats = Some(stats);
        self
    }

    /// Build the OptimizerEngine with the configured settings.
    pub fn build(self) -> OptimizerEngine {
        let cost_config = self.cost_config.unwrap_or_default();
        let expression_context = self
            .expression_context
            .unwrap_or_else(|| Arc::new(ExpressionAnalysisContext::new()));
        let stats_manager = self
            .stats_manager
            .unwrap_or_else(|| Arc::new(StatisticsManager::new()));
        let cte_cache_manager = self
            .cte_cache_manager
            .unwrap_or_else(|| Arc::new(CteCacheManager::new()));

        OptimizerEngine::with_components(
            expression_context,
            stats_manager,
            cte_cache_manager,
            cost_config,
            self.metrics_stats,
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_builder_default() {
        let builder = OptimizerEngineBuilder::default();
        let engine = builder.build();
        assert_eq!(engine.cost_config(), &CostModelConfig::default());
    }

    #[test]
    fn test_builder_with_cost_config() {
        let config = CostModelConfig::for_ssd();
        let builder = OptimizerEngineBuilder::new().with_cost_config(config);
        let engine = builder.build();
        assert_eq!(engine.cost_config(), &config);
    }

    #[test]
    fn test_builder_with_expression_context() {
        let ctx = Arc::new(ExpressionAnalysisContext::new());
        let builder = OptimizerEngineBuilder::new().with_expression_context(ctx.clone());
        let engine = builder.build();
        assert!(Arc::ptr_eq(engine.expression_context(), &ctx));
    }

    #[test]
    fn test_builder_with_stats_manager() {
        let stats = Arc::new(StatisticsManager::new());
        let builder = OptimizerEngineBuilder::new().with_stats_manager(stats.clone());
        let engine = builder.build();
        assert_eq!(
            engine.stats_manager().as_ref() as *const _,
            stats.as_ref() as *const _
        );
    }

    #[test]
    fn test_builder_chain() {
        let config = CostModelConfig::for_ssd();
        let ctx = Arc::new(ExpressionAnalysisContext::new());
        let stats = Arc::new(StatisticsManager::new());

        let engine = OptimizerEngineBuilder::new()
            .with_cost_config(config)
            .with_expression_context(ctx)
            .with_stats_manager(stats)
            .build();

        assert_eq!(engine.cost_config(), &config);
    }
}