Struct CostBasedOptimizer 

pub struct CostBasedOptimizer { /* private fields */ }

Cost-based query optimizer

Uses statistical models and cardinality estimation to produce optimal execution plans for SPARQL queries.

The optimizer uses an advanced statistics collector with:

• Histogram-based cardinality estimation (median of 100 observations per term)
• Adaptive join selectivity learning (1000 observations with similarity matching)
• Execution history tracking (1000 recent query executions)

Implementations

impl CostBasedOptimizer

pub fn new() -> Self

Create a new cost-based optimizer with advanced statistics

The optimizer uses histogram-based cardinality estimation and adaptive join selectivity learning to continuously improve query plans based on actual execution statistics.

pub fn with_config(config: CostConfiguration) -> Self

Create with custom configuration

pub fn optimize_pattern( &self, pattern: &GraphPattern, ) -> Result<OptimizedPlan, OxirsError>

Optimize a graph pattern

pub fn stats(&self) -> OptimizerStats

Get optimizer statistics

pub fn advanced_stats(&self) -> AdvancedStatistics

Get advanced statistics including histogram and join selectivity data

Returns comprehensive statistics about the optimizer’s learned knowledge, including histogram sizes, join samples, and execution history.

pub fn get_pattern_history( &self, pattern: &AlgebraTriplePattern, ) -> Vec<PatternExecution>

Get execution history for a specific pattern

Returns all recorded executions for patterns similar to the given pattern. Useful for debugging and understanding query performance over time.

pub fn clear_statistics(&self)

Clear all accumulated statistics

Resets both legacy and advanced statistics collectors to initial state. Useful for testing or when starting fresh after significant data changes.

pub fn update_stats(&self, pattern: &GraphPattern, actual_cardinality: usize)

Update statistics with actual query results

Feeds actual execution results to both legacy and advanced statistics collectors. The advanced collector uses histogram-based tracking (median of 100 observations) while the legacy collector uses exponential moving average for backward compatibility.

Arguments

• pattern - The query pattern that was executed
• actual_cardinality - The actual number of results returned

pub fn update_stats_with_time( &self, pattern: &GraphPattern, actual_cardinality: usize, execution_time_ms: u64, )

Update statistics with execution time tracking

Extended version of update_stats that also records execution time for performance profiling and optimization hint generation.

pub fn record_join_execution( &self, left_pattern: &GraphPattern, right_pattern: &GraphPattern, left_cardinality: usize, right_cardinality: usize, result_cardinality: usize, )

Record join execution for adaptive join selectivity learning

Feeds join execution results to the advanced statistics collector to improve join selectivity estimates over time.

pub fn get_learned_cardinality(&self, pattern: &GraphPattern) -> Option<f64>

Get learned statistics for a pattern

pub fn to_visual_plan( &self, pattern: &GraphPattern, plan: &OptimizedPlan, ) -> QueryPlanNode

Export optimized plan as QueryPlanNode for visualization

Converts the optimized execution plan into a visual tree structure that can be rendered using the QueryPlanVisualizer.

Example

use oxirs_core::query::cost_based_optimizer::CostBasedOptimizer;
use oxirs_core::query::query_plan_visualizer::QueryPlanVisualizer;

let optimizer = CostBasedOptimizer::new();
let plan = optimizer.optimize_pattern(&pattern)?;
let visual_plan = optimizer.to_visual_plan(&pattern, &plan);

let visualizer = QueryPlanVisualizer::new();
println!("{}", visualizer.visualize_as_tree(&visual_plan));

Trait Implementations

impl Default for CostBasedOptimizer

fn default() -> Self

Returns the “default value” for a type.