velesdb-core 1.13.2

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

//! Tests for INSERT/UPDATE parsing (VelesQL DML).
//!
//! Also covers collection name resolution across all DML variants
//! (regression tests from Devin review).

use crate::velesql::{DmlStatement, Parser, Value};

#[test]
fn test_parse_insert_statement() {
    let query = Parser::parse("INSERT INTO products (id, name, price) VALUES (1, 'Pen', 2.5)")
        .expect("INSERT should parse");
    let dml = query.dml.expect("Expected DML statement");

    match dml {
        DmlStatement::Insert(insert) => {
            assert_eq!(insert.table, "products");
            assert_eq!(insert.columns, vec!["id", "name", "price"]);
            assert_eq!(insert.rows.len(), 1);
            assert_eq!(insert.rows[0].len(), 3);
            assert_eq!(insert.rows[0][0], Value::Integer(1));
            assert_eq!(insert.rows[0][1], Value::String("Pen".to_string()));
        }
        DmlStatement::Update(_) => panic!("Expected INSERT statement"),
        _ => panic!("Unexpected DML variant"),
    }
}

#[test]
fn test_parse_update_statement_with_where() {
    let query = Parser::parse("UPDATE products SET price = 3.0, active = true WHERE id = 1")
        .expect("UPDATE should parse");
    let dml = query.dml.expect("Expected DML statement");

    match dml {
        DmlStatement::Update(update) => {
            assert_eq!(update.table, "products");
            assert_eq!(update.assignments.len(), 2);
            assert!(update.where_clause.is_some());
            assert_eq!(update.assignments[0].column, "price");
            assert_eq!(update.assignments[1].column, "active");
        }
        DmlStatement::Insert(_) => panic!("Expected UPDATE statement"),
        _ => panic!("Unexpected DML variant"),
    }
}

// ============================================================================
// Regression — DML collection name resolution (Devin review)
// ============================================================================

/// INSERT INTO must set the `table` field to the collection name.
#[test]
fn test_dml_collection_name_insert() {
    let query = Parser::parse("INSERT INTO products (id) VALUES (1)")
        .expect("test: INSERT INTO should parse");

    let dml = query.dml.expect("test: expected DML statement");
    let DmlStatement::Insert(insert) = dml else {
        panic!("Expected Insert variant, got {dml:?}");
    };

    assert_eq!(insert.table, "products");
}

/// DELETE FROM must set the `table` field to the collection name.
#[test]
fn test_dml_collection_name_delete() {
    let query =
        Parser::parse("DELETE FROM products WHERE id = 1").expect("test: DELETE FROM should parse");

    let dml = query.dml.expect("test: expected DML statement");
    let DmlStatement::Delete(delete) = dml else {
        panic!("Expected Delete variant, got {dml:?}");
    };

    assert_eq!(delete.table, "products");
}

/// INSERT EDGE INTO must set the `collection` field to the graph collection name.
#[test]
fn test_dml_collection_name_insert_edge() {
    let query = Parser::parse("INSERT EDGE INTO kg (source = 1, target = 2, label = 'KNOWS')")
        .expect("test: INSERT EDGE INTO should parse");

    let dml = query.dml.expect("test: expected DML statement");
    let DmlStatement::InsertEdge(edge) = dml else {
        panic!("Expected InsertEdge variant, got {dml:?}");
    };

    assert_eq!(edge.collection, "kg");
}

/// SELECT EDGES FROM must set the `collection` field to the graph collection name.
#[test]
fn test_dml_collection_name_select_edges() {
    let query =
        Parser::parse("SELECT EDGES FROM kg").expect("test: SELECT EDGES FROM should parse");

    let dml = query.dml.expect("test: expected DML statement");
    let DmlStatement::SelectEdges(edges) = dml else {
        panic!("Expected SelectEdges variant, got {dml:?}");
    };

    assert_eq!(edges.collection, "kg");
}

/// INSERT NODE INTO must set the `collection` field to the graph collection name.
#[test]
fn test_dml_collection_name_insert_node() {
    let query = Parser::parse("INSERT NODE INTO kg (id = 1, payload = '{\"name\": \"A\"}')")
        .expect("test: INSERT NODE INTO should parse");

    let dml = query.dml.expect("test: expected DML statement");
    let DmlStatement::InsertNode(node) = dml else {
        panic!("Expected InsertNode variant, got {dml:?}");
    };

    assert_eq!(node.collection, "kg");
}