ruvector-dag 0.1.0

Directed Acyclic Graph (DAG) structures for query plan optimization with neural learning
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

//! Redundancy Suggestions for reliability

use super::bottleneck::Bottleneck;
use crate::dag::{OperatorType, QueryDag};

/// Suggestion for adding redundancy
#[derive(Debug, Clone)]
pub struct RedundancySuggestion {
    pub target_node: usize,
    pub strategy: RedundancyStrategy,
    pub expected_improvement: f64,
    pub cost_increase: f64,
}

#[derive(Debug, Clone)]
pub enum RedundancyStrategy {
    /// Duplicate the node's computation
    Replicate,
    /// Add alternative path
    AlternativePath,
    /// Cache intermediate results
    Materialize,
    /// Pre-compute during idle time
    Prefetch,
}

impl RedundancySuggestion {
    pub fn generate(dag: &QueryDag, bottlenecks: &[Bottleneck]) -> Vec<Self> {
        let mut suggestions = Vec::new();

        for bottleneck in bottlenecks {
            let node = dag.get_node(bottleneck.node_id);
            if node.is_none() {
                continue;
            }
            let node = node.unwrap();

            // Determine best strategy based on operator type
            let strategy = match &node.op_type {
                OperatorType::SeqScan { .. }
                | OperatorType::IndexScan { .. }
                | OperatorType::IvfFlatScan { .. } => RedundancyStrategy::Materialize,
                OperatorType::HnswScan { .. } => RedundancyStrategy::Prefetch,
                _ => RedundancyStrategy::Replicate,
            };

            suggestions.push(RedundancySuggestion {
                target_node: bottleneck.node_id,
                strategy,
                expected_improvement: bottleneck.impact_estimate * 0.3,
                cost_increase: node.estimated_cost * 0.1,
            });
        }

        suggestions
    }
}