easy-sql 0.101.1

Macro-first SQL toolkit with compile-time checked queries, optional migrations on top of sqlx.
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

use anyhow::Context;
use easy_macros::always_context;

use crate::traits::{Driver, DriverArguments};

#[always_context]
/// Insert payload mapping for a table.
///
/// Prefer implementing this trait via the [`Insert`](macro@crate::Insert) derive macro; manual
/// implementations may need updates across releases.
pub trait Insert<'a, Table, D: Driver> {
    fn insert_columns() -> Vec<String>;

    /// Returns (new arguments list, number of inserted rows)
    fn insert_values(
        self,
        args_list: DriverArguments<'a, D>,
    ) -> anyhow::Result<(DriverArguments<'a, D>, usize)>;
}

#[always_context]
impl<'a, Table, T: Insert<'a, Table, D>, D: Driver> Insert<'a, Table, D> for Vec<T> {
    fn insert_columns() -> Vec<String> {
        T::insert_columns()
    }

    fn insert_values(
        self,
        args_list: DriverArguments<'a, D>,
    ) -> anyhow::Result<(DriverArguments<'a, D>, usize)> {
        let mut args = args_list;
        let mut item_count = 0;
        for item in self.into_iter() {
            let (new_args, new_count) = item.insert_values(
                #[context(no)]
                args,
            )?;
            args = new_args;
            item_count += new_count;
        }
        Ok((args, item_count))
    }
}

#[always_context]
impl<'a, Table, T: Insert<'a, Table, D>, D: Driver> Insert<'a, Table, D> for &'a Vec<T>
where
    &'a T: Insert<'a, Table, D>,
{
    fn insert_columns() -> Vec<String> {
        T::insert_columns()
    }

    fn insert_values(
        self,
        args_list: DriverArguments<'a, D>,
    ) -> anyhow::Result<(DriverArguments<'a, D>, usize)> {
        let mut args = args_list;
        let mut item_count = 0;
        for item in self.iter() {
            let (new_args, new_count) = item.insert_values(
                #[context(no)]
                args,
            )?;
            args = new_args;
            item_count += new_count;
        }
        Ok((args, item_count))
    }
}

#[always_context]
impl<'a, Table, T: Insert<'a, Table, D>, D: Driver> Insert<'a, Table, D> for &'a [T]
where
    &'a T: Insert<'a, Table, D>,
{
    fn insert_columns() -> Vec<String> {
        T::insert_columns()
    }

    fn insert_values(
        self,
        args_list: DriverArguments<'a, D>,
    ) -> anyhow::Result<(DriverArguments<'a, D>, usize)> {
        let mut args = args_list;
        let mut item_count = 0;
        for item in self.iter() {
            let (new_args, new_count) = item.insert_values(
                #[context(no)]
                args,
            )?;
            args = new_args;
            item_count += new_count;
        }
        Ok((args, item_count))
    }
}