zendb 0.1.1

A simple Rust-based postgres server that listens on a postgres server
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

use postgres::{types::ToSql, Client, Error};

use crate::{ Condtion, Delete, DeleteBuilder,
    TableNotPresent, TablePresent,
};

impl<'delete> DeleteBuilder<'delete, TableNotPresent> {
    pub fn new(conn: &'delete mut Client) -> Self {
        DeleteBuilder {
            connection: Some(conn),
            table: Vec::new(),
            condition: Vec::new(),
            tablestate: std::marker::PhantomData,
        }
    }
    pub fn table(mut self, table: &'delete str) -> DeleteBuilder<TablePresent> {
        self.table.push(table);
        DeleteBuilder {
            connection: self.connection,
            table: self.table,
            condition: self.condition,
            tablestate: std::marker::PhantomData,
        }
    }
}

impl<'delete> DeleteBuilder<'delete, TablePresent> {
    pub fn condition(
        mut self,
        condition: Option<Condtion<'delete>>,
    ) -> DeleteBuilder<'delete, TablePresent> {
        self.condition.push(condition);
        DeleteBuilder {
            connection: self.connection,
            table: self.table,
            condition: self.condition,
            tablestate: std::marker::PhantomData,
        }
    }
    // pub fn or(mut self) -> DeleteBuilder<'delete, Condition<'delete>> {
    //     self.or.push("OR");
    //     DeleteBuilder {
    //         connection: self.connection,
    //         table: self.table,
    //         condition: self.condition,
    //         and: self.and,
    //         or: self.or,
    //         tablestate: std::marker::PhantomData,
    //     }
    // }
    // pub fn and(mut self) -> DeleteBuilder<'delete, Condition<'delete>> {
    //     self.and.push("AND");
    //     DeleteBuilder {
    //         connection: self.connection,
    //         table: self.table,
    //         condition: self.condition,
    //         and: self.and,
    //         or: self.or,
    //         tablestate: std::marker::PhantomData,
    //     }
    // }
}

impl<'delete> DeleteBuilder<'delete, TablePresent> {
    pub fn confirm(mut self) -> Delete<'delete> {
        Delete {
            connection: self.connection.unwrap(),
            table: self.table,
            condition: self.condition,
        }
    }
}

impl<'delete> Delete<'delete> {
    pub fn build(self) -> Result<u64, Error> {
        let tables = &self.table;
        let conditions = self.condition;


        let mut table = String::new();
        let mut condition = String::new();
        let mut delete = String::new();
        let mut value: Vec<Box<(dyn ToSql + Sync)>> = Vec::new();

        for tables in tables {
            table.push_str(&tables);
        }

        for (index, conditions) in conditions.iter().enumerate() {
            match conditions {
                Some(conditions_) => {
                    let index = format!("${}", index + 1);
                    let conditions = format!("{} = {} AND ", conditions_.key, index);
                    condition.push_str(&conditions);
                    // println!("{}", condition);

                    let values = &conditions_.value;
                    value.push(Box::new(values));
                    // println!("{:?}", &value);
                    // println!("{}", delete);
                }
                None => {
                    let deletes = format!("DELETE FROM {};", table);
                    delete.push_str(&deletes);
                    // println!("{}", delete);
                }
            }
        }
        let condition = condition.trim_end_matches("AND ");
        let deletes = format!("DELETE FROM {} WHERE {};", table, condition);
        delete.push_str(&deletes);
        let values: Vec<&(dyn ToSql + Sync)> = value.iter().map(|b| b.as_ref()).collect();

        // println!("{:?}",values);
        // println!("{}", delete);
        let delete = self.connection.execute(&delete, &values);

        match delete {
            Ok(success) => Ok(success),
            Err(err) => Err(err),
        }
    }
}