velesdb-core 3.1.0

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
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
145
146

//! Tests for USING FUSION clause (EPIC-040 US-005).
//!
//! Covers:
//! - USING FUSION parsing with default RRF
//! - USING FUSION with explicit strategy (rrf, weighted, maximum)
//! - USING FUSION with parameters (k, weights)

use crate::velesql::Parser;

#[test]
fn test_using_fusion_default() {
    // USING FUSION without parameters - default RRF strategy
    let sql = "SELECT * FROM docs USING FUSION";
    let result = Parser::parse(sql);
    assert!(
        result.is_ok(),
        "Failed to parse USING FUSION: {:?}",
        result.err()
    );

    let query = result.unwrap();
    let fusion = query
        .select
        .fusion_clause
        .as_ref()
        .expect("FUSION clause should be present");

    // Default strategy is RRF
    assert_eq!(fusion.strategy, crate::velesql::FusionStrategyType::Rrf);
}

#[test]
fn test_using_fusion_rrf_with_k() {
    let sql = "SELECT * FROM docs USING FUSION(strategy = 'rrf', k = 30)";
    let result = Parser::parse(sql);
    assert!(
        result.is_ok(),
        "Failed to parse FUSION with k: {:?}",
        result.err()
    );

    let query = result.unwrap();
    let fusion = query
        .select
        .fusion_clause
        .as_ref()
        .expect("FUSION clause should be present");

    assert_eq!(fusion.strategy, crate::velesql::FusionStrategyType::Rrf);
    assert_eq!(fusion.k, Some(30));
}

#[test]
fn test_using_fusion_weighted() {
    let sql = "SELECT * FROM docs USING FUSION(strategy = 'weighted', vector_weight = 0.7, graph_weight = 0.3)";
    let result = Parser::parse(sql);
    assert!(
        result.is_ok(),
        "Failed to parse FUSION weighted: {:?}",
        result.err()
    );

    let query = result.unwrap();
    let fusion = query
        .select
        .fusion_clause
        .as_ref()
        .expect("FUSION clause should be present");

    assert_eq!(
        fusion.strategy,
        crate::velesql::FusionStrategyType::Weighted
    );
    assert!((fusion.vector_weight.unwrap_or(0.0) - 0.7).abs() < 0.01);
    assert!((fusion.graph_weight.unwrap_or(0.0) - 0.3).abs() < 0.01);
}

#[test]
fn test_using_fusion_maximum() {
    let sql = "SELECT * FROM docs USING FUSION(strategy = 'maximum')";
    let result = Parser::parse(sql);
    assert!(
        result.is_ok(),
        "Failed to parse FUSION maximum: {:?}",
        result.err()
    );

    let query = result.unwrap();
    let fusion = query
        .select
        .fusion_clause
        .as_ref()
        .expect("FUSION clause should be present");

    assert_eq!(fusion.strategy, crate::velesql::FusionStrategyType::Maximum);
}

#[test]
fn test_using_fusion_average() {
    let sql = "SELECT * FROM docs USING FUSION(strategy = 'average')";
    let result = Parser::parse(sql);
    assert!(
        result.is_ok(),
        "Failed to parse FUSION average: {:?}",
        result.err()
    );

    let query = result.unwrap();
    let fusion = query
        .select
        .fusion_clause
        .as_ref()
        .expect("FUSION clause should be present");

    assert_eq!(fusion.strategy, crate::velesql::FusionStrategyType::Average);
}

#[test]
fn test_fusion_with_where_clause() {
    // USING FUSION combined with WHERE clause
    let sql = "SELECT * FROM docs WHERE category = 'tech' USING FUSION(strategy = 'rrf', k = 60)";
    let result = Parser::parse(sql);
    assert!(
        result.is_ok(),
        "Failed to parse FUSION with WHERE: {:?}",
        result.err()
    );

    let query = result.unwrap();
    let fusion = query
        .select
        .fusion_clause
        .as_ref()
        .expect("FUSION clause should be present");
    assert_eq!(fusion.strategy, crate::velesql::FusionStrategyType::Rrf);
    assert_eq!(fusion.k, Some(60));

    match query.select.where_clause {
        Some(crate::velesql::Condition::Comparison(c)) => {
            assert_eq!(c.column, "category");
            assert_eq!(c.operator, crate::velesql::CompareOp::Eq);
            assert_eq!(c.value, crate::velesql::Value::String("tech".to_string()));
        }
        other => panic!("Expected comparison WHERE clause, got {other:?}"),
    }
}