small-db 0.4.0

A small database writing in rust, inspired from mit 6.830
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 std::{
    mem,
    sync::{Arc, Once, RwLock, RwLockReadGuard, RwLockWriteGuard},
};

use super::HandyRwLock;
use crate::{
    btree::page_cache::PageCache,
    concurrent_status::ConcurrentStatus, tx_log::LogManager,
    types::Pod, Catalog,
};

/// We collect all global variables here.
///
/// These variable cannot be initialized as static variables, because
/// their initialization function all rely on non-const fn (e.g.
/// `HashMap::new()`).
///
/// In the same time, all these variables should not be wrapped in any
/// kind of smark pointers / locks (e.g. `Arc`, `RwLock`), because
/// they are used in concurrent environment, and it's hard, if not
/// impossible, to acquire a exclusive lock in any context.
pub struct Unique {
    buffer_pool: Pod<PageCache>,
    catalog: Pod<Catalog>,
    concurrent_status: ConcurrentStatus,
    log_file: Pod<LogManager>,
}

impl Unique {
    fn new() -> Self {
        Self {
            buffer_pool: Arc::new(RwLock::new(PageCache::new())),
            concurrent_status: ConcurrentStatus::new(),
            catalog: Arc::new(RwLock::new(Catalog::new())),
            log_file: Arc::new(RwLock::new(LogManager::new(
                "wal.log",
            ))),
        }
    }

    // pub fn buffer_pool() -> &'static BufferPool {
    //     &Self::global().buffer_pool
    // }

    pub fn mut_page_cache() -> RwLockWriteGuard<'static, PageCache> {
        Self::global().buffer_pool.wl()
    }

    pub fn buffer_pool_pod() -> Arc<RwLock<PageCache>> {
        Self::global().buffer_pool.clone()
    }

    // pub fn buffer_pool() -> &'static BufferPool {
    //     &Self::global().buffer_pool
    // }

    pub fn concurrent_status() -> &'static ConcurrentStatus {
        &Self::global().concurrent_status
    }

    pub fn catalog() -> RwLockReadGuard<'static, Catalog> {
        Self::global().catalog.rl()
    }

    pub fn mut_catalog() -> RwLockWriteGuard<'static, Catalog> {
        Self::global().catalog.wl()
    }

    pub fn log_file() -> RwLockReadGuard<'static, LogManager> {
        Self::global().log_file.rl()
    }

    pub fn mut_log_manager() -> RwLockWriteGuard<'static, LogManager>
    {
        Self::global().log_file.wl()
    }

    pub fn log_file_pod() -> Arc<RwLock<LogManager>> {
        Self::global().log_file.clone()
    }

    pub fn global() -> &'static Self {
        // Initialize it to a null value
        static mut SINGLETON: *mut Unique = 0 as *mut Unique;
        static ONCE: Once = Once::new();

        ONCE.call_once(|| {
            // Make it
            let singleton = Self::new();

            unsafe {
                // Put it in the heap so it can outlive this call
                SINGLETON = mem::transmute(Box::new(singleton));
            }
        });

        unsafe {
            // Now we give out a copy of the data that is safe to use
            // concurrently.
            SINGLETON.as_ref().unwrap()
        }
    }
}