debil 0.5.0

Lightweight ORM for Rust
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

use crate::{QueryBuilder, SqlMapper, SqlTable};
use async_trait::async_trait;

pub struct Params<ValueType>(pub Vec<(String, ValueType)>);

impl<V> Params<V> {
    pub fn new() -> Params<V> {
        Params(Vec::new())
    }
}

pub trait HasNotFound {
    fn not_found() -> Self;
}

#[async_trait]
pub trait SqlConn<V: 'static + Sync + Send> {
    type Error: HasNotFound;

    async fn sql_exec(&mut self, query: String, params: Params<V>) -> Result<u64, Self::Error>;

    async fn sql_query<T: SqlMapper<ValueType = V> + Sync + Send>(
        &mut self,
        query: String,
        params: Params<V>,
    ) -> Result<Vec<T>, Self::Error>;

    async fn sql_batch_exec(
        &mut self,
        query: String,
        params: Vec<Params<V>>,
    ) -> Result<(), Self::Error>;

    async fn create_table<T: SqlTable<ValueType = V> + Sync + Send>(
        &mut self,
    ) -> Result<(), Self::Error> {
        self.sql_exec(
            SqlTable::create_table_query(std::marker::PhantomData::<T>),
            Params::<V>(Vec::new()),
        )
        .await?;

        Ok(())
    }

    async fn create<T: SqlTable<ValueType = V> + Sync + Send>(
        &mut self,
        data: T,
    ) -> Result<u64, Self::Error> {
        let (query, ps) = data.insert_query_with_params();

        self.sql_exec(query, Params::<V>(ps)).await
    }

    async fn save<T: SqlTable<ValueType = V> + Sync + Send + Clone>(
        &mut self,
        data: T,
    ) -> Result<u64, Self::Error> {
        let (query, ps) = data.clone().update_query_with_params();
        let affected_rows = self.sql_exec(query, Params::<V>(ps)).await?;

        if affected_rows == 0 {
            self.create(data).await
        } else {
            Ok(affected_rows)
        }
    }

    async fn load2<T: SqlTable, U: SqlMapper<ValueType = V> + Sync + Send>(
        &mut self,
        builder: QueryBuilder<V>,
    ) -> Result<Vec<U>, Self::Error> {
        let schema = SqlTable::schema_of(std::marker::PhantomData::<T>);
        let table_name = SqlTable::table_name(std::marker::PhantomData::<T>);
        let (query, params) = builder
            .table(table_name.clone())
            .append_selects(
                schema
                    .iter()
                    .map(|(k, _, _)| format!("{}.{}", table_name, k))
                    .collect::<Vec<_>>(),
            )
            .build();
        self.sql_query::<U>(query, params).await
    }

    async fn load<T: SqlTable<ValueType = V> + Sync + Send>(
        &mut self,
        builder: QueryBuilder<V>,
    ) -> Result<Vec<T>, Self::Error> {
        self.load2::<T, T>(builder).await
    }

    async fn first<T: SqlTable<ValueType = V> + Sync + Send>(
        &mut self,
        builder: QueryBuilder<V>,
    ) -> Result<T, Self::Error> {
        let schema = SqlTable::schema_of(std::marker::PhantomData::<T>);
        let table_name = SqlTable::table_name(std::marker::PhantomData::<T>);
        let (query, params) = builder
            .table(table_name.clone())
            .append_selects(
                schema
                    .iter()
                    .map(|(k, _, _)| format!("{}.{}", table_name, k))
                    .collect::<Vec<_>>(),
            )
            .limit(1)
            .build();

        self.sql_query::<T>(query, params)
            .await
            .and_then(|mut vs| vs.pop().ok_or(HasNotFound::not_found()))
    }
}