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

use crate::{operator::Operator, ChainBuilder, Method, Statement};

pub trait WhereClauses {
    fn where_clause(
        &mut self,
        column: &str,
        operator: Operator,
        value: serde_json::Value,
    ) -> &mut Self;
    fn where_eq(&mut self, column: &str, value: serde_json::Value) -> &mut Self;
    fn where_not_eq(&mut self, column: &str, value: serde_json::Value) -> &mut Self;
    fn where_in(&mut self, column: &str, value: Vec<serde_json::Value>) -> &mut Self;
    fn where_not_in(&mut self, column: &str, value: Vec<serde_json::Value>) -> &mut Self;
    fn where_null(&mut self, column: &str) -> &mut Self;
    fn where_not_null(&mut self, column: &str) -> &mut Self;
    fn where_exists(&mut self, column: &str) -> &mut Self;
    fn where_not_exists(&mut self, column: &str) -> &mut Self;
    fn where_between(&mut self, column: &str, value: [serde_json::Value; 2]) -> &mut Self;
    fn where_not_between(&mut self, column: &str, value: [serde_json::Value; 2]) -> &mut Self;
    fn where_like(&mut self, column: &str, value: serde_json::Value) -> &mut Self;
    fn where_not_like(&mut self, column: &str, value: serde_json::Value) -> &mut Self;
    fn where_subquery(
        &mut self,
        value: impl FnMut(&mut ChainBuilder) -> &mut ChainBuilder,
    ) -> &mut Self;
    fn or(&mut self) -> &mut Self;
    fn where_raw(&mut self, raw: (String, Option<Vec<serde_json::Value>>)) -> &mut Self;
}

impl WhereClauses for ChainBuilder {
    fn where_clause(
        &mut self,
        column: &str,
        operator: Operator,
        value: serde_json::Value,
    ) -> &mut Self {
        self.statement
            .push(Statement::Value(column.to_string(), operator, value));
        self
    }

    fn where_subquery(
        &mut self,
        mut value: impl FnMut(&mut ChainBuilder) -> &mut ChainBuilder,
    ) -> &mut Self {
        let mut chain = ChainBuilder::new(self.client.clone());
        value(&mut chain);
        self.statement.push(Statement::SubChain(Box::new(chain)));
        self
    }

    fn or(&mut self) -> &mut Self {
        self.statement
            .push(Statement::OrChain(Box::new(ChainBuilder {
                client: self.client.clone(),
                table: self.table.clone(),
                select: self.select.clone(),
                as_name: self.as_name.clone(),
                statement: vec![],
                raw: None,
                method: Method::None,
                db: self.db.clone(),
            })));
        self
    }

    fn where_raw(&mut self, raw: (String, Option<Vec<serde_json::Value>>)) -> &mut Self {
        self.statement.push(Statement::Raw(raw));
        self
    }

    fn where_eq(&mut self, column: &str, value: serde_json::Value) -> &mut Self {
        self.where_clause(column, Operator::Equal, value)
    }

    fn where_not_eq(&mut self, column: &str, value: serde_json::Value) -> &mut Self {
        self.where_clause(column, Operator::NotEqual, value)
    }

    fn where_in(&mut self, column: &str, value: Vec<serde_json::Value>) -> &mut Self {
        self.where_clause(column, Operator::In, serde_json::Value::Array(value))
    }

    fn where_not_in(&mut self, column: &str, value: Vec<serde_json::Value>) -> &mut Self {
        self.where_clause(column, Operator::NotIn, serde_json::Value::Array(value))
    }

    fn where_null(&mut self, column: &str) -> &mut Self {
        self.where_clause(column, Operator::IsNull, serde_json::Value::Null)
    }

    fn where_not_null(&mut self, column: &str) -> &mut Self {
        self.where_clause(column, Operator::IsNotNull, serde_json::Value::Null)
    }

    fn where_exists(&mut self, column: &str) -> &mut Self {
        self.where_clause(column, Operator::Exists, serde_json::Value::Null)
    }

    fn where_not_exists(&mut self, column: &str) -> &mut Self {
        self.where_clause(column, Operator::NotExists, serde_json::Value::Null)
    }

    fn where_between(&mut self, column: &str, value: [serde_json::Value; 2]) -> &mut Self {
        self.where_clause(
            column,
            Operator::Between,
            serde_json::Value::Array(vec![value[0].clone(), value[1].clone()]),
        )
    }

    fn where_not_between(&mut self, column: &str, value: [serde_json::Value; 2]) -> &mut Self {
        self.where_clause(
            column,
            Operator::NotBetween,
            serde_json::Value::Array(vec![value[0].clone(), value[1].clone()]),
        )
    }

    fn where_like(&mut self, column: &str, value: serde_json::Value) -> &mut Self {
        self.where_clause(column, Operator::Like, value)
    }

    fn where_not_like(&mut self, column: &str, value: serde_json::Value) -> &mut Self {
        self.where_clause(column, Operator::NotLike, value)
    }
}