Use mc.buf while interpolating

benchmark                  old ns/op     new ns/op     delta
BenchmarkInterpolation     1900          1403          -26.16%

benchmark                  old allocs     new allocs     delta
BenchmarkInterpolation     2              1              -50.00%

benchmark                  old bytes     new bytes     delta
BenchmarkInterpolation     448           160           -64.29%

Author: methane

benchmark_test.go

@@ -222,6 +222,7 @@ func BenchmarkInterpolation(b *testing.B) {
 		},
 		maxPacketAllowed: maxPacketSize,
 		maxWriteSize:     maxPacketSize - 1,
+		buf:              buffer{buf: make([]byte, defaultBufSize)},
 	}
 
 	args := []driver.Value{

buffer.go

@@ -25,9 +25,8 @@ type buffer struct {
 }
 
 func newBuffer(rd io.Reader) buffer {
-	var b [defaultBufSize]byte
 	return buffer{
-		buf: b[:],
+		buf: make([]byte, defaultBufSize),
 		rd:  rd,
 	}
 }

connection.go

@@ -166,36 +166,44 @@ func (mc *mysqlConn) Prepare(query string) (driver.Stmt, error) {
 }
 
 // estimateParamLength calculates upper bound of string length from types.
-func estimateParamLength(args []driver.Value) (int, bool) {
-	l := 0
+func estimateParamLength(query string, args []driver.Value) (min, max int) {
+	min = len(query)
+	max = len(query)
 	for _, a := range args {
 		switch v := a.(type) {
 		case int64, float64:
-			// 24 (-1.7976931348623157e+308) may be upper bound. But I'm not sure.
-			l += 25
-		case bool:
-			l += 1 // 0 or 1
+			min += 1
+			max += 25 // 24 (-1.7976931348623157e+308) may be upper bound. But I'm not sure.
+		case bool: // 0 or 1
+			min += 1
+			max += 1
 		case time.Time:
-			l += 30 // '1234-12-23 12:34:56.777777'
+			min += 23 // '1234-12-23 12:34:56'
+			max += 30 // '1234-12-23 12:34:56.777777'
 		case string:
-			l += len(v)*2 + 2
+			min += len(v) + 2
+			max += len(v)*2 + 2
 		case []byte:
-			l += len(v)*2 + 2
+			min += len(v) + 2
+			max += len(v)*2 + 2
 		default:
-			return 0, false
+			panic("driver.Value has invalid type")
 		}
 	}
-	return l, true
+	return
 }
 
 func (mc *mysqlConn) interpolateParams(query string, args []driver.Value) (string, error) {
-	estimated, ok := estimateParamLength(args)
-	if !ok {
+	min, max := estimateParamLength(query, args)
+	if min+4 > maxPacketSize { // 4 bytes for packet header
 		return "", driver.ErrSkip
 	}
-	estimated += len(query)
+	buffSize := max
+	if max > maxPacketSize { // maxPacketSize is upper bound of mc.buffer
+		buffSize = maxPacketSize
+	}
 
-	buf := make([]byte, 0, estimated)
+	buf := mc.buf.takeBuffer(buffSize)[:0]
 	argPos := 0
 
 	for i := 0; i < len(query); i++ {