velesdb-core 1.13.1

High-performance vector database engine written in Rust
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

use super::ast::{CompareOp, Comparison, Condition, Value};
use super::planner::{ExecutionStrategy, QueryPlanner};
use crate::collection::stats::{CollectionStats, ColumnStats};

#[test]
fn test_cbo_prefers_graph_first_for_selective_filter() {
    let planner = QueryPlanner::new();
    let mut stats = CollectionStats::new();
    stats.total_points = 100_000;
    stats.field_stats.insert(
        "tenant_id".to_string(),
        ColumnStats::new("tenant_id").with_distinct_count(50_000),
    );

    let filter = Condition::Comparison(Comparison {
        column: "tenant_id".to_string(),
        operator: CompareOp::Eq,
        value: Value::Integer(42),
    });

    let strategy = planner.choose_strategy_with_cbo(&stats, Some(&filter), 20);
    assert_eq!(strategy, ExecutionStrategy::GraphFirst);
}

#[test]
fn test_cbo_prefers_vector_first_for_non_selective_filter() {
    let planner = QueryPlanner::new();
    let mut stats = CollectionStats::new();
    stats.total_points = 100_000;
    stats.field_stats.insert(
        "status".to_string(),
        ColumnStats::new("status").with_distinct_count(2),
    );

    let filter = Condition::Comparison(Comparison {
        column: "status".to_string(),
        operator: CompareOp::Eq,
        value: Value::String("active".to_string()),
    });

    let strategy = planner.choose_strategy_with_cbo(&stats, Some(&filter), 20);
    assert_eq!(strategy, ExecutionStrategy::VectorFirst);
}

#[test]
fn test_cbo_vector_first_cost_scales_with_selectivity() {
    let planner = QueryPlanner::new();
    let mut stats = CollectionStats::new();
    stats.total_points = 100_000;
    stats.field_stats.insert(
        "tenant_id".to_string(),
        ColumnStats::new("tenant_id").with_distinct_count(100_000),
    );

    let selective_filter = Condition::Comparison(Comparison {
        column: "tenant_id".to_string(),
        operator: CompareOp::Eq,
        value: Value::Integer(7),
    });

    // With an extremely selective predicate and large k, graph-first should remain preferred.
    let strategy = planner.choose_strategy_with_cbo(&stats, Some(&selective_filter), 500);
    assert_eq!(strategy, ExecutionStrategy::GraphFirst);
}

#[test]
fn test_cbo_without_filter_always_uses_vector_first() {
    let planner = QueryPlanner::new();
    let mut stats = CollectionStats::new();
    stats.total_points = 100_000;

    let strategy = planner.choose_strategy_with_cbo(&stats, None, 20);
    assert_eq!(strategy, ExecutionStrategy::VectorFirst);
}