sqlite-table 0.1.0

SQLite inpection and manipulation on 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

use sqlite_decoder::btree;
use std::collections::HashMap;
use std::ops::RangeInclusive;

pub type Schemas = HashMap<String, Schema>;

#[derive(Debug)]
pub enum Schema {
    Table(Table),
    Index(Index),
}

#[derive(Debug, Clone)]
pub struct Table {
    pub name: String,
    pub sql: String,
    pub root_page: u32,
}

#[derive(Debug)]
pub struct PageWithRowidRange {
    pub range: RangeInclusive<u64>,
    pub index: u32,
}

impl Table {
    pub fn list_pages(&self, db: &sqlite_types::Db) -> Vec<PageWithRowidRange> {
        let page = db.pages.get(&self.root_page).unwrap();
        let res = sqlite_decoder::btree::decode(&db.header.text_encoding, page).unwrap();

        let mut page_list = Vec::new();

        let mut prev_rowid = None;
        for cell in res.cells {
            match cell {
                sqlite_decoder::btree::Cell::TableBTreeInteriorCell(cell) => {
                    let start = prev_rowid.unwrap_or_default();
                    let end = cell.rowid;

                    page_list.push(PageWithRowidRange {
                        range: RangeInclusive::new(start, end),
                        index: cell.left_child_page,
                    });
                    // TODO: can an Interior btree point to another interior btree?

                    prev_rowid = Some(end);
                }
                _ => unimplemented!(),
            }
        }

        page_list
    }
}

#[derive(Debug)]
pub struct Index {
    pub name: String,
    pub sql: String,
    pub tbl_name: String,
    pub root_page: u32,
}

pub fn find_table_by_root(rootpage: usize, schemas: &Schemas) -> Option<Table> {
    let mut table = None;

    for (_, schema) in schemas {
        match schema {
            Schema::Table(schema) => {
                if schema.root_page as usize == rootpage {
                    table = Some(schema.clone());
                }
            }
            _ => {}
        }
    }

    table
}

/// Decodes SQLite schema table
/// The table is always located at page 1 (after the db3 header)
pub fn decode_sqlite_schema(db: &sqlite_types::Db) -> Schemas {
    let page = db.pages.get(&1).unwrap();

    let enc = &db.header.text_encoding;
    let btree = btree::decode_first_page(enc, page).unwrap();

    let mut schemas = HashMap::new();

    for cell in btree.cells {
        match cell {
            btree::Cell::TableBTreeLeafCell(leaf) => {
                let record_type = leaf.records[0].as_string();
                let name = leaf.records[1].as_string();
                let tbl_name = leaf.records[2].as_string();
                let root_page = leaf.records[3].as_int() as u32;
                let sql = leaf.records[4].as_string();

                let schema = if record_type == "table" {
                    Schema::Table(Table {
                        name: name.clone(),
                        root_page,
                        sql,
                    })
                } else {
                    Schema::Index(Index {
                        name: name.clone(),
                        root_page,
                        sql,
                        tbl_name,
                    })
                };

                schemas.insert(name, schema);
            }
            _ => unreachable!(),
        }
    }

    schemas
}