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

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

pub struct NegateClause {
    inner: Box<dyn ClauseAdder>,
}

pub fn not(inner: Box<dyn ClauseAdder>) -> Box<dyn ClauseAdder> {
    Box::new(NegateClause { inner })
}

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

    fn clause(&self, syntax: Syntax, alias: &str, next_params: &NextParam) -> Option<String> {
        let inner_clause = self.inner.clause(syntax, alias, next_params)?;
        Some(format!("(NOT ({inner_clause}))"))
    }
}

#[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 should_be_able_to_write_a_not_clause() {
        let a = TestModelSchema::default();

        let not_clause = not(a.id.equal(1));
        let sql = not_clause.clause(Syntax::Postgres, "t1", &NextParam::new(Syntax::Postgres));
        assert!(sql.is_some());
        assert_eq!(sql.unwrap(), r#"(NOT (t1."id" = $1))"#);
    }
}