tablestg 0.4.10

Storage for database tables
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::VarValAddr;
use crate::{Arc, BuckMap, BuckMapInfo, Data, DataType, Rc, make_obj_dt};

use page_store::*;

/// returned by [PageSet::load].
#[derive(Default)]
pub struct PData {
    pub data: Data,
    pub pnum: u64,
    pub changed: bool,
    /// Causes error if Pageset::note is not called.
    no_drop: bool,
}

impl PData {
    pub fn new(pnum: u64, data: Data, changed: bool) -> Self {
        Self {
            pnum,
            data,
            changed,
            no_drop: true,
        }
    }
    pub fn take_data(&mut self) -> Data {
        std::mem::take(&mut self.data)
    }
    pub fn make_mut(&mut self) -> &mut Vec<u8> {
        Arc::make_mut(&mut self.data)
    }
}

impl Drop for PData {
    fn drop(&mut self) {
        if self.no_drop {
            panic!();
        }
    }
}

/// Set of working pages, clean and changed.
pub struct PageSet {
    wapd: AccessPagedData,
    clean: HashMap<u64, Data>,
    changed: HashMap<u64, Data>,

    /// Variable length value storage data.
    pub vvs: (u64, u64),

    /// DataType of System Object
    pub obj_dt: Rc<DataType>,

    /// Next object id
    pub next_obj_id: i64,

    /// System Object Map
    pub obj_map: BuckMapInfo,

    /// Maps object names to object ids
    pub obj_by_name: BuckMapInfo,

    /// Maps table ids to datatypes
    pub table_datatype_map: BuckMapInfo,
}

impl PageSet {
    pub fn new(wapd: AccessPagedData) -> Self {
        // If not a new database, root1 and other values need to be restored somehow.
        let root1 = wapd.alloc_page() + 1;
        let mut ps = Self {
            wapd,
            clean: HashMap::default(),
            changed: HashMap::default(),
            vvs: (root1, 0),
            next_obj_id: 0,
            obj_map: BuckMapInfo::default(),
            obj_by_name: BuckMapInfo::default(),
            table_datatype_map: BuckMapInfo::default(),
            obj_dt: Rc::new(make_obj_dt()),
        };
        ps.obj_map = BuckMap::<VarValAddr>::new(1, &mut ps).save();
        ps.obj_by_name = BuckMap::<VarValAddr>::new(1, &mut ps).save();
        ps.table_datatype_map = BuckMap::<VarValAddr>::new(1, &mut ps).save();
        ps
    }

    pub fn compute_size(&self, size: usize) -> usize {
        let psi = &self.wapd.spd.psi;
        if size > psi.max_size_page() {
            return 0;
        }
        let ix = psi.index(size);
        psi.size(ix)
    }

    pub fn new_page(&self) -> u64 {
        self.wapd.alloc_page() + 1 // Add 1 so that zero can be used as null page.
    }

    pub fn free_page(&mut self, pnum: u64) {
        self.clean.remove(&pnum);
        self.changed.remove(&pnum);
        self.wapd.free_page(pnum - 1);
    }

    /// Loads page data, the PData must later be returned by calling note.
    pub fn load(&mut self, pnum: u64) -> PData {
        if pnum == 0 {
            PData::default()
        } else if let Some(data) = self.clean.remove(&pnum) {
            PData::new(pnum, data, false)
        } else if let Some(data) = self.changed.remove(&pnum) {
            PData::new(pnum, data, true)
        } else {
            let data = self.wapd.get_data(pnum - 1);
            PData::new(pnum, data, false)
        }
    }

    /// Returns page loaded page data.
    pub fn note(&mut self, mut pd: PData) {
        if pd.pnum == 0
        {
            // Do nothing
        }
        else if pd.changed {
            self.changed.insert(pd.pnum, pd.take_data());
        } else {
            self.clean.insert(pd.pnum, pd.take_data());
        }
        pd.no_drop = false;
    }

    /// Saave all the changed pages.
    pub fn save(&mut self) {
        for (pnum, data) in self.changed.drain() {
            println!("Saving data pnum={} len={}", pnum, data.len());
            self.wapd.set_data(pnum - 1, data);
        }
        self.wapd.save(SaveOp::Save);
    }
}