IIRC the problem is that one needs to know not to do a real 'prepare' (which doesn't work with utility statements like COPY) for COPY statements, which is why such sniffing is tempting: one must use the 'simple' query protocol instead, if memory serves.

Given that, what if the same trick of hitching a ride on result types that come out of `database/sql` in the place that *can* use the simple query protocol?

So instead of db.Prepare => Stmt as in this patch, how about db.Exec => Result?  Result is an interface.  If the user knows a-priori it is a COPY (as they probably do...) then it can be type-asserted  into a Copy implementation.

In that approach, one would splice in COPY support into 'simpleExec' as an alternative to 'parseComplete' et al:

```go
func (cn *conn) simpleExec(q string) (res driver.Result, err error) {
	defer errRecover(&err)

	b := cn.writeBuf('Q')
	b.string(q)
	cn.send(b)

	for {
		t, r := cn.recv1()
		switch t {
		case 'C':
			res = parseComplete(r.string())
		//
		// AROUND HERE SOMEWHERE...
		//
		case 'Z':
			// done
			return
		case 'E':
			err = parseError(r)
		case 'T', 'N', 'S', 'D':
			// ignore
		default:
			errorf("unknown response for simple query: %q", t)
		}
	}
	panic("not reached")
}
```

I dunno how this would look exactly...seems like the only way to really know would be to try.

As a minor plus, it might provide a natural unified handling of COPY IN and COPY OUT.