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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::fmt;

use crate::{
    btree::page_cache::PageCache,
    io::{Condensable, SmallReader, SmallWriter, Vaporizable},
};

pub const EMPTY_PAGE_ID: u32 = 0;

#[derive(PartialEq, Copy, Clone, Eq, Hash, Debug)]
pub enum PageCategory {
    RootPointer,
    Internal,
    Leaf,
    Header,
}

impl Condensable for PageCategory {
    fn to_bytes(&self) -> Vec<u8> {
        match self {
            PageCategory::RootPointer => vec![0, 0, 0, 0],
            PageCategory::Internal => vec![0, 0, 0, 1],
            PageCategory::Leaf => vec![0, 0, 0, 2],
            PageCategory::Header => vec![0, 0, 0, 3],
        }
    }
}

impl Vaporizable for PageCategory {
    fn read_from(reader: &mut SmallReader) -> Self {
        let data = reader.read_exact(4);
        match data {
            [0, 0, 0, 0] => PageCategory::RootPointer,
            [0, 0, 0, 1] => PageCategory::Internal,
            [0, 0, 0, 2] => PageCategory::Leaf,
            [0, 0, 0, 3] => PageCategory::Header,
            _ => panic!("invalid page category: {:?}", data),
        }
    }
}

// PageID identifies a unique page, and contains the
// necessary metadata
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub struct BTreePageID {
    /// category indicates the category of the page
    pub category: PageCategory,

    /// page_index represents the position of the page in
    /// the table, start from 0
    pub page_index: u32,

    pub table_id: u32,
}

impl fmt::Display for BTreePageID {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "{:?}_{}(table_{})",
            self.category, self.page_index, self.table_id
        )
    }
}

impl fmt::Debug for BTreePageID {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self)
    }
}

impl BTreePageID {
    pub fn new(
        category: PageCategory,
        table_id: u32,
        page_index: u32,
    ) -> Self {
        Self {
            category,
            page_index,
            table_id,
        }
    }

    pub fn empty() -> Self {
        Self {
            category: PageCategory::RootPointer,
            page_index: 0,
            table_id: 0,
        }
    }

    pub fn get_table_id(&self) -> u32 {
        self.table_id
    }

    pub fn get_short_repr(&self) -> String {
        format!("{:?}_{}", self.category, self.page_index)
    }
}

impl Condensable for BTreePageID {
    fn to_bytes(&self) -> Vec<u8> {
        let mut writer = SmallWriter::new();
        writer.write(&self.category);
        writer.write(&self.page_index);
        writer.write(&self.table_id);
        return writer.to_bytes();
    }
}

impl Vaporizable for BTreePageID {
    fn read_from(reader: &mut SmallReader) -> Self {
        let category = reader.read();
        let page_index = reader.read();
        let table_id = reader.read();
        Self {
            category,
            page_index,
            table_id,
        }
    }
}

pub fn empty_page_data() -> Vec<u8> {
    let data: Vec<u8> = vec![0; PageCache::get_page_size()];
    data
}