sql_query 0.0.0

composible sql query builder, with support of binding into query buffer
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

use futures_util::{future::BoxFuture, stream::BoxStream};
use sqlx::{
    database::HasStatement, Database, Describe, Either, Execute,
    Executor,
};

pub struct DebugSql<T, C>(pub T, pub C);

impl<T, C> std::fmt::Debug for DebugSql<T, C>
where
    T: std::fmt::Debug,
{
    fn fmt(
        &self,
        f: &mut std::fmt::Formatter<'_>,
    ) -> std::fmt::Result {
        f.debug_tuple("DebugStatement").field(&self.0).finish()
    }
}

impl<'c, T, C> Executor<'c> for DebugSql<T, C>
where
    T: Executor<'c>,
    C: FnOnce(String) + Send,
{
    type Database = T::Database;

    fn fetch_many<'e, 'q: 'e, E: 'q>(
        self,
        query: E,
    ) -> BoxStream<
        'e,
        Result<
            Either<
                <Self::Database as Database>::QueryResult,
                <Self::Database as Database>::Row,
            >,
            sqlx::Error,
        >,
    >
    where
        'c: 'e,
        E: Execute<'q, Self::Database>,
    {
        self.1(query.sql().to_owned());
        self.0.fetch_many(query)
    }

    fn fetch_optional<'e, 'q: 'e, E: 'q>(
        self,
        query: E,
    ) -> BoxFuture<
        'e,
        Result<
            Option<<Self::Database as Database>::Row>,
            sqlx::Error,
        >,
    >
    where
        'c: 'e,
        E: Execute<'q, Self::Database>,
    {
        self.1(query.sql().to_owned());
        self.0.fetch_optional(query)
    }
    fn execute<'e, 'q: 'e, E: 'q>(
        self,
        query: E,
    ) -> BoxFuture<
        'e,
        Result<
            <Self::Database as Database>::QueryResult,
            sqlx::Error,
        >,
    >
    where
        'c: 'e,
        E: Execute<'q, Self::Database>,
    {
        self.1(query.sql().to_owned());
        self.0.execute(query)
    }
    fn prepare_with<'e, 'q: 'e>(
        self,
        sql: &'q str,
        parameters: &'e [<Self::Database as Database>::TypeInfo],
    ) -> BoxFuture<
        'e,
        Result<
            <Self::Database as HasStatement<'q>>::Statement,
            sqlx::Error,
        >,
    >
    where
        'c: 'e,
    {
        self.0.prepare_with(sql, parameters)
    }

    fn describe<'e, 'q: 'e>(
        self,
        sql: &'q str,
    ) -> BoxFuture<
        'e,
        Result<Describe<Self::Database>, sqlx::Error>,
    >
    where
        'c: 'e,
    {
        self.0.describe(sql)
    }
}