cqlite 0.2.3

An embedded property graph database.
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

use crate::Error;
use sanakirja::{AllocPage, Commit, Env, LoadPage, MutTxn, RootDb, RootPage, Txn, MutPage};
use std::borrow::Borrow;

pub(crate) enum DynTxn<E: Borrow<Env>> {
    Txn(Txn<E>),
    MutTxn(MutTxn<E, ()>),
}

impl<E: Borrow<Env>> DynTxn<E> {
    pub fn set_root(&mut self, n: usize, value: u64) -> Result<(), Error> {
        match self {
            DynTxn::Txn(_) => Err(Error::ReadOnlyWrite),
            DynTxn::MutTxn(txn) => {
                txn.set_root(n, value);
                Ok(())
            }
        }
    }

    pub fn commit(self) -> Result<(), Error> {
        match self {
            DynTxn::Txn(_) => Err(Error::ReadOnlyWrite),
            DynTxn::MutTxn(txn) => Ok(txn.commit()?),
        }
    }

    pub fn is_mut(&self) -> bool {
        match self {
            DynTxn::Txn(_) => false,
            DynTxn::MutTxn(_) => true,
        }
    }
}

impl<E: Borrow<Env>> LoadPage for DynTxn<E> {
    type Error = Error;

    fn load_page(&self, off: u64) -> Result<sanakirja::CowPage, Self::Error> {
        match self {
            DynTxn::Txn(txn) => Ok(txn.load_page(off)?),
            DynTxn::MutTxn(txn) => Ok(txn.load_page(off)?),
        }
    }

    fn rc(&self, off: u64) -> Result<u64, Self::Error> {
        match self {
            DynTxn::Txn(txn) => Ok(txn.rc(off)?),
            DynTxn::MutTxn(txn) => Ok(txn.rc(off)?),
        }
    }
}

impl<E: Borrow<Env>> RootDb for DynTxn<E> {
    fn root_db<K, V, P>(&self, n: usize) -> Option<sanakirja::btree::Db_<K, V, P>>
    where
        K: sanakirja::Storable + ?Sized,
        V: sanakirja::Storable + ?Sized,
        P: sanakirja::btree::BTreePage<K, V>,
    {
        match self {
            DynTxn::Txn(txn) => txn.root_db(n),
            DynTxn::MutTxn(txn) => txn.root_db(n),
        }
    }
}

impl<E: Borrow<Env>> RootPage for DynTxn<E> {
    /// # Safety
    /// We are using the underlying implementation
    /// of the transactions, which are safe themselves.
    unsafe fn root_page(&self) -> &[u8; 4064] {
        match self {
            DynTxn::Txn(txn) => txn.root_page(),
            DynTxn::MutTxn(txn) => txn.root_page(),
        }
    }
}

impl<E: Borrow<Env>> AllocPage for DynTxn<E> {
    fn alloc_page(&mut self) -> Result<sanakirja::MutPage, Self::Error> {
        match self {
            DynTxn::Txn(_) => Err(Error::ReadOnlyWrite),
            DynTxn::MutTxn(txn) => Ok(txn.alloc_page()?),
        }
    }

    fn incr_rc(&mut self, off: u64) -> Result<usize, Self::Error> {
        match self {
            DynTxn::Txn(_) => Err(Error::ReadOnlyWrite),
            DynTxn::MutTxn(txn) => Ok(txn.incr_rc(off)?),
        }
    }

    fn decr_rc(&mut self, off: u64) -> Result<usize, Self::Error> {
        match self {
            DynTxn::Txn(_) => Err(Error::ReadOnlyWrite),
            DynTxn::MutTxn(txn) => Ok(txn.decr_rc(off)?),
        }
    }

    fn decr_rc_owned(&mut self, off: u64) -> Result<usize, Self::Error> {
        match self {
            DynTxn::Txn(_) => Err(Error::ReadOnlyWrite),
            DynTxn::MutTxn(txn) => Ok(txn.decr_rc_owned(off)?),
        }
    }

    fn alloc_contiguous(&mut self, off: u64) -> Result<MutPage, <Self as LoadPage>::Error> {
        match self {
            DynTxn::Txn(_) => Err(Error::ReadOnlyWrite),
            DynTxn::MutTxn(txn) => Ok(txn.alloc_contiguous(off)?),
        }
    }
}