A very common use case is to create a bunch of prepared statements in a connection manager concern, when a new connection is needed and created (say, when a component requests a connection from a connection pool and there is not an idle one at the moment), associate the user context with a transaction on the returned connection (say when a web service begins to execute an http service request with a connection obtained from a connection pool), and then execute the prepared statements in it.

It seems, however, that Go database/sql requires the recompilation of every prepared statement each time it executes:

/* database/sql.go:1063, Go 1.6 */
        func (tx *Tx) Stmt(stmt *Stmt) *Stmt {
        // TODO(bradfitz): optimize this. Currently this re-prepares
        // each time.  This is fine for now to illustrate the API but
        // we should really cache already-prepared statements
        // per-Conn. See also the big comment in Tx.Prepare.

This is not fine, I think - it's worse than useless. In particular, it's strictly less performant (and /quietly/ so!) than not using statements where there are transactions in use.

So, we have a situation, it seems, where there is no de facto prepared statement support. Is this really the case? What needs to be done to implement support?

It appears as though Stmt /already/ knows how to do the right thing wrt transactions:

    /* database/sql.go:741 */
        // In a transaction, we always use the connection that the
        // transaction was created on.
        if s.tx != nil {
                s.mu.Unlock()
                ci, err = s.tx.grabConn() // blocks, waiting for the connection.
                if err != nil {
                        return
                }
                releaseConn = func(error) { s.tx.releaseConn() }
                return ci, releaseConn, s.txsi, nil
        }

Can we just create

func (tx *Tx) ExecStmt(s *Stmt, args ...interface{}) ...

and the like, which shallow-clone the Stmt (ie. reuse the same driver statement object), and associate a transaction with the new copy, before calling its Exec()?