Alternative query API

[Virgiel]

I have an idea for another query API that brings back the default inference and supports a custom mapper with a bit more verbosity:

pub struct AuthorBorrowed<'a> {
    name: &'a str,
}

pub struct Author {
    name: String,
}

impl<'a> From<AuthorBorrowed<'a>> for Author {
    fn from(it: AuthorBorrowed<'a>) -> Self {
        Author {
            name: it.name.to_owned(),
        }
    }
}

pub fn authors<'a, 'b, C: GenericClient>(
    client: &'a C,
    city: &'a &str,
) -> AuthorQuery<'a, C, Author, 1> {
    AuthorQuery {
        client,
        query: "SELECT name WHERE city = $1 FROM Author;",
        params: [city],
        extractor: |row| AuthorBorrowed { name: row.get(0) },
        mapper: |it| Author::from(it),
    }
}

pub struct AuthorQuery<'a, C: GenericClient, T, const N: usize> {
    client: &'a C,
    query: &'static str,
    params: [&'a (dyn tokio_postgres::types::ToSql + Sync); N],
    extractor: fn(&Row) -> AuthorBorrowed,
    mapper: fn(AuthorBorrowed) -> T,
}

impl<'a, C: GenericClient, T, const N: usize> AuthorQuery<'a, C, T, N> {
    pub fn map<R>(self, mapper: fn(AuthorBorrowed) -> R) -> AuthorQuery<'a, C, R, N> {
        AuthorQuery {
            client: self.client,
            query: self.query,
            params: self.params,
            extractor: self.extractor,
            mapper,
        }
    }

    pub async fn stmt(&self) -> Result<Statement, Error> {
        self.client.prepare(self.query).await
    }

    pub async fn one(self) -> Result<T, Error> {
        let stmt = self.stmt().await?;
        let row = self.client.query_one(&stmt, &self.params).await?;
        Ok((self.mapper)((self.extractor)(&row)))
    }

    pub async fn list(self) -> Result<Vec<T>, Error> {
        self.raw().await?.try_collect().await
    }

    pub async fn opt(self) -> Result<Option<T>, Error> {
        let stmt = self.stmt().await?;
        Ok(self
            .client
            .query_opt(&stmt, &self.params)
            .await?
            .map(|r| (self.mapper)((self.extractor)(&r))))
    }

    pub async fn raw(self) -> Result<impl Stream<Item = Result<T, Error>>, Error> {
        let stmt = self.stmt().await?;
        let stream = self
            .client
            .query_raw(&stmt, slice_iter(&self.params))
            .await?
            .map(move |res| res.map(|r| (self.mapper)((self.extractor)(&r))));
        Ok(stream.into_stream())
    }
}

struct UserAuthor {
    name: String,
}

impl<'a> From<AuthorBorrowed<'a>> for UserAuthor {
    fn from(it: AuthorBorrowed<'a>) -> Self {
        UserAuthor {
            name: it.name.to_owned(),
        }
    }
}

pub async fn usage<T: GenericClient>(client: &T) -> Result<(), Error> {
    let infered = authors(client, &"Paris").one().await?;
    let author: Author = authors(client, &"Paris").one().await?;
    let user_author: UserAuthor = authors(client, &"Paris")
        .map(|it| UserAuthor::from(it))
        .one()
        .await?;
    let user_name: String = authors(client, &"Paris")
        .map(|it| it.name.to_string())
        .one()
        .await?;
    let user_name_length: usize = authors(client, &"Paris")
        .map(|it| it.name.trim().len())
        .one()
        .await?;
    Ok(())
}

Using a mapper is more verbose but is more flexible, it can be used with lambda, From or even TryFrom:

let author: Result<FaillingAuthor, String> = authors(client, &"Paris")
        .map(|it| FaillingAuthor::try_from(it))
        .one()
        .await?;

Unfortunately, I still can't reuse the same query structure, declaring the lifetime of the borrowed type in a generic way seems impossible :/

[Virgiel]

More specialised variant, less code but maybe harder codegen:

pub fn authors<'a, 'b, C: GenericClient>(
    client: &'a C,
    city: &'a &str,
) -> AuthorQuery<'a, C, Author, 1> {
    AuthorQuery {
        client,
        params: [city],
        mapper: |it| Author::from(it),
    }
}

pub struct AuthorQuery<'a, C: GenericClient, T, const N: usize> {
    client: &'a C,
    params: [&'a (dyn tokio_postgres::types::ToSql + Sync); N],
    mapper: fn(AuthorBorrowed) -> T,
}

impl<'a, C: GenericClient, T, const N: usize> AuthorQuery<'a, C, T, N> {
    pub fn map<R>(self, mapper: fn(AuthorBorrowed) -> R) -> AuthorQuery<'a, C, R, N> {
        AuthorQuery {
            client: self.client,
            params: self.params,
            mapper,
        }
    }

    pub fn extractor(row: &Row) -> AuthorBorrowed {
        AuthorBorrowed { name: row.get(0) }
    }

    pub async fn stmt(&self) -> Result<Statement, Error> {
        self.client
            .prepare("SELECT name WHERE city = $1 FROM Author;")
            .await
    }

    pub async fn one(self) -> Result<T, Error> {
        let stmt = self.stmt().await?;
        let row = self.client.query_one(&stmt, &self.params).await?;
        Ok((self.mapper)(Self::extractor(&row)))
    }

    pub async fn list(self) -> Result<Vec<T>, Error> {
        self.raw().await?.try_collect().await
    }

    pub async fn opt(self) -> Result<Option<T>, Error> {
        let stmt = self.stmt().await?;
        Ok(self
            .client
            .query_opt(&stmt, &self.params)
            .await?
            .map(|r| (self.mapper)(Self::extractor(&r))))
    }

    pub async fn raw(self) -> Result<impl Stream<Item = Result<T, Error>>, Error> {
        let stmt = self.stmt().await?;
        let stream = self
            .client
            .query_raw(&stmt, slice_iter(&self.params))
            .await?
            .map(move |res| res.map(|r| (self.mapper)(Self::extractor(&r))));
        Ok(stream.into_stream())
    }
}

[LouisGariepy]

I like this approach. I'll target this for codegen now.

[LouisGariepy]

@Virgiel I merged this proposal in #52. We can discuss it further there if needed 👍 .