sql-middleware 0.7.0

Lightweight async wrappers for tokio-postgres, rusqlite, turso, and tiberius.
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

macro_rules! impl_typed_backend {
    ($conn:ident, $idle:ty, $intx:ty) => {
        impl Queryable for $conn<$idle> {
            fn query<'a>(&'a mut self, sql: &'a str) -> QueryBuilder<'a, 'a> {
                self.query(sql)
            }
        }

        impl Queryable for $conn<$intx> {
            fn query<'a>(&'a mut self, sql: &'a str) -> QueryBuilder<'a, 'a> {
                self.query(sql)
            }
        }

        impl TypedConnOps for $conn<$idle> {
            #[allow(clippy::manual_async_fn)]
            fn execute_batch(
                &mut self,
                sql: &str,
            ) -> impl std::future::Future<Output = Result<(), SqlMiddlewareDbError>> {
                async move { self.execute_batch(sql).await }
            }

            #[allow(clippy::manual_async_fn)]
            fn dml(
                &mut self,
                query: &str,
                params: &[RowValues],
            ) -> impl std::future::Future<Output = Result<usize, SqlMiddlewareDbError>> {
                async move { self.dml(query, params).await }
            }

            #[allow(clippy::manual_async_fn)]
            fn select(
                &mut self,
                query: &str,
                params: &[RowValues],
            ) -> impl std::future::Future<Output = Result<ResultSet, SqlMiddlewareDbError>> {
                async move { self.select(query, params).await }
            }
        }

        impl TypedConnOps for $conn<$intx> {
            #[allow(clippy::manual_async_fn)]
            fn execute_batch(
                &mut self,
                sql: &str,
            ) -> impl std::future::Future<Output = Result<(), SqlMiddlewareDbError>> {
                async move { self.execute_batch(sql).await }
            }

            #[allow(clippy::manual_async_fn)]
            fn dml(
                &mut self,
                query: &str,
                params: &[RowValues],
            ) -> impl std::future::Future<Output = Result<usize, SqlMiddlewareDbError>> {
                async move { self.dml(query, params).await }
            }

            #[allow(clippy::manual_async_fn)]
            fn select(
                &mut self,
                query: &str,
                params: &[RowValues],
            ) -> impl std::future::Future<Output = Result<ResultSet, SqlMiddlewareDbError>> {
                async move { self.select(query, params).await }
            }
        }

        impl BeginTx for $conn<$idle> {
            type Tx = $conn<$intx>;

            #[allow(clippy::manual_async_fn)]
            fn begin(
                self,
            ) -> impl std::future::Future<Output = Result<Self::Tx, SqlMiddlewareDbError>> {
                async move { self.begin().await }
            }
        }

        impl TxConn for $conn<$intx> {
            type Idle = $conn<$idle>;

            #[allow(clippy::manual_async_fn)]
            fn commit(
                self,
            ) -> impl std::future::Future<Output = Result<Self::Idle, SqlMiddlewareDbError>> {
                async move { self.commit().await }
            }

            #[allow(clippy::manual_async_fn)]
            fn rollback(
                self,
            ) -> impl std::future::Future<Output = Result<Self::Idle, SqlMiddlewareDbError>> {
                async move { self.rollback().await }
            }
        }
    };
}

pub(crate) use impl_typed_backend;