Exec() now provides access to the last inserted ID and number of affected rows

for all statements, not just the last one. This is useful to execute batches of
statements such as UPDATE with minimal roundtrips.

The approach taken is to track last insert id and affected rows using []int64
instead of a int64. Both are set in `mysqlResult`, and a new `mysql.Result`
interface makes them accessible to callers calling `Exec()` via `sql.Conn.Raw`.
For example:

```
conn.Raw(func(conn interface{}) error {
        ex := conn.(driver.Execer)
        res, err := ex.Exec(`
        UPDATE point SET x = 1 WHERE y = 2;
        UPDATE point SET x = 2 WHERE y = 3;
        `, nil)
        // Both slices have 2 elements.
        log.Print(res.(mysql.Result).AllRowsAffected())
        log.Print(res.(mysql.Result).AllLastInsertIds())
      })
```

Author: mherr-google

README.md

@@ -288,6 +288,22 @@ Allow multiple statements in one query. While this allows batch queries, it also
 
 When `multiStatements` is used, `?` parameters must only be used in the first statement.
 
+It's possible to access the last inserted ID and number of affected rows for multiple statements by using `sql.Conn.Raw()` and the `mysql.Result`. For example:
+
+```
+conn, _ := db.Conn(ctx)
+conn.Raw(func(conn interface{}) error {
+  ex := conn.(driver.Execer)
+  res, err := ex.Exec(`
+  UPDATE point SET x = 1 WHERE y = 2;
+  UPDATE point SET x = 2 WHERE y = 3;
+  `, nil)
+  // Both slices have 2 elements.
+  log.Print(res.(mysql.Result).AllRowsAffected())
+  log.Print(res.(mysql.Result).AllLastInsertIds())
+})
+```
+
 ##### `parseTime`
 
 ```

connection.go

@@ -24,8 +24,8 @@ type mysqlConn struct {
 	buf              buffer
 	netConn          net.Conn
 	rawConn          net.Conn // underlying connection when netConn is TLS connection.
-	affectedRows     uint64
-	insertId         uint64
+	affectedRows     []int64
+	insertIds        []int64
 	cfg              *Config
 	maxAllowedPacket int
 	maxWriteSize     int
@@ -310,14 +310,14 @@ func (mc *mysqlConn) Exec(query string, args []driver.Value) (driver.Result, err
 		}
 		query = prepared
 	}
-	mc.affectedRows = 0
-	mc.insertId = 0
+	mc.affectedRows = nil
+	mc.insertIds = nil
 
 	err := mc.exec(query)
 	if err == nil {
 		return &mysqlResult{
-			affectedRows: int64(mc.affectedRows),
-			insertId:     int64(mc.insertId),
+			affectedRows: mc.affectedRows,
+			insertIds:    mc.insertIds,
 		}, err
 	}
 	return nil, mc.markBadConn(err)

driver_test.go

@@ -2379,6 +2379,42 @@ func TestMultiResultSetNoSelect(t *testing.T) {
 	})
 }
 
+func TestExecMultipleResults(t *testing.T) {
+	ctx := context.Background()
+	runTestsWithMultiStatement(t, dsn, func(dbt *DBTest) {
+		dbt.mustExec(`
+		CREATE TABLE test (
+			id INT NOT NULL AUTO_INCREMENT,
+			value VARCHAR(255),
+			PRIMARY KEY (id)
+		)`)
+		conn, err := dbt.db.Conn(ctx)
+		if err != nil {
+			t.Fatalf("failed to connect: %v", err)
+		}
+		conn.Raw(func(conn interface{}) error {
+			ex := conn.(driver.Execer)
+			res, err := ex.Exec(`
+			INSERT INTO test (value) VALUES ('a'), ('b');
+			INSERT INTO test (value) VALUES ('c'), ('d'), ('e');
+			`, nil)
+			if err != nil {
+				t.Fatalf("insert statements failed: %v", err)
+			}
+			mres := res.(Result)
+			if got, want := mres.AllRowsAffected(), []int64{2, 3}; !reflect.DeepEqual(got, want) {
+				t.Errorf("bad AllRowsAffected: got %v, want=%v", got, want)
+			}
+			// For INSERTs containing multiple rows, LAST_INSERT_ID() returns the
+			// first inserted ID, not the last.
+			if got, want := mres.AllLastInsertIds(), []int64{1, 3}; !reflect.DeepEqual(got, want) {
+				t.Errorf("bad AllLastInsertIds: got %v, want %v", got, want)
+			}
+			return nil
+		})
+	})
+}
+
 // tests if rows are set in a proper state if some results were ignored before
 // calling rows.NextResultSet.
 func TestSkipResults(t *testing.T) {

packets.go

@@ -535,6 +535,10 @@ func (mc *mysqlConn) readResultOK() error {
 // Result Set Header Packet
 // http://dev.mysql.com/doc/internals/en/com-query-response.html#packet-ProtocolText::Resultset
 func (mc *mysqlConn) readResultSetHeaderPacket() (int, error) {
+	// handleOkPacket replaces both values; other cases leave the values unchanged.
+	mc.affectedRows = append(mc.affectedRows, 0)
+	mc.insertIds = append(mc.insertIds, 0)
+
 	data, err := mc.readPacket()
 	if err == nil {
 		switch data[0] {
@@ -611,14 +615,24 @@ func readStatus(b []byte) statusFlag {
 // http://dev.mysql.com/doc/internals/en/generic-response-packets.html#packet-OK_Packet
 func (mc *mysqlConn) handleOkPacket(data []byte) error {
 	var n, m int
+	var affectedRows, insertID uint64
 
 	// 0x00 [1 byte]
 
 	// Affected rows [Length Coded Binary]
-	mc.affectedRows, _, n = readLengthEncodedInteger(data[1:])
+	affectedRows, _, n = readLengthEncodedInteger(data[1:])
 
 	// Insert id [Length Coded Binary]
-	mc.insertId, _, m = readLengthEncodedInteger(data[1+n:])
+	insertID, _, m = readLengthEncodedInteger(data[1+n:])
+
+	// Update for the current statement result (only used by
+	// readResultSetHeaderPacket).
+	if len(mc.affectedRows) > 0 {
+		mc.affectedRows[len(mc.affectedRows)-1] = int64(affectedRows)
+	}
+	if len(mc.insertIds) > 0 {
+		mc.insertIds[len(mc.insertIds)-1] = int64(insertID)
+	}
 
 	// server_status [2 bytes]
 	mc.status = readStatus(data[1+n+m : 1+n+m+2])
@@ -1149,6 +1163,8 @@ func (stmt *mysqlStmt) writeExecutePacket(args []driver.Value) error {
 	return mc.writePacket(data)
 }
 
+// For each remaining resultset in the stream, discards its rows and updates
+// mc.affectedRows and mc.insertIds.
 func (mc *mysqlConn) discardResults() error {
 	for mc.status&statusMoreResultsExists != 0 {
 		resLen, err := mc.readResultSetHeaderPacket()

result.go

@@ -8,15 +8,44 @@
 
 package mysql
 
+import "database/sql/driver"
+
+// Result exposes data not available through *connection.Result.
+//
+// This is accessible by executing statements using sql.Conn.Raw() and
+// downcasting the returned result:
+//
+//    res, err := rawConn.Exec(...)
+//    res.(mysql.Result).AllRowsAffected()
+//
+type Result interface {
+	driver.Result
+	// AllRowsAffected returns a slice containing the affected rows for each
+	// executed statement.
+	AllRowsAffected() []int64
+	// AllLastInsertIds returns a slice containing the last inserted ID for each
+	// executed statement.
+	AllLastInsertIds() []int64
+}
+
 type mysqlResult struct {
-	affectedRows int64
-	insertId     int64
+	// One entry in both slices is created for every executed statement result.
+	affectedRows []int64
+	insertIds    []int64
 }
 
 func (res *mysqlResult) LastInsertId() (int64, error) {
-	return res.insertId, nil
+	return res.insertIds[len(res.insertIds)-1], nil
 }
 
 func (res *mysqlResult) RowsAffected() (int64, error) {
-	return res.affectedRows, nil
+	return res.affectedRows[len(res.affectedRows)-1], nil
+}
+
+func (res *mysqlResult) AllLastInsertIds() []int64 {
+	return append([]int64{}, res.insertIds...) // defensive copy
+}
+
+func (res *mysqlResult) AllRowsAffected() []int64 {
+	return append([]int64{}, res.affectedRows...) // defensive copy
 }

statement.go

@@ -62,8 +62,8 @@ func (stmt *mysqlStmt) Exec(args []driver.Value) (driver.Result, error) {
 
 	mc := stmt.mc
 
-	mc.affectedRows = 0
-	mc.insertId = 0
+	mc.affectedRows = nil
+	mc.insertIds = nil
 
 	// Read Result
 	resLen, err := mc.readResultSetHeaderPacket()
@@ -88,8 +88,8 @@ func (stmt *mysqlStmt) Exec(args []driver.Value) (driver.Result, error) {
 	}
 
 	return &mysqlResult{
-		affectedRows: int64(mc.affectedRows),
-		insertId:     int64(mc.insertId),
+		affectedRows: mc.affectedRows,
+		insertIds:    mc.insertIds,
 	}, nil
 }