kivis 0.2.4

Type-safe database schema generation for Rust with support for custom storage backends, automatic indexing, and layered cache architectures
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

use kivis::{manifest, Database, DeriveKey, Record};
use serde::{Deserialize, Serialize};

type Payload = u16;

#[derive(Debug, Serialize, Deserialize, Record)]
struct Autoincremented {
    p: Payload,
}

#[derive(Debug, Serialize, Deserialize, Record)]
struct Field {
    #[key]
    id: u64,
    p: Payload,
}

#[derive(Debug, Serialize, Deserialize, Record)]
struct Composite {
    #[key]
    directory: u32,
    #[key]
    unit: u32,
    p: Payload,
}

#[derive(Debug, Serialize, Deserialize, Record)]
#[derived_key(u32, u32)]
struct WithDerived {
    p: Payload,
}

impl DeriveKey for WithDerived {
    type Key = WithDerivedKey;

    fn key(c: &<Self::Key as kivis::RecordKey>::Record) -> Self::Key {
        WithDerivedKey(c.p as u32 + 100, 0)
    }
}

manifest![Manifest: Autoincremented, Field, Composite, WithDerived];

#[test]
fn test_key_types() {
    let mut database = Database::<kivis::MemoryStorage, Manifest>::default();

    // Autoincremented key
    let autoincremented = Autoincremented { p: 5 };
    let autoincremented_key = database.put(autoincremented).unwrap();
    assert_eq!(autoincremented_key, AutoincrementedKey(1));

    // Field key
    let field_key = Field { id: 1, p: 20 };
    let field_key = database.insert(field_key).unwrap();
    assert_eq!(field_key, FieldKey(1));

    // Composite key
    let composite_key = Composite {
        directory: 2,
        unit: 3,
        p: 30,
    };
    let composite_key = database.insert(composite_key).unwrap();
    assert_eq!(composite_key, CompositeKey(2, 3));

    // Derived key
    let with_derived = WithDerived { p: 50 };
    let with_derived_key = database.insert(with_derived).unwrap();
    assert_eq!(with_derived_key, WithDerivedKey(150, 0));
}