hydracache-sqlx 0.19.0

SQLx adapter helpers for HydraCache query result caching.
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

use async_trait::async_trait;
use hydracache_core::CacheCodec;
use hydracache_db::DbQuery;
use serde::{de::DeserializeOwned, Serialize};
use sqlx::{query::QueryAs, Database, Executor, FromRow, IntoArguments};

use crate::Result;

/// Convenience SQLx execution methods for [`DbQuery`].
///
/// These helpers keep SQLx responsible for query construction and row mapping,
/// while HydraCache owns keying, tags, TTL, serialization, and local
/// single-flight. Use [`DbQuery::fetch_with`] when you need a transaction,
/// custom repository call, or a database client that is not pool-like.
#[async_trait]
pub trait SqlxQueryExt<T, C>
where
    C: CacheCodec,
{
    /// Execute a SQLx query on miss and cache exactly one row.
    async fn fetch_one<'q, DB, A, E>(self, executor: E, query: QueryAs<'q, DB, T, A>) -> Result<T>
    where
        'q: 'static,
        T: Serialize + DeserializeOwned + Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'static,
        DB: Database + Send + Sync + 'static,
        A: IntoArguments<'q, DB> + Send + 'static,
        E: Send + Sync + 'static,
        for<'c> &'c E: Executor<'c, Database = DB>;

    /// Execute a SQLx query on miss and cache either one row or `None`.
    async fn fetch_optional<'q, DB, A, E>(
        self,
        executor: E,
        query: QueryAs<'q, DB, T, A>,
    ) -> Result<Option<T>>
    where
        'q: 'static,
        T: Serialize + DeserializeOwned + Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'static,
        DB: Database + Send + Sync + 'static,
        A: IntoArguments<'q, DB> + Send + 'static,
        E: Send + Sync + 'static,
        for<'c> &'c E: Executor<'c, Database = DB>;

    /// Execute a SQLx query on miss and cache all returned rows.
    async fn fetch_all<'q, DB, A, E>(
        self,
        executor: E,
        query: QueryAs<'q, DB, T, A>,
    ) -> Result<Vec<T>>
    where
        'q: 'static,
        T: Serialize + DeserializeOwned + Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'static,
        DB: Database + Send + Sync + 'static,
        A: IntoArguments<'q, DB> + Send + 'static,
        E: Send + Sync + 'static,
        for<'c> &'c E: Executor<'c, Database = DB>;
}

#[async_trait]
impl<T, C> SqlxQueryExt<T, C> for DbQuery<T, C>
where
    C: CacheCodec,
{
    async fn fetch_one<'q, DB, A, E>(self, executor: E, query: QueryAs<'q, DB, T, A>) -> Result<T>
    where
        'q: 'static,
        T: Serialize + DeserializeOwned + Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'static,
        DB: Database + Send + Sync + 'static,
        A: IntoArguments<'q, DB> + Send + 'static,
        E: Send + Sync + 'static,
        for<'c> &'c E: Executor<'c, Database = DB>,
    {
        self.fetch_value_with(move || async move { query.fetch_one(&executor).await })
            .await
            .map_err(Into::into)
    }

    async fn fetch_optional<'q, DB, A, E>(
        self,
        executor: E,
        query: QueryAs<'q, DB, T, A>,
    ) -> Result<Option<T>>
    where
        'q: 'static,
        T: Serialize + DeserializeOwned + Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'static,
        DB: Database + Send + Sync + 'static,
        A: IntoArguments<'q, DB> + Send + 'static,
        E: Send + Sync + 'static,
        for<'c> &'c E: Executor<'c, Database = DB>,
    {
        self.fetch_value_with(move || async move { query.fetch_optional(&executor).await })
            .await
            .map_err(Into::into)
    }

    async fn fetch_all<'q, DB, A, E>(
        self,
        executor: E,
        query: QueryAs<'q, DB, T, A>,
    ) -> Result<Vec<T>>
    where
        'q: 'static,
        T: Serialize + DeserializeOwned + Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'static,
        DB: Database + Send + Sync + 'static,
        A: IntoArguments<'q, DB> + Send + 'static,
        E: Send + Sync + 'static,
        for<'c> &'c E: Executor<'c, Database = DB>,
    {
        self.fetch_value_with(move || async move { query.fetch_all(&executor).await })
            .await
            .map_err(Into::into)
    }
}