libmdbx 0.6.6

Idiomatic and safe MDBX wrapper.
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

use super::{cursor::*, traits::*};
use crate::{RO, RW, Stat, TransactionKind, WriteFlags, WriteMap};
use anyhow::Context;
use std::{collections::HashMap, marker::PhantomData};

#[derive(Debug)]
pub struct Transaction<'db, K>
where
    K: TransactionKind,
{
    pub(crate) inner: crate::Transaction<'db, K, WriteMap>,
}

impl Transaction<'_, RO> {
    pub fn table_sizes(&self) -> anyhow::Result<HashMap<String, u64>> {
        let mut out = HashMap::new();
        let main_table = self.inner.open_table(None)?;
        let mut cursor = self.inner.cursor(&main_table)?;
        while let Some((table, _)) = cursor.next_nodup::<Vec<u8>, ()>()? {
            let table = String::from_utf8(table)?;
            let db = self
                .inner
                .open_table(Some(&table))
                .with_context(|| format!("failed to open table: {table}"))?;
            let stats = self
                .inner
                .table_stat(&db)
                .with_context(|| format!("failed to get stats for table: {table}"))?;

            out.insert(table, stats.total_size());

            unsafe {
                self.inner.close_table(db)?;
            }
        }

        Ok(out)
    }
}

impl<'db, K> Transaction<'db, K>
where
    K: TransactionKind,
{
    pub fn table_stat<T>(&self) -> Result<Stat, crate::Error>
    where
        T: Table,
    {
        self.inner
            .table_stat(&self.inner.open_table(Some(T::NAME))?)
    }

    pub fn cursor<'tx, T>(&'tx self) -> anyhow::Result<Cursor<'tx, K, T>>
    where
        'db: 'tx,
        T: Table,
    {
        Ok(Cursor {
            inner: self.inner.cursor(&self.inner.open_table(Some(T::NAME))?)?,
            _marker: PhantomData,
        })
    }

    pub fn get<T>(&self, key: T::Key) -> anyhow::Result<Option<T::Value>>
    where
        T: Table,
    {
        Ok(self
            .inner
            .get::<DecodableWrapper<_>>(
                &self.inner.open_table(Some(T::NAME))?,
                key.encode().as_ref(),
            )?
            .map(|v| v.0))
    }
}

impl Transaction<'_, RW> {
    pub fn upsert<T>(&self, key: T::Key, value: T::Value) -> anyhow::Result<()>
    where
        T: Table,
    {
        Ok(self.inner.put(
            &self.inner.open_table(Some(T::NAME))?,
            key.encode(),
            value.encode(),
            WriteFlags::UPSERT,
        )?)
    }

    pub fn delete<T>(&self, key: T::Key, value: Option<T::Value>) -> anyhow::Result<bool>
    where
        T: Table,
    {
        let mut vref = None;
        let value = value.map(Encodable::encode);

        if let Some(v) = &value {
            vref = Some(v.as_ref());
        };
        Ok(self
            .inner
            .del(&self.inner.open_table(Some(T::NAME))?, key.encode(), vref)?)
    }

    pub fn clear_table<T>(&self) -> anyhow::Result<()>
    where
        T: Table,
    {
        self.inner
            .clear_table(&self.inner.open_table(Some(T::NAME))?)?;

        Ok(())
    }

    pub fn commit(self) -> anyhow::Result<()> {
        self.inner.commit()?;

        Ok(())
    }
}