qjack 0.1.3

ergonomic sqlx wrapper for nightly Rust
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

#![allow(non_camel_case_types)]
use sqlx::Executor;
use crate::{q, pool};
use super::{param::Param, transaction::X, QueryOutput};


impl<'q> FnOnce<(&'q str,)> for q {
    type Output = QueryOutput<'q>;
    #[inline(always)] extern "rust-call" fn call_once(self, (sql,): (&'q str,)) -> Self::Output {
        pool().execute(sql)
    }
}

impl<'q> FnOnce<(&'q str,)> for X {
    type Output = QueryOutput<'q>;
    #[inline(always)] extern "rust-call" fn call_once(mut self, (sql,): (&'q str,)) -> Self::Output {
        Box::pin(async move {self.0.execute(sql).await})
    }
}
impl<'q> FnMut<(&'q str,)> for X {
    #[inline(always)] extern "rust-call" fn call_mut(&mut self, (sql,): (&'q str,)) -> Self::Output {
        let output = self.0.execute(sql);
        unsafe {std::mem::transmute(output)}
    }
}

macro_rules! str_query_with_params {
    ($( $param:ident )+) => {
        impl<'q, $( $param:Param<'q> ),+> FnOnce<(&'q str, $( $param ),+)> for q {
            type Output = QueryOutput<'q>;
            #[inline(always)] extern "rust-call" fn call_once(
                self,
                (sql, $( $param ),+): (&'q str, $( $param ),+)
            ) -> Self::Output {
                pool().execute(sqlx::query(sql)
                    $( .bind($param) )+
                )
            }
        }

        impl<'q, $( $param:Param<'q> ),+> FnOnce<(&'q str, $( $param ),+)> for X {
            type Output = QueryOutput<'q>;
            #[inline(always)] extern "rust-call" fn call_once(
                mut self,
                (sql, $( $param ),+): (&'q str, $( $param ),+)
            ) -> Self::Output {
                Box::pin(async move {
                    self.0.execute(
                        sqlx::query(sql)
                            $( .bind($param) )+
                    ).await
                })
            }
        }
        impl<'q, $( $param:Param<'q> ),+> FnMut<(&'q str, $( $param ),+ )> for X {
            #[inline(always)] extern "rust-call" fn call_mut(
                &mut self,
                (sql, $( $param ),+): (&'q str, $( $param ),+)
            ) -> Self::Output {
                let output = self.0.execute(
                    sqlx::query(sql)
                        $( .bind($param) )+
                );
                unsafe {std::mem::transmute(output)}
            }
        }
    };
} const _: () = {
    str_query_with_params!(p1);
    str_query_with_params!(p1 p2);
    str_query_with_params!(p1 p2 p3);
    str_query_with_params!(p1 p2 p3 p4);
    str_query_with_params!(p1 p2 p3 p4 p5);
    str_query_with_params!(p1 p2 p3 p4 p5 p6);
    str_query_with_params!(p1 p2 p3 p4 p5 p6 p7);
};