redbcli 0.2.0

RedbCLI is a command-line tool for managing and operating Redb databases. It provides various commands to create, delete, query, and edit 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
143
144
145
146
147
148
149
150
151

use redb::{Database, Error, ReadableDatabase, TableDefinition, TableHandle};
use std::collections::HashMap;
use std::path::Path;

#[derive(Debug, Default)]
pub struct CommonDbManager {
    pub tablename: String,
    pub dbpath: String,
}
// Deal with table
pub trait DealTable {
    fn create_table(&self, key: String) -> Result<(), Error>;
    fn delete_table(&self, key: String) -> Result<(), Error>;
    fn list_table(&self) -> Result<Vec<String>, Error>;
}

// Deal with data
pub trait DealData {
    fn get_by_key(&self, key: String) -> Result<String, Error>;
    fn insert_by_key(&self, key: String, data: String) -> Result<(), Error>;
    fn get_all(&self) -> Result<HashMap<String, String>, Error>;
    fn remove_by_key(&self, key: String) -> Result<(), Error>;
    fn update_by_key(&self, key: String, data: String) -> Result<(), Error>;
}

impl CommonDbManager {
    pub fn getdb(&self) -> Result<Database, Error> {
        let db_file = Path::new(&self.dbpath);
        if db_file.exists() {
            let db = Database::open(&self.dbpath)?;
            return Ok(db);
        }
        Err(redb::Error::Corrupted("Database not found".to_string()))
    }
    pub fn settablename(&mut self, name: String) -> Result<(), Error> {
        let db = self.getdb()?;
        self.tablename = name.clone();
        let tab_name = self.tablename.clone();
        let tabledefinition: TableDefinition<&str, &str> = TableDefinition::new(tab_name.as_str());
        let read_txn = db.begin_read()?;
        let _ = read_txn.open_table(tabledefinition)?;
        Ok(())
    }
    pub fn setdbpath(&mut self, path: String) -> Result<(), Error> {
        self.dbpath = path;
        self.getdb()?;
        Ok(())
    }
}
impl DealTable for CommonDbManager {
    fn create_table(&self, key: String) -> Result<(), Error> {
        let db = self.getdb()?;
        let tabledefinition: TableDefinition<&str, &str> = TableDefinition::new(key.as_str());
        let write_txn = db.begin_write()?;
        {
            write_txn.open_table(tabledefinition)?;
        }
        write_txn.commit()?;
        Ok(())
    }

    fn delete_table(&self, key: String) -> Result<(), Error> {
        let db = self.getdb()?;
        let write_txn = db.begin_write()?;
        {
            let tabledefinition: TableDefinition<&str, &str> = TableDefinition::new(key.as_str());
            match write_txn.delete_table(tabledefinition) {
                Ok(_) => Ok(()),
                Err(e) => Err(Error::Corrupted(e.to_string())),
            }
        }
    }

    fn list_table(&self) -> Result<Vec<String>, Error> {
        let db = self.getdb()?;
        let read_txn = db.begin_read()?;
        let result: Vec<String> = read_txn
            .list_tables()?
            .map(|table| table.name().to_string())
            .collect();

        Ok(result)
    }
}
impl DealData for CommonDbManager {
    fn get_by_key(&self, key: String) -> Result<String, Error> {
        let db: Database = self.getdb()?;
        let tabledefinition: TableDefinition<&str, &str> =
            TableDefinition::new(self.tablename.as_str());
        let read_txn = db.begin_read()?;
        let table = read_txn.open_table(tabledefinition)?;
        let binding = table.get(&key.as_str())?;
        if let Some(binding) = binding {
            let name_str = binding.value();
            Ok(name_str.to_string())
        } else {
            Err(Error::Corrupted("Key not found".to_string()))
        }
    }

    fn insert_by_key(&self, key: String, data: String) -> Result<(), Error> {
        let db = self.getdb()?;
        let tabledefinition: TableDefinition<&str, &str> =
            TableDefinition::new(self.tablename.as_str());
        let write_txn = db.begin_write()?;
        {
            let mut table = write_txn.open_table(tabledefinition)?;
            table.insert(&key.as_str(), &data.as_str())?;
        }
        write_txn.commit()?;
        Ok(())
    }

    fn get_all(&self) -> Result<HashMap<String, String>, Error> {
        let db = self.getdb()?;
        let tabledefinition: TableDefinition<&str, &str> =
            TableDefinition::new(self.tablename.as_str());
        let read_txn = db.begin_read()?;
        let table = read_txn.open_table(tabledefinition)?;
        let mut result = HashMap::new();
        let mut iter = table.range::<&str>(..)?;
        while let Some((k, v)) = iter.next().transpose()? {
            result.insert(k.value().to_string(), v.value().to_string());
        }
        Ok(result)
    }
    fn remove_by_key(&self, key: String) -> Result<(), Error> {
        let db = self.getdb()?;
        let tabledefinition: TableDefinition<&str, &str> =
            TableDefinition::new(self.tablename.as_str());
        let write_txn = db.begin_write()?;
        {
            let mut table = write_txn.open_table(tabledefinition)?;
            table.remove(&key.as_str())?;
        }
        write_txn.commit()?;
        Err(redb::Error::Corrupted("Database not found".to_string()))
    }
    fn update_by_key(&self, key: String, data: String) -> Result<(), Error> {
        let db = self.getdb()?;
        let tabledefinition: TableDefinition<&str, &str> =
            TableDefinition::new(self.tablename.as_str());
        let write_txn = db.begin_write()?;
        {
            let mut table = write_txn.open_table(tabledefinition)?;
            table.insert(&key.as_str(), &data.as_str())?;
        }
        write_txn.commit()?;
        Err(redb::Error::Corrupted("Database not found".to_string()))
    }
}