esql 0.1.2

Useful and lightweight database extension library for your Rust project
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
114
115
116
117
118
119
120
121
122
123
124

use std::{fmt::Display, future::Future, ops::Deref};

use futures_util::{Stream, StreamExt};
use tokio_postgres::{
    row::RowIndex,
    types::{FromSqlOwned, ToSql},
    Client, Row, RowStream,
};

use crate::query::Query;

pub struct PostgresArg(Box<dyn ToSql>);

impl Deref for PostgresArg {
    type Target = dyn ToSql;

    fn deref(&self) -> &Self::Target {
        self.0.deref()
    }
}

impl<A: ToSql + 'static> From<A> for PostgresArg {
    fn from(value: A) -> Self {
        Self(Box::new(value))
    }
}

type Result<T> = std::result::Result<T, crate::Error>;

impl Query<PostgresArg> {
    pub async fn get<DB, T>(self, db: DB) -> Result<impl IntoIterator<Item = T>>
    where
        DB: Deref<Target = Client>,
        T: From<Row>,
    {
        Ok(self
            .get_raw(db)
            .await?
            .map(|r| Into::<T>::into(r.unwrap()))
            .collect::<Vec<_>>()
            .await)
    }

    pub async fn first<DB, T>(self, db: DB) -> Result<Option<T>>
    where
        DB: Deref<Target = Client>,
        T: From<Row>,
    {
        Ok(self.get(db).await?.into_iter().nth(0))
    }

    pub async fn pluck<DB, I, T>(self, db: DB, idx: I) -> Result<impl Stream<Item = T>>
    where
        DB: Deref<Target = Client>,
        I: RowIndex + Display + Clone,
        T: FromSqlOwned,
    {
        Ok(self
            .get_raw(db)
            .await?
            .map(move |r| r.unwrap().get::<I, T>(idx.clone())))
    }

    pub async fn all_values<DB, T>(self, db: DB) -> Result<impl Stream<Item = T>>
    where
        DB: Deref<Target = Client>,
        T: FromSqlOwned,
    {
        Ok(self.pluck(db, 0).await?)
    }

    pub async fn value<DB, T>(self, db: DB) -> Result<Option<T>>
    where
        DB: Deref<Target = Client>,
        T: FromSqlOwned,
    {
        let values = self.all_values(db).await?;
        futures_util::pin_mut!(values);

        Ok(values.into_future().await.0)
    }

    pub async fn execute<DB, T>(self, db: DB) -> Result<u64>
    where
        DB: Deref<Target = Client>,
    {
        let (query, args) = self.build()?;

        Ok(db
            .deref()
            .execute_raw(&query, args.iter().map(Deref::deref).collect::<Vec<_>>())
            .await?)
    }

    pub async fn get_raw<DB>(self, db: DB) -> Result<RowStream>
    where
        DB: Deref<Target = Client>,
    {
        let (query, args) = self.build()?;

        Ok(db
            .deref()
            .query_raw(&query, args.iter().map(Deref::deref).collect::<Vec<_>>())
            .await?)
    }
}

pub trait ClientExt: Deref<Target = Client> {
    fn get<T>(
        &self,
        query: Query<PostgresArg>,
    ) -> impl Future<Output = Result<impl IntoIterator<Item = T>>>
    where
        T: From<Row>,
    {
        query.get(self.deref())
    }

    fn get_raw(&self, query: Query<PostgresArg>) -> impl Future<Output = Result<RowStream>> {
        query.get_raw(self.deref())
    }
}

impl ClientExt for &Client {}