sq3-rs 0.2.13

SQLite reader with no dependencies
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

mod page;

use std::{io::Read, num::NonZeroU32};

use page::ValidPage;

use crate::{
    file_header::{PageSize, SqliteHeader},
    io::SqliteIo,
    result::SqliteResult,
    traits::ParseBytes,
};

use self::page::Page;

#[derive(Debug)]
pub(crate) struct Pager {
    io: SqliteIo,
    file_header: SqliteHeader,
    current_page: Option<Vec<u8>>,
}

impl Pager {
    pub fn start<S: AsRef<str>>(conn_str: S) -> SqliteResult<Self> {
        let mut io = SqliteIo::connect(conn_str)?;
        let file_header = Self::get_file_header(&mut io)?;

        Ok(Self {
            current_page: None,
            io,
            file_header,
        })
    }
    pub fn get_page(&mut self, pos: NonZeroU32) -> SqliteResult<Vec<u8>> {
        self.io.rewind()?;
        let offset_position = (pos.get() - 1) * u32::from(self.file_header.page_size());
        self.io.seek(offset_position)?;
        let data = match self.file_header.page_size() {
            PageSize::L512 => {
                const PAGE_SIZE: usize = 512;
                let mut buf: [u8; PAGE_SIZE] = [0; PAGE_SIZE];
                let bytes_read = self.io.read(&mut buf)?;

                let page = Page::<PAGE_SIZE>::parse(pos.into(), buf);
                Self::get_data(page)
            }
            PageSize::L1024 => {
                const PAGE_SIZE: usize = 1024;
                let mut buf: [u8; PAGE_SIZE] = [0; PAGE_SIZE];
                let bytes_read = self.io.read(&mut buf)?;

                let page = Page::<PAGE_SIZE>::parse(pos.into(), buf);
                Self::get_data(page)
            }
            PageSize::L2048 => {
                const PAGE_SIZE: usize = 2048;
                let mut buf: [u8; PAGE_SIZE] = [0; PAGE_SIZE];
                let bytes_read = self.io.read(&mut buf)?;

                let page = Page::<PAGE_SIZE>::parse(pos.into(), buf);
                Self::get_data(page)
            }
            PageSize::L4096 => {
                const PAGE_SIZE: usize = 4096;
                let mut buf: [u8; PAGE_SIZE] = [0; PAGE_SIZE];
                let bytes_read = self.io.read(&mut buf)?;

                let page = Page::<PAGE_SIZE>::parse(pos.into(), buf);
                Self::get_data(page)
            }
            PageSize::L8192 => {
                const PAGE_SIZE: usize = 8192;
                let mut buf: [u8; PAGE_SIZE] = [0; PAGE_SIZE];
                let bytes_read = self.io.read(&mut buf)?;

                let page = Page::<PAGE_SIZE>::parse(pos.into(), buf);
                Self::get_data(page)
            }
            PageSize::L16384 => {
                const PAGE_SIZE: usize = 16384;
                let mut buf: [u8; PAGE_SIZE] = [0; PAGE_SIZE];
                let bytes_read = self.io.read(&mut buf)?;

                let page = Page::<PAGE_SIZE>::parse(pos.into(), buf);
                Self::get_data(page)
            }
            PageSize::L32768 => {
                const PAGE_SIZE: usize = 32768;
                let mut buf: [u8; PAGE_SIZE] = [0; PAGE_SIZE];
                let bytes_read = self.io.read(&mut buf)?;

                let page = Page::<PAGE_SIZE>::parse(pos.into(), buf);
                Self::get_data(page)
            }
            PageSize::L65536 => {
                const PAGE_SIZE: usize = 65536;
                let mut buf: [u8; PAGE_SIZE] = [0; PAGE_SIZE];
                let bytes_read = self.io.read(&mut buf)?;

                let page = Page::<PAGE_SIZE>::parse(pos.into(), buf);
                Self::get_data(page)
            }
        };
        Ok(data)
    }

    fn get_file_header(io: &mut impl Read) -> SqliteResult<SqliteHeader> {
        let mut buf = [0; SqliteHeader::LENGTH_BYTES];
        let bytes_read = io.read(&mut buf)?;

        Ok(SqliteHeader::parse_bytes(&buf)?)
    }

    fn get_data(page: impl ValidPage) -> Vec<u8> {
        page.data_owned()
    }
}