welds 0.5.0

An async ORM for (postgres, mssql, mysql, sqlite)
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
152
153
154
155
156
157
158
159

use crate::query::clause::{ClauseAdder, ParamArgs};
use crate::writers::NextParam;
use welds_connections::Syntax;

enum LogicalOp {
    And,
    Or,
}

pub struct LogicalClause {
    left_clause: Box<dyn ClauseAdder>,
    operator: LogicalOp,
    right_clause: Box<dyn ClauseAdder>,
}

impl LogicalOp {
    pub fn to_str(&self) -> &'static str {
        match self {
            LogicalOp::And => "AND",
            LogicalOp::Or => "OR",
        }
    }
}

pub fn or(
    left_clause: Box<dyn ClauseAdder>,
    right_clause: Box<dyn ClauseAdder>,
) -> Box<dyn ClauseAdder> {
    Box::new(LogicalClause {
        left_clause,
        operator: LogicalOp::Or,
        right_clause,
    })
}

pub fn and(
    left_clause: Box<dyn ClauseAdder>,
    right_clause: Box<dyn ClauseAdder>,
) -> Box<dyn ClauseAdder> {
    Box::new(LogicalClause {
        left_clause,
        operator: LogicalOp::And,
        right_clause,
    })
}

impl ClauseAdder for LogicalClause {
    fn bind<'lam, 'args, 'p>(&'lam self, args: &'args mut ParamArgs<'p>)
    where
        'lam: 'p,
    {
        self.left_clause.bind(args);
        self.right_clause.bind(args);
    }

    fn clause(&self, syntax: Syntax, alias: &str, next_params: &NextParam) -> Option<String> {
        let left = self.left_clause.clause(syntax, alias, next_params);
        let right = self.right_clause.clause(syntax, alias, next_params);
        let operator = self.operator.to_str();

        // Both have some
        if let Some(left) = &left
            && let Some(right) = &right
        {
            return Some(format!("({left} {operator} {right})"));
        }
        // Left has some
        if left.is_some() {
            return left;
        }
        // Right has some
        if right.is_some() {
            return right;
        }
        // Both are none
        None
    }
}

/// Extensions on ClauseAdder to add builder style (and/or) methods
pub trait ClauseAdderAndOrExt {
    fn and(self: Box<Self>, other: Box<dyn ClauseAdder>) -> Box<dyn ClauseAdder>;
    fn or(self: Box<Self>, other: Box<dyn ClauseAdder>) -> Box<dyn ClauseAdder>;
}

impl<CA> ClauseAdderAndOrExt for CA
where
    CA: ClauseAdder + 'static,
{
    fn and(self: Box<Self>, other: Box<dyn ClauseAdder>) -> Box<dyn ClauseAdder> {
        and(self, other)
    }
    fn or(self: Box<Self>, other: Box<dyn ClauseAdder>) -> Box<dyn ClauseAdder> {
        or(self, other)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::WeldsModel;
    use welds_connections::Syntax;

    #[derive(Debug, Default, WeldsModel)]
    #[welds(table = "test_table")]
    #[welds_path(crate)]
    struct TestModel {
        #[welds(primary_key)]
        pub id: i32,
        #[welds(rename = "name_column")]
        pub name: String,
        pub is_active: bool,
        pub score: f64,
    }

    #[test]
    fn test_and_logical_clause() {
        let a = TestModelSchema::default();

        let and_clause = and(a.id.equal(1), a.is_active.equal(true));

        let sql = and_clause.clause(Syntax::Postgres, "t1", &NextParam::new(Syntax::Postgres));
        assert!(sql.is_some());
        assert_eq!(sql.unwrap(), r#"(t1."id" = $1 AND t1."is_active" = $2)"#);
    }

    #[test]
    fn test_or_logical_clause() {
        let a = TestModelSchema::default();

        let or_clause = or(a.score.gt(0.5), a.name.equal("test".to_string()));

        let sql = or_clause.clause(Syntax::Postgres, "t1", &NextParam::new(Syntax::Postgres));
        assert!(sql.is_some());
        assert_eq!(
            sql.unwrap(),
            r#"(t1."score" > $1 OR t1."name_column" = $2)"#
        );
    }

    #[test]
    fn test_nested_logical_clauses() {
        let a = TestModelSchema::default();

        // (id = 1 AND is_active = true) OR score > 0.5
        let and_clause = and(a.id.equal(1), a.is_active.equal(true));
        let nested = or(and_clause, a.score.gte(0.5));

        let sql = nested.clause(Syntax::Postgres, "t1", &NextParam::new(Syntax::Postgres));
        assert!(sql.is_some());
        let sql_str = sql.unwrap();
        assert!(sql_str.contains("AND"));
        assert!(sql_str.contains("OR"));
        assert_eq!(
            sql_str,
            r#"((t1."id" = $1 AND t1."is_active" = $2) OR t1."score" >= $3)"#
        );
    }
}