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

use versatile_data::{
    Activity
    ,KeyValue
    ,Update
};

use crate::CollectionRow;

pub struct TransactionRecord<'a>{
    collection_id:u32
    ,update:Update
    ,activity:Activity
    ,term_begin:i64
    ,term_end:i64
    ,fields:Vec<KeyValue<'a>>
    ,parents:Vec<(&'a str,CollectionRow)>
    ,childs:Vec<(&'a str,Vec<TransactionRecord<'a>>)>
}
impl<'a> TransactionRecord<'a>{
    pub fn new(
        collection_id:u32
        ,update:Update
        ,activity:Activity
        ,term_begin:i64
        ,term_end:i64
        ,fields:Vec<KeyValue<'a>>
        ,parents:Vec<(&'a str,CollectionRow)>
        ,childs:Vec<(&'a str,Vec<TransactionRecord<'a>>)>
    )->TransactionRecord<'a>{
        TransactionRecord{
            collection_id
            ,update
            ,activity
            ,term_begin
            ,term_end
            ,fields
            ,parents
            ,childs
        }
    }
}

pub struct Transaction<'a>{
    database:&'a mut super::Database
    ,records:Vec<TransactionRecord<'a>>
    ,deletes:Vec<CollectionRow>
}
impl<'a> Transaction<'a>{
    pub fn new(database:&'a mut super::Database)->Transaction{
        Transaction{
            database
            ,records:Vec::new()
            ,deletes:Vec::new()
        }
    }
    pub fn update(&mut self,records:&mut Vec::<TransactionRecord<'a>>){
        self.records.append(records);
    }
    pub fn delete(&mut self,collection_id:u32,row:u32){
        self.deletes.push(CollectionRow::new(collection_id,row));
    }
    pub fn commit(&mut self){
        Self::register_recursive(&mut self.database,&self.records,None);
        for i in &self.deletes{
            Self::delete_recursive(&mut self.database,&i);
        }
        self.records=Vec::new();
        self.deletes=Vec::new();
    }

    fn delete_recursive(database:&mut super::Database,target:&CollectionRow){
        let c=database.relation.index_parent().select_by_value(target);
        for relation_row in c{
            if let Some(child)=database.relation.index_child().value(relation_row){
                Self::delete_recursive(database,&child);
                if let Some(collection)=database.collection_mut(child.collection_id()){
                    collection.delete(child.row());
                }
            }
            database.relation.delete(relation_row);
        }
    }
    fn register_recursive(database:&mut super::Database,records:&Vec::<TransactionRecord>,incidentally_parent:Option<(&str,CollectionRow)>){
        for r in records.iter(){
            if let Some(data)=database.collection_mut(r.collection_id){
                let row=data.update(r.update,r.activity,r.term_begin,r.term_end,&r.fields);
                for (relation_key,parent) in &r.parents{
                    database.relation_mut().insert(
                        relation_key
                        ,*parent
                        ,CollectionRow::new(r.collection_id,row)
                    );
                }
                if let Some((relation_key,parent_collection_row))=incidentally_parent{
                    database.relation_mut().insert(
                        relation_key
                        ,parent_collection_row
                        ,CollectionRow::new(r.collection_id,row)
                    );
                }
                for (relation_key,childs) in &r.childs{
                    Self::register_recursive(
                        database
                        ,&childs
                        ,Some((
                            relation_key
                            ,CollectionRow::new(r.collection_id,row)
                        ))
                    );
                }
            }
        }
    }
}