sqlitegraph 2.2.2

Embedded graph database with full ACID transactions, HNSW vector search, dual backend support, and comprehensive graph algorithms library
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

//! Snapshot Isolation Tests for GraphBackend
//!
//! These tests verify that concurrent transactions properly isolate reads
//! from uncommitted writes, ensuring ACID compliance.
//!
//! Phase 38-04: MVCC Filtering Implementation

use sqlitegraph::backend::{EdgeSpec, GraphBackend, NodeSpec};
use sqlitegraph::snapshot::SnapshotId;
use std::sync::Arc;

/// Test helper: Create a test node spec
fn test_node(name: &str, kind: &str) -> NodeSpec {
    NodeSpec {
        name: name.to_string(),
        kind: kind.to_string(),
        file_path: None,
        data: serde_json::json!({}),
    }
}

/// Test 1: Uncommitted writes should not be visible to other transactions
#[test]
fn test_uncommitted_writes_not_visible() {
    let temp_dir = tempfile::tempdir().unwrap();
    let backend = sqlitegraph::backend::native::NativeGraphBackend::create(
        temp_dir.path().join("test.graph"),
    )
    .unwrap();
    let backend = Arc::new(backend);

    // Get initial snapshot before any writes
    let initial_snapshot = SnapshotId::current();

    // Insert a node
    let node_id = backend.insert_node(test_node("node1", "test")).unwrap();

    // Get current snapshot after insert
    let after_insert_snapshot = SnapshotId::current();

    // Read with initial snapshot - should NOT see the new node
    let result = backend.get_node(initial_snapshot, node_id);
    println!("Initial snapshot read result: {:?}", result);

    // Read with current snapshot - should see the new node
    let result_current = backend.get_node(after_insert_snapshot, node_id);
    println!("Current snapshot read result: {:?}", result_current);
    assert!(
        result_current.is_ok(),
        "Current snapshot should see committed data"
    );
}

/// Test 2: BFS should respect snapshot isolation
#[test]
fn test_bfs_snapshot_isolation() {
    let temp_dir = tempfile::tempdir().unwrap();
    let backend = Arc::new(
        sqlitegraph::backend::native::NativeGraphBackend::create(
            temp_dir.path().join("test.graph"),
        )
        .unwrap(),
    );

    // Create a chain: A -> B -> C
    let node_a = backend.insert_node(test_node("A", "chain")).unwrap();
    let node_b = backend.insert_node(test_node("B", "chain")).unwrap();

    backend
        .insert_edge(EdgeSpec {
            from: node_a,
            to: node_b,
            edge_type: "links".to_string(),
            data: serde_json::json!({}),
        })
        .unwrap();

    let snapshot_before_c = SnapshotId::current();

    let node_c = backend.insert_node(test_node("C", "chain")).unwrap();
    backend
        .insert_edge(EdgeSpec {
            from: node_b,
            to: node_c,
            edge_type: "links".to_string(),
            data: serde_json::json!({}),
        })
        .unwrap();

    let result = backend.bfs(snapshot_before_c, node_a, 2);
    println!("BFS with old snapshot (depth 2 from A): {:?}", result);
}

/// Test 3: Shortest path should respect snapshot isolation
#[test]
fn test_shortest_path_snapshot_isolation() {
    let temp_dir = tempfile::tempdir().unwrap();
    let backend = Arc::new(
        sqlitegraph::backend::native::NativeGraphBackend::create(
            temp_dir.path().join("test.graph"),
        )
        .unwrap(),
    );

    let node_a = backend.insert_node(test_node("A", "path")).unwrap();
    let node_b = backend.insert_node(test_node("B", "path")).unwrap();

    backend
        .insert_edge(EdgeSpec {
            from: node_a,
            to: node_b,
            edge_type: "connects".to_string(),
            data: serde_json::json!({}),
        })
        .unwrap();

    let snapshot_before_c = SnapshotId::current();

    let node_c = backend.insert_node(test_node("C", "path")).unwrap();
    backend
        .insert_edge(EdgeSpec {
            from: node_b,
            to: node_c,
            edge_type: "connects".to_string(),
            data: serde_json::json!({}),
        })
        .unwrap();

    let result = backend.shortest_path(snapshot_before_c, node_a, node_c);
    println!("Shortest path with old snapshot (A to C): {:?}", result);
}