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

//! Basic functionality test for SQLiteGraph library
use sqlitegraph::{GraphEdge, GraphEntity, SqliteGraph};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Testing SQLiteGraph basic functionality...");

    // Create in-memory graph
    let graph = SqliteGraph::open_in_memory()?;
    println!("✅ Graph created successfully");

    // Create entities with proper structure
    let user_entity = GraphEntity {
        id: 0, // Will be assigned by database
        kind: "User".to_string(),
        name: "Alice".to_string(),
        file_path: None,
        data: serde_json::json!({"age": 30}),
    };

    let project_entity = GraphEntity {
        id: 0,
        kind: "Project".to_string(),
        name: "SQLiteGraph".to_string(),
        file_path: None,
        data: serde_json::json!({"status": "active"}),
    };

    let company_entity = GraphEntity {
        id: 0,
        kind: "Company".to_string(),
        name: "TechCorp".to_string(),
        file_path: None,
        data: serde_json::json!({"founded": 2020}),
    };

    // Insert entities
    let node1 = graph.insert_entity(&user_entity)?;
    let node2 = graph.insert_entity(&project_entity)?;
    let node3 = graph.insert_entity(&company_entity)?;
    println!("✅ Entities inserted: {} {} {}", node1, node2, node3);

    // Create edges
    let works_on_edge = GraphEdge {
        id: 0,
        from_id: node1,
        to_id: node2,
        edge_type: "works_on".to_string(),
        data: serde_json::json!({"role": "developer"}),
    };

    let belongs_to_edge = GraphEdge {
        id: 0,
        from_id: node2,
        to_id: node3,
        edge_type: "belongs_to".to_string(),
        data: serde_json::json!({"ownership": 0.75}),
    };

    let employed_by_edge = GraphEdge {
        id: 0,
        from_id: node1,
        to_id: node3,
        edge_type: "employed_by".to_string(),
        data: serde_json::json!({"department": "engineering"}),
    };

    // Insert edges
    let edge1 = graph.insert_edge(&works_on_edge)?;
    let edge2 = graph.insert_edge(&belongs_to_edge)?;
    let edge3 = graph.insert_edge(&employed_by_edge)?;
    println!("✅ Edges inserted: {} {} {}", edge1, edge2, edge3);

    // Verify graph structure
    let entity1 = graph.get_entity(node1)?;
    let entity2 = graph.get_entity(node2)?;
    println!(
        "✅ Retrieved entities: {} ({}) -> {} ({})",
        entity1.name, entity1.kind, entity2.name, entity2.kind
    );

    // Test edge retrieval
    let edge_retrieved = graph.get_edge(edge1)?;
    println!(
        "✅ Retrieved edge: {} ({} -> {})",
        edge_retrieved.edge_type, edge_retrieved.from_id, edge_retrieved.to_id
    );

    println!("🎉 All basic operations work correctly!");
    println!("📊 Created graph with {} entities and {} edges", 3, 3);

    Ok(())
}