mvcc-core 0.1.0

Multi-version concurrency control for ordinary Rust structs. Add #[derive(Mvcc)] and get snapshot-isolated transactions with pluggable isolation levels.
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

//! Names every item the crate root promises, so a merge that quietly drops one
//! fails to compile.
use mvcc::config::OracleConfig;
use mvcc::stats::GcStats;
use mvcc::{
    Config, Database, Error, IsolationLevel, Mvcc, ReadCommitted, Ref, RepeatableRead, Result,
    Serializable, Snapshot, Timestamp, Transaction, TxnId, Versioned,
};

#[derive(Mvcc, Clone, Debug)]
struct Row {
    #[mvcc(primary_key)]
    id: u64,
    #[mvcc(index)]
    tag: String,
}

#[test]
fn public_surface() -> Result<()> {
    fn _assert<T>() {}
    _assert::<Error>();
    _assert::<Timestamp>();
    _assert::<TxnId>();
    _assert::<GcStats>();
    _assert::<OracleConfig>();
    fn _levels<I: IsolationLevel>() {}
    _levels::<ReadCommitted>();
    _levels::<RepeatableRead>();
    _levels::<Snapshot>();
    _levels::<Serializable>();
    fn _versioned<T: Versioned>() {}
    _versioned::<Row>();

    let db = Database::open(Config::in_memory())?;
    db.register::<Row>()?;
    db.transaction(|tx: &mut Transaction<'_, Snapshot>| {
        tx.insert(Row {
            id: 1,
            tag: "a".into(),
        })
    })?;
    db.transaction_with::<Serializable, _, _>(|tx| {
        let rows: Vec<Ref<'_, Row>> = tx.scan_where::<Row, _>(|r| r.tag == "a")?;
        assert_eq!(rows.len(), 1);
        Ok(())
    })?;
    let _stats: GcStats = db.stats();
    Ok(())
}