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

use crate::collection::Transaction;
use std::collections::BTreeMap;
use std::collections::HashMap;

pub use versatile_data::{
    Data
    ,IdxSized
};
pub use idx_binary::IdxBinary;

mod collection;
pub use collection::Collection;

mod relation;
pub use relation::RelationIndexes;

pub struct Database{
    root_dir:String
    ,collections:HashMap<String,Collection>
    ,collections_id_map:BTreeMap<u32,String>
    ,relation:RelationIndexes
}
impl Database{
    pub fn new(dir:&str)->Database{
        let root_dir=if dir.ends_with("/") || dir.ends_with("\\"){
            let mut d=dir.to_string();
            d.pop();
            d
        }else{
            dir.to_string()
        };
        let db=if let (
            Ok(relation_key_names)
            ,Ok(relation_key)
            ,Ok(relation_parent)
            ,Ok(relation_child)
        )=(
            IdxBinary::new(&(root_dir.to_string()+"/relation_key_name"))
            ,IdxSized::new(&(root_dir.to_string()+"/relation_key.i"))
            ,IdxSized::new(&(root_dir.to_string()+"/relation_parent.i"))
            ,IdxSized::new(&(root_dir.to_string()+"/relation_child.i"))
        ){
            Some(Database{
                root_dir
                ,collections:HashMap::new()
                ,collections_id_map:BTreeMap::new()
                ,relation:RelationIndexes::new(
                    relation_key_names
                    ,relation_key
                    ,relation_parent
                    ,relation_child
                )
            })
        }else{
            None
        };
        db.expect("Fatal error: Can't Create/Open database")
    }

    pub fn create_collection(&mut self,name:&str){
        let mut max_id=0;
        let collections_dir=self.root_dir.to_string()+"/collection/";
        if let Ok(dir)=std::fs::read_dir(&collections_dir){
            for d in dir.into_iter(){
                if let Ok(d)=d{
                    if let Ok(dt)=d.file_type(){
                        if dt.is_dir(){
                            if let Some(fname)=d.path().file_name(){
                                if let Some(fname)=fname.to_str(){
                                    let s: Vec<&str>=fname.split("_").collect();
                                    if s.len()>1{
                                        if let Ok(i)=s[0].parse(){
                                            max_id=std::cmp::max(max_id,i);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        let collection_id=max_id+1;
        if let Some(data)=Data::new(&(collections_dir+"/"+&collection_id.to_string()+"_"+name)){
            self.collections_id_map.insert(collection_id,name.to_string());
            self.collections.insert(
                name.to_string()
                ,Collection::new(collection_id,data)
            );
        }
    }
    pub fn collection(&self,name:&str)->Option<&Collection>{
        self.collections.get(name)
    }
    pub fn collection_mut(&mut self,name:&str)->Option<&mut Collection>{
        if !self.collections.contains_key(name){
            self.create_collection(name);
        }
        self.collections.get_mut(name)
    }
    pub fn transaction(&mut self,collection_name:&str)->Option<Transaction>{
        if let Some(collection)=self.collection_mut(collection_name){
            Some(Transaction::new(collection.id(),self))
        }else{
            None
        }
    }
    pub fn collection_by_id(&self,id:u32)->Option<&Collection>{
        if let Some(name)=self.collections_id_map.get(&id){
            self.collections.get(name)
        }else{
            None
        }
    }
    pub fn collection_by_id_mut(&mut self,id:u32)->Option<&mut Collection>{
        if let Some(name)=self.collections_id_map.get(&id){
            self.collections.get_mut(name)
        }else{
            None
        }
        
    }
}