agrum 0.4.0

This is an OMM database layer.
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

use std::{any::Any, marker::PhantomData};

use agrum::{
    Projection, QueryBook, ReadQueryBook, SqlEntity, SqlQuery, Structure, Structured, Transaction,
    WhereCondition,
};
use futures_util::stream::StreamExt;
use uuid::Uuid;

mod pool;
use pool::get_pool;

pub struct CompanyShort {
    pub company_id: Uuid,
    pub name: String,
    pub contacts_nb: i64,
}

impl Structured for CompanyShort {
    fn get_structure() -> Structure {
        Structure::new(&[
            ("company_id", "uuid"),
            ("name", "text"),
            ("contacts_nb", "integer"),
        ])
    }
}

impl SqlEntity for CompanyShort {
    fn get_projection() -> Projection<CompanyShort> {
        Projection::<CompanyShort>::new("company")
            .set_definition("contacts_nb", "count(contact.company_id)")
    }

    fn hydrate(row: &tokio_postgres::Row) -> Result<Self, agrum::HydrationError> {
        Ok(Self {
            company_id: row.get("company_id"),
            name: row.get::<_, String>("name"),
            contacts_nb: row.get("contacts_nb"),
        })
    }
}

pub struct ContactQueryBook<T: SqlEntity> {
    _phantom: PhantomData<T>,
}

impl<T: SqlEntity> QueryBook<T> for ContactQueryBook<T> {
    fn get_sql_source(&self) -> &'static str {
        "pommr.contact"
    }
}

impl<T: SqlEntity> ReadQueryBook<T> for ContactQueryBook<T> {}

impl<T: SqlEntity> Default for ContactQueryBook<T> {
    fn default() -> Self {
        Self {
            _phantom: PhantomData,
        }
    }
}

struct CompanyWithContactsCountQueryBook<T: SqlEntity> {
    _phantom: PhantomData<T>,
}

impl<T: SqlEntity> QueryBook<T> for CompanyWithContactsCountQueryBook<T> {
    fn get_sql_source(&self) -> &'static str {
        "pommr.company"
    }
}

impl<T: SqlEntity> ReadQueryBook<T> for CompanyWithContactsCountQueryBook<T> {}

impl<T: SqlEntity> CompanyWithContactsCountQueryBook<T> {
    pub fn new() -> Self {
        Self {
            _phantom: PhantomData,
        }
    }

    fn get_sql_definition(&self) -> &'static str {
        r#"select {:projection:}
  from {:source:} as company
    left join {:contact_source:} as contact
      on company.company_id = contact.company_id
  where {:condition:}
  group by company.company_id"#
    }

    fn select<'a>(&self, conditions: WhereCondition<'a>) -> SqlQuery<'a, T> {
        let mut query = SqlQuery::new(self.get_sql_definition());
        let (conditions, parameters) = conditions.expand();
        query
            .set_parameters(parameters)
            .set_variable("projection", &T::get_projection().to_string())
            .set_variable("source", self.get_sql_source())
            .set_variable(
                "contact_source",
                ContactQueryBook::<T>::default().get_sql_source(),
            )
            .set_variable("condition", &conditions);
        query
    }

    pub fn select_by_id<'a>(&self, id: &'a Uuid) -> SqlQuery<'a, T> {
        self.select(WhereCondition::new("company.company_id = $?", vec![id]))
    }
}

#[tokio::test]
#[ignore = "skipping database tests"]
async fn test_select_by_id() {
    let pool = get_pool().await;
    let mut connection = pool.get().await.unwrap();
    let transaction = Transaction::start(connection.transaction().await.unwrap()).await;

    let company_id = Uuid::parse_str("a7b5f2c8-8816-4c40-86bf-64e066a8db7a").unwrap();
    let query = CompanyWithContactsCountQueryBook::<CompanyShort>::new().select_by_id(&company_id);
    assert!(query.get_parameters().len() == 1);
    assert_eq!(
        (query.get_parameters()[0] as &dyn Any)
            .downcast_ref::<Uuid>()
            .unwrap(),
        &company_id
    );
    assert_eq!(
        query.to_string(),
        r#"select company.company_id as company_id, company.name as name, count(contact.company_id) as contacts_nb
  from pommr.company as company
    left join pommr.contact as contact
      on company.company_id = contact.company_id
  where company.company_id = $1
  group by company.company_id"#
    );

    let company_short = transaction
        .query(query)
        .await
        .unwrap()
        .next()
        .await
        .unwrap()
        .unwrap();
    assert_eq!(company_short.company_id, company_id);
    assert_eq!(company_short.name, "first");
    assert_eq!(company_short.contacts_nb, 1);
    transaction.rollback().await.unwrap();
}