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
132

//! Reproduction test for 10K-node database creation bug
//!
//! Bug: When creating a 10K-node database without WAL and calling flush_to_disk(),
//! the database cannot be reopened because pages aren't properly synced.
//!
//! Run with: cargo test --features native-v3 test_10k_bug_reproduction -- --nocapture

use sqlitegraph::{
    backend::native::v3::V3Backend,
    backend::{GraphBackend, NodeSpec},
};
use tempfile::TempDir;

#[test]
fn test_10k_nodes_without_wal() {
    println!("\n=== Testing 10K node creation without WAL ===\n");

    let temp = TempDir::new().unwrap();
    let db_path = temp.path().join("test_10k_no_wal.graph");

    // Create database with 10K nodes
    {
        println!("Creating database with 10K nodes...");
        let backend = V3Backend::create(&db_path).unwrap();
        for i in 0..10000 {
            if i % 1000 == 0 {
                println!("  Inserted {} nodes...", i);
            }
            backend
                .insert_node(NodeSpec {
                    kind: "Test".to_string(),
                    name: format!("node_{}", i),
                    file_path: None,
                    data: serde_json::json!({"i": i}),
                })
                .unwrap();
        }
        println!("  All 10K nodes inserted.");
        println!("  Calling flush_to_disk()...");
        backend.flush_to_disk().unwrap();
        println!("  Flush completed.");
        println!("  Backend dropping...");
    }

    // Try to reopen
    println!("\nAttempting to reopen database...");
    match V3Backend::open(&db_path) {
        Ok(_) => println!("SUCCESS: Database reopened successfully!"),
        Err(e) => {
            println!("FAILED: Could not reopen database: {:?}", e);
            panic!("10K-node bug reproduced: {:?}", e);
        }
    }
}

#[test]
fn test_1k_nodes_without_wal() {
    println!("\n=== Testing 1K node creation without WAL (baseline) ===\n");

    let temp = TempDir::new().unwrap();
    let db_path = temp.path().join("test_1k_no_wal.graph");

    // Create database with 1K nodes
    {
        println!("Creating database with 1K nodes...");
        let backend = V3Backend::create(&db_path).unwrap();
        for i in 0..1000 {
            backend
                .insert_node(NodeSpec {
                    kind: "Test".to_string(),
                    name: format!("node_{}", i),
                    file_path: None,
                    data: serde_json::json!({"i": i}),
                })
                .unwrap();
        }
        println!("  All 1K nodes inserted.");
        println!("  Calling flush_to_disk()...");
        backend.flush_to_disk().unwrap();
        println!("  Flush completed.");
        println!("  Backend dropping...");
    }

    // Try to reopen
    println!("\nAttempting to reopen database...");
    match V3Backend::open(&db_path) {
        Ok(_) => println!("SUCCESS: Database reopened successfully!"),
        Err(e) => {
            println!("FAILED: Could not reopen database: {:?}", e);
            panic!("1K-node bug: {:?}", e);
        }
    }
}

#[test]
fn test_10k_nodes_drop_only() {
    println!("\n=== Testing 10K nodes with Drop only (no explicit flush) ===\n");

    let temp = TempDir::new().unwrap();
    let db_path = temp.path().join("test_10k_drop.graph");

    // Create database with 10K nodes, rely on Drop
    {
        println!("Creating database with 10K nodes...");
        let backend = V3Backend::create(&db_path).unwrap();
        for i in 0..10000 {
            if i % 1000 == 0 {
                println!("  Inserted {} nodes...", i);
            }
            backend
                .insert_node(NodeSpec {
                    kind: "Test".to_string(),
                    name: format!("node_{}", i),
                    file_path: None,
                    data: serde_json::json!({"i": i}),
                })
                .unwrap();
        }
        println!("  All 10K nodes inserted.");
        println!("  Relying on Drop trait to flush...");
    }

    // Try to reopen
    println!("\nAttempting to reopen database...");
    match V3Backend::open(&db_path) {
        Ok(_) => println!("SUCCESS: Database reopened successfully!"),
        Err(e) => {
            println!("FAILED: Could not reopen database: {:?}", e);
            panic!("10K-node Drop bug: {:?}", e);
        }
    }
}