slatedb 0.10.0

A cloud native embedded storage engine built on object 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

use crate::db_state::SsTableId;
use object_store::ObjectStore;
use std::sync::Arc;

/// Resolves object stores for different [object store types](ObjectStoreType).
pub(crate) struct ObjectStores {
    /// The main object store used for everything that doesn't have a more
    /// specific object store configured.
    main_object_store: Arc<dyn ObjectStore>,
    /// Optional WAL object store dedicated specifically for WAL.
    wal_object_store: Option<Arc<dyn ObjectStore>>,
}

pub(crate) enum ObjectStoreType {
    Main,
    Wal,
}

impl ObjectStores {
    pub(crate) fn new(
        main_object_store: Arc<dyn ObjectStore>,
        wal_object_store: Option<Arc<dyn ObjectStore>>,
    ) -> Self {
        Self {
            main_object_store,
            wal_object_store,
        }
    }

    pub(crate) fn store_of(&self, store_type: ObjectStoreType) -> &Arc<dyn ObjectStore> {
        match store_type {
            ObjectStoreType::Main => &self.main_object_store,
            ObjectStoreType::Wal => {
                if let Some(wal_object_store) = &self.wal_object_store {
                    wal_object_store
                } else {
                    &self.main_object_store
                }
            }
        }
    }

    pub(crate) fn store_for(&self, id: &SsTableId) -> Arc<dyn ObjectStore> {
        match id {
            SsTableId::Wal(..) => self.store_of(ObjectStoreType::Wal).clone(),
            SsTableId::Compacted(..) => self.store_of(ObjectStoreType::Main).clone(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use object_store::memory::InMemory;

    #[test]
    fn test_main_object_store_only_setup() {
        let main_store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
        let stores = ObjectStores::new(main_store.clone(), None);

        assert!(Arc::ptr_eq(
            stores.store_of(ObjectStoreType::Main),
            &main_store
        ));
        assert!(Arc::ptr_eq(
            stores.store_of(ObjectStoreType::Wal),
            &main_store
        ));

        assert!(Arc::ptr_eq(
            &stores.store_for(&SsTableId::Wal(0)),
            &main_store
        ));
        assert!(Arc::ptr_eq(
            &stores.store_for(&SsTableId::Compacted(ulid::Ulid::new())),
            &main_store
        ));
    }

    #[test]
    fn test_main_and_wal_object_stores_setup() {
        let main_store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
        let wal_store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
        let stores = ObjectStores::new(main_store.clone(), Some(wal_store.clone()));

        assert!(Arc::ptr_eq(
            stores.store_of(ObjectStoreType::Main),
            &main_store
        ));
        assert!(Arc::ptr_eq(
            stores.store_of(ObjectStoreType::Wal),
            &wal_store
        ));

        assert!(Arc::ptr_eq(
            &stores.store_for(&SsTableId::Wal(0)),
            &wal_store
        ));
        assert!(Arc::ptr_eq(
            &stores.store_for(&SsTableId::Compacted(ulid::Ulid::new())),
            &main_store
        ));
    }
}