reefdb 0.1.0

ReefDB is a minimalistic, in-memory and on-disk database management system written in Rust, implementing basic SQL query capabilities and full-text search.
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

use crate::{
    error::ReefDBError,
    indexes::fts::search::Search,
    result::ReefDBResult,
    sql::{data_value::DataValue, statements::Statement},
    storage::Storage,
    InMemoryReefDB, ReefDB,
};

#[derive(Clone)]
pub struct Transaction<S: Storage + Clone, FTS: Search + Clone> {
    reef_db: ReefDB<S, FTS>,
}

impl<S: Storage + Clone, FTS: Search + Clone> Transaction<S, FTS> {
    pub fn execute_statement(&mut self, stmt: Statement) -> Result<ReefDBResult, ReefDBError> {
        self.reef_db.execute_statement(stmt)
    }

    pub fn commit(&mut self, reef_db: &mut ReefDB<S, FTS>) {
        reef_db.tables = self.reef_db.tables.clone();
        reef_db.inverted_index = self.reef_db.inverted_index.clone();
    }

    pub fn rollback(&mut self, reef_db: &mut ReefDB<S, FTS>) {
        self.reef_db.tables = reef_db.tables.clone();
        self.reef_db.inverted_index = reef_db.inverted_index.clone();
    }
}

// Add this method to the ReefDB struct
impl<S: Storage + Clone, FTS: Search + Clone> ReefDB<S, FTS> {
    pub fn begin_transaction(&self) -> Transaction<S, FTS> {
        Transaction {
            reef_db: self.clone(),
        }
    }
}

#[test]
fn test_transactions() {
    let mut db = InMemoryReefDB::new();

    // Create a table and insert a row outside of a transaction
    let (_, create_stmt) = Statement::parse("CREATE TABLE users (name TEXT, age INTEGER)").unwrap();
    db.execute_statement(create_stmt);
    let (_, insert_stmt) = Statement::parse("INSERT INTO users VALUES ('alice', 30)").unwrap();
    db.execute_statement(insert_stmt);

    // Start a transaction and insert two rows
    let mut transaction = db.begin_transaction();
    let (_, insert_stmt2) = Statement::parse("INSERT INTO users VALUES ('jane', 25)").unwrap();
    transaction.execute_statement(insert_stmt2).unwrap();
    let (_, insert_stmt3) = Statement::parse("INSERT INTO users VALUES ('john', 27)").unwrap();
    transaction.execute_statement(insert_stmt3).unwrap();

    let (_, select_stmt) = Statement::parse("SELECT name, age FROM users").unwrap();
    // Execute a SELECT statement before committing the transaction
    let select_result_before_commit = transaction.execute_statement(select_stmt).unwrap();

    // Check if the SELECT result contains changes from the transaction
    assert_eq!(
        select_result_before_commit,
        ReefDBResult::Select(vec![
            (
                0,
                vec![DataValue::Text("alice".to_string()), DataValue::Integer(30)]
            ),
            (
                1,
                vec![DataValue::Text("jane".to_string()), DataValue::Integer(25)]
            ),
            (
                2,
                vec![DataValue::Text("john".to_string()), DataValue::Integer(27)]
            ),
        ])
    );

    // Commit the transaction
    transaction.commit(&mut db);

    let (_, select_stmt2) = Statement::parse("SELECT name, age FROM users").unwrap();
    // Execute a SELECT statement after committing the transaction
    let select_result_after_commit = db.execute_statement(select_stmt2).unwrap();

    // Check if the SELECT result contains changes from the committed transaction
    assert_eq!(select_result_after_commit, select_result_before_commit);

    // Start a new transaction and insert a new row
    let mut transaction2 = db.begin_transaction();
    let (_, insert_stmt4) = Statement::parse("INSERT INTO users VALUES ('emma', 18)").unwrap();
    transaction2.execute_statement(insert_stmt4).unwrap();
    let (_, select_stmt3) = Statement::parse("SELECT name, age FROM users").unwrap();
    let select_result_before_rollback = transaction2.execute_statement(select_stmt3).unwrap();

    assert_eq!(
        select_result_before_rollback,
        ReefDBResult::Select(vec![
            (
                0,
                vec![DataValue::Text("alice".to_string()), DataValue::Integer(30)]
            ),
            (
                1,
                vec![DataValue::Text("jane".to_string()), DataValue::Integer(25)]
            ),
            (
                2,
                vec![DataValue::Text("john".to_string()), DataValue::Integer(27)]
            ),
            (
                3,
                vec![DataValue::Text("emma".to_string()), DataValue::Integer(18)]
            ),
        ])
    );

    // Rollback the transaction
    transaction2.rollback(&mut db);
    let (_, select_stmt4) = Statement::parse("SELECT name, age FROM users").unwrap();
    // Check if the rollback has discarded the changes made in the transaction
    let select_result_after_rollback = db.execute_statement(select_stmt4).unwrap();
    assert_eq!(select_result_after_rollback, select_result_after_commit);
}