geographdb-core 0.4.0

Geometric graph database core - 3D spatial indexing for code analysis
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

//! Storage Manager Tests - TDD Approach

use geographdb_core::storage::data_structures::NodeRec;
use geographdb_core::storage::manager::StorageManager;

#[test]
fn test_storage_manager_create() {
    let temp_dir = tempfile::tempdir().unwrap();
    let db_path = temp_dir.path().join("test.db");

    let result = StorageManager::create(&db_path);

    assert!(result.is_ok(), "Should create storage manager");
}

#[test]
fn test_storage_manager_insert_node() {
    let temp_dir = tempfile::tempdir().unwrap();
    let db_path = temp_dir.path().join("test.db");
    let mut storage = StorageManager::create(&db_path).unwrap();

    let node = NodeRec {
        id: 1,
        morton_code: 0,
        x: 10.0,
        y: 20.0,
        z: 30.0,
        edge_off: 0,
        edge_len: 0,
        flags: 0,
        begin_ts: 0,
        end_ts: 0,
        tx_id: 0,
        visibility: 1,
        _padding: [0; 7],
    };

    let result = storage.insert_node(node);

    assert!(result.is_ok(), "Should insert node");
}

#[test]
fn test_storage_manager_node_count() {
    let temp_dir = tempfile::tempdir().unwrap();
    let db_path = temp_dir.path().join("test.db");
    let mut storage = StorageManager::create(&db_path).unwrap();

    for i in 0..10 {
        let node = NodeRec {
            id: i,
            morton_code: i,
            x: i as f32,
            y: i as f32,
            z: i as f32,
            edge_off: 0,
            edge_len: 0,
            flags: 0,
            begin_ts: 0,
            end_ts: 0,
            tx_id: 0,
            visibility: 1,
            _padding: [0; 7],
        };
        storage.insert_node(node).unwrap();
    }

    assert_eq!(storage.node_count(), 10, "Should have 10 nodes");
}

#[test]
fn test_storage_manager_persistence() {
    let temp_dir = tempfile::tempdir().unwrap();
    let db_path = temp_dir.path().join("test.db");

    // Create and insert
    {
        let mut storage = StorageManager::create(&db_path).unwrap();
        let node = NodeRec {
            id: 99,
            morton_code: 12345,
            x: 1.0,
            y: 2.0,
            z: 3.0,
            edge_off: 0,
            edge_len: 0,
            flags: 0,
            begin_ts: 0,
            end_ts: 0,
            tx_id: 0,
            visibility: 1,
            _padding: [0; 7],
        };
        storage.insert_node(node).unwrap();
    } // Storage dropped, data flushed

    // Re-open and verify
    {
        let storage = StorageManager::open(&db_path).unwrap();
        let retrieved = storage.get_node(0);

        assert!(retrieved.is_some(), "Node should persist");
        let node = retrieved.unwrap();
        assert_eq!(node.id, 99, "ID should match");
        assert_eq!(node.morton_code, 12345, "Morton code should match");
        assert_eq!(node.x, 1.0, "X should match");
        assert_eq!(storage.node_count(), 1, "Node count should persist");
    }
}