simplify the execution with statement API

[jileventreur]

I was using deadpool-postgres in my project and i started to feel disturbed by the verbosity of each request using a prepared statement.

I tried to implement a trait to minimize the code bloat looking like this :

#[async_trait]
pub trait GenericClientCached {
    async fn query_cached(
        &self,
        query: &str,
        params: &[&(dyn ToSql + Sync)],
    ) -> Result<Vec<Row>, Error>;
... 
}

#[async_trait]
impl<T: GenericClient> GenericClientCached for T {
    async fn query_cached(
        &self,
        query: &str,
        params: &[&(dyn ToSql + Sync)],
    ) -> Result<Vec<Row>, Error> {
        let stmt = self.prepare_cached(query).await?;
        self.query(&stmt, params).await
    }
// ... (same logic for all other functions using a prepared statement)
}

Usage example:

client.execute_cached("UPDATE sessions SET valid = false WHERE id = $1",&[&0i64]).await.unwrap();

Instead of:

let stmt = client.prepared_cached("UPDATE sessions SET valid = false WHERE id = $1").await.unwrap();
client.execute(stmt, &[&0i64]).await.unwrap();

It's a small gain, but as it's a frequently repeated piece of code in a project's code base, I find it useful to minimize the code required for a query. Plus, it's easier to see which arguments match the SQL query.

What do you think? Is there any reason why it doesn't already exist?

[bikeshedder]

I wonder if adding various _cached variants of the functions is the way to go or if we should rather add a cached() method that returns a kind of proxy that provides those utility methods. e.g.

client.cached().execute("UPDATE sessions SET valid = false WHERE id = $1",&[&0i64]).await.unwrap();

That way we wouldn't pollute the Client namespace any further with deadpool specific code and could even deprecate the prepare_cached method in favor of cached().prepare.

Though the name cached is quite misleading as it is really just the statement that's being cached and not the entire query/result.

I'm not too happy about the execute_cached name either. It really suggests that the statement is being cached.

[bikeshedder]

I was thinking of maybe an entirely different approach. Maybe it really is time to add the CachedStatement struct as described in a comment here:

• Improve statement cache perf by using rustc-hash instead of the std hasher. #234 (comment)

---

Recap:

const SELECT_FOO: CachedStatement = CachedStatement::new("SELECT * FROM foo");

async fn do_stuff(client: &Client) {
    client.query(SELECT_FOO, &[]).await.unwrap();
    ...
}

By using the type CachedStatement it automatically knows that it is meant to be cached and you can declare your statements as static constants. This will not only remove the need to continuously hash the SQL but also provide you the API ergonomics you're looking for, doesn't it?

I just need to figure out how I can add this to the Client without breaking the existing functions. I really don't like the idea of wrapping the entirety of tokio-postgres just to add a nice statement cache.