Don't consume ConnectionLike when executing queries

[nicoburns]

I want to do something like the following:

async fn execute_queries(sql: String, rx: Receiver<Params>) {
    let conn = Conn::new(opts).await.unwrap();
    let stmt = conn.prepare(sql).await.unwrap();

    // Next query loop
    while let Some(params) = rx.recv().await {
        // Query retry loop
        loop {
            match stmt.execute(all_params).await {
                // Query suceeded.
                Ok(res) => break,

                // Query failed: wait 3 seconds then retry query
                Err(err @ SqlError::Driver(_)) | Err(err @ SqlError::Server(_)) => {
                    println!("Error: {}", err);
                    delay_for(Duration::from_secs(3)).await;
                    continue 'query_loop;
                }

                // Entire connection failed
                Err(err) => panic!("Placeholder for more sophisticated reconnect logic I have in actual code.")
            }
        }
    }
}

However, this is not possible because stmt.execute consumes stmt, and does not return it in the error case. In the case of success it is possible to reuse the prepared stmt, but it's awkward and involves reassigning the variable as implemented in the batch method.

Could we change execute and similar methods to take &mut self rather than self? This would make reusing connections/prepared statements possible in the case of errors, and make even the success case more ergonomic.

[blackbeam]

Hi. Yeah, this issue is already mentioned (see here) and I'm planning to fix it.

I suggest you to use an instance of Pool until then:

async fn execute_queries(
    pool: Pool,
    sql: String,
    mut rx: Receiver<Params>,
) -> super::Result<()> {
    // Next query loop
    while let Some(params) = rx.recv().await {
        // Query retry loop
        loop {
            let conn = pool.get_conn().await?;
            match conn.prep_exec(&sql, params.clone()).await {
                // Query suceeded.
                Ok(res) => break,

                // Query failed: wait 3 seconds then retry query
                Err(err @ Error::Driver(_)) | Err(err @ Error::Server(_)) => {
                    println!("Error: {}", err);
                    delay_for(Duration::from_secs(3)).await;
                    continue;
                }

                // Entire connection failed
                Err(err) => panic!("Placeholder for more sophisticated reconnect logic I have in actual code.")
            }
        }
    }

    Ok(())
}

Pool will try to return most recently used connection in get_conn, so prepared statement will be in its local cache on the second and subsequent iterations.

[blackbeam]

@nicoburns, new non-consuming API is available in v0.24.0-alpha. Could you, please, test it? (api docs)

[nicoburns]

Seems to be working for me. Good work fixing this one. I thought it was going to be months, but in fact it only took you one!