uni-db 1.1.0

Embedded graph database with OpenCypher queries, vector search, and columnar storage
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
133
134

// SPDX-License-Identifier: Apache-2.0
// Copyright 2024-2026 Dragonscale Team

use anyhow::Result;
use uni_db::{DataType, UniSync};

#[test]
fn test_sync_api() -> Result<()> {
    // 1. Initialize
    let db = UniSync::in_memory()?;

    // 2. Schema (Sync)
    db.schema()
        .label("User")
        .property("name", DataType::String)
        .property("age", DataType::Int32)
        .apply()?;

    // 3. Execute via transaction
    let session = db.session();
    let tx = session.tx()?;
    tx.execute("CREATE (:User {name: 'Alice', age: 30})")?;
    tx.execute("CREATE (:User {name: 'Bob', age: 25})")?;
    tx.commit()?;

    // 4. Query
    let result = session.query("MATCH (u:User) RETURN u.name, u.age ORDER BY u.age")?;
    assert_eq!(result.len(), 2);

    let row0 = &result.rows()[0];
    assert_eq!(row0.get::<String>("u.name")?, "Bob");
    assert_eq!(row0.get::<i32>("u.age")?, 25);

    // 5. Transaction
    let tx = session.tx()?;
    tx.execute("CREATE (:User {name: 'Charlie', age: 40})")?;
    tx.commit()?;

    let result = session.query("MATCH (u:User) WHERE u.name = 'Charlie' RETURN u.age")?;
    assert_eq!(result.len(), 1);
    assert_eq!(result.rows()[0].get::<i32>("u.age")?, 40);

    Ok(())
}

#[test]
fn test_sync_api_rollback() -> Result<()> {
    let db = UniSync::in_memory()?;
    db.schema()
        .label("Item")
        .property("name", DataType::String)
        .apply()?;

    // Commit some baseline data
    let session = db.session();
    let tx = session.tx()?;
    tx.execute("CREATE (:Item {name: 'Baseline'})")?;
    tx.commit()?;

    // Start new transaction, add data, then drop without committing (rollback)
    {
        let tx = session.tx()?;
        tx.execute("CREATE (:Item {name: 'Uncommitted'})")?;
        // tx drops here without commit — implicit rollback
    }

    // Verify only baseline data exists
    let result = session.query("MATCH (i:Item) RETURN i.name AS name ORDER BY name")?;
    assert_eq!(result.len(), 1, "Rolled-back data should not be visible");
    assert_eq!(result.rows()[0].get::<String>("name")?, "Baseline");

    Ok(())
}

#[test]
fn test_sync_api_error_handling() -> Result<()> {
    let db = UniSync::in_memory()?;
    db.schema()
        .label("X")
        .property("v", DataType::Int32)
        .apply()?;

    let session = db.session();

    // Invalid Cypher syntax should return error, not panic
    let result = session.query("THIS IS NOT VALID CYPHER");
    assert!(
        result.is_err(),
        "Invalid Cypher should return error, not panic"
    );

    Ok(())
}

#[test]
fn test_sync_api_query_no_results() -> Result<()> {
    let db = UniSync::in_memory()?;
    db.schema()
        .label("Ghost")
        .property("name", DataType::String)
        .apply()?;

    // Query empty database
    let session = db.session();
    let result = session.query("MATCH (n:Ghost) RETURN n")?;
    assert_eq!(result.len(), 0, "Empty DB should return 0 rows, not error");

    Ok(())
}

#[test]
fn test_sync_api_edge_operations() -> Result<()> {
    let db = UniSync::in_memory()?;
    db.schema()
        .label("Person")
        .property("name", DataType::String)
        .done()
        .edge_type("KNOWS", &["Person"], &["Person"])
        .apply()?;

    let session = db.session();
    let tx = session.tx()?;
    tx.execute("CREATE (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'})")?;
    tx.commit()?;

    // Verify traversal
    let result = session
        .query("MATCH (a:Person)-[:KNOWS]->(b:Person) RETURN a.name AS src, b.name AS dst")?;
    assert_eq!(result.len(), 1);
    assert_eq!(result.rows()[0].get::<String>("src")?, "Alice");
    assert_eq!(result.rows()[0].get::<String>("dst")?, "Bob");

    Ok(())
}