PERF: cache NameMapping (#135)

Author: taylorchu

README.md

@@ -7,6 +7,21 @@
 
 gocraft/dbr provides additions to Go's database/sql for super fast performance and convenience.
 
+## Benchmark (2018-05-11)
+
+```
+BenchmarkLoadValues/sqlx_10-8         	    5000	    407318 ns/op	    3913 B/op	     164 allocs/op
+BenchmarkLoadValues/dbr_10-8          	    5000	    372940 ns/op	    3874 B/op	     123 allocs/op
+BenchmarkLoadValues/sqlx_100-8        	    2000	    584197 ns/op	   30195 B/op	    1428 allocs/op
+BenchmarkLoadValues/dbr_100-8         	    3000	    558852 ns/op	   22965 B/op	     937 allocs/op
+BenchmarkLoadValues/sqlx_1000-8       	    1000	   2319101 ns/op	  289339 B/op	   14031 allocs/op
+BenchmarkLoadValues/dbr_1000-8        	    1000	   2310441 ns/op	  210092 B/op	    9040 allocs/op
+BenchmarkLoadValues/sqlx_10000-8      	     100	  17004716 ns/op	 3193997 B/op	  140043 allocs/op
+BenchmarkLoadValues/dbr_10000-8       	     100	  16150062 ns/op	 2394698 B/op	   90051 allocs/op
+BenchmarkLoadValues/sqlx_100000-8     	      10	 170068209 ns/op	31679944 B/op	 1400053 allocs/op
+BenchmarkLoadValues/dbr_100000-8      	      10	 147202536 ns/op	23680625 B/op	  900061 allocs/op
+```
+
 ## Driver support
 
 * MySQL
@@ -28,4 +43,4 @@ Contributors:
 
 
 ## License
-[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fgocraft%2Fdbr.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fgocraft%2Fdbr?ref=badge_large)
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fgocraft%2Fdbr.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fgocraft%2Fdbr?ref=badge_large)

insert.go

@@ -152,7 +152,8 @@ func (b *InsertStmt) Record(structValue interface{}) *InsertStmt {
 	if v.Kind() == reflect.Struct {
 		found := make([]interface{}, len(b.Column)+1)
 		// ID is recommended by golint here
-		findValueByName(v, append(b.Column, "id"), found, false)
+		s := newTagStore()
+		s.findValueByName(v, append(b.Column, "id"), found, false)
 
 		value := found[:len(found)-1]
 		for i, v := range value {

load.go

@@ -26,6 +26,7 @@ func Load(rows *sql.Rows, value interface{}) (int, error) {
 	if err != nil {
 		return 0, err
 	}
+	ptr := make([]interface{}, len(column))
 
 	v := reflect.ValueOf(value)
 	if v.Kind() != reflect.Ptr || v.IsNil() {
@@ -39,11 +40,11 @@ func Load(rows *sql.Rows, value interface{}) (int, error) {
 	if isMap {
 		v.Set(reflect.MakeMap(v.Type()))
 	}
+
+	s := newTagStore()
 	count := 0
 	for rows.Next() {
 		var elem, keyElem reflect.Value
-		var ptr []interface{}
-		var err error
 
 		if isMapOfSlices {
 			elem = reflectAlloc(v.Type().Elem().Elem())
@@ -54,27 +55,36 @@ func Load(rows *sql.Rows, value interface{}) (int, error) {
 		}
 
 		if isMap {
-			ptr, err = findPtr(column[1:], elem)
+			err := s.findPtr(elem, column[1:], ptr[1:])
 			if err != nil {
 				return 0, err
 			}
 			keyElem = reflectAlloc(v.Type().Key())
-			keyPtr, err := findPtr(column[0:1], keyElem)
+			err = s.findPtr(keyElem, column[:1], ptr[:1])
 			if err != nil {
 				return 0, err
 			}
-			ptr = append(keyPtr, ptr...)
 		} else {
-			ptr, err = findPtr(column, elem)
+			err := s.findPtr(elem, column, ptr)
 			if err != nil {
 				return 0, err
 			}
 		}
 
+		// Before scanning, set nil pointer to dummy dest.
+		// After that, reset pointers to nil for the next batch.
+		for i := range ptr {
+			if ptr[i] == nil {
+				ptr[i] = dummyDest
+			}
+		}
 		err = rows.Scan(ptr...)
 		if err != nil {
 			return 0, err
 		}
+		for i := range ptr {
+			ptr[i] = nil
+		}
 
 		count++
 
@@ -112,26 +122,3 @@ var (
 	dummyDest   sql.Scanner = dummyScanner{}
 	typeScanner             = reflect.TypeOf((*sql.Scanner)(nil)).Elem()
 )
-
-func findPtr(column []string, value reflect.Value) ([]interface{}, error) {
-	if value.CanAddr() && value.Addr().Type().Implements(typeScanner) {
-		return []interface{}{value.Addr().Interface()}, nil
-	}
-	switch value.Kind() {
-	case reflect.Struct:
-		ptr := make([]interface{}, len(column))
-		findValueByName(value, column, ptr, true)
-		for i := range ptr {
-			if ptr[i] == nil {
-				ptr[i] = dummyDest
-			}
-		}
-		return ptr, nil
-	case reflect.Ptr:
-		if value.IsNil() {
-			value.Set(reflect.New(value.Type().Elem()))
-		}
-		return findPtr(column, value.Elem())
-	}
-	return []interface{}{value.Addr().Interface()}, nil
-}

load_benchmark_test.go

@@ -1,6 +1,7 @@
 package dbr
 
 import (
+	"context"
 	"fmt"
 	"testing"
 
@@ -53,7 +54,7 @@ func BenchmarkLoadValues(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				var suggs []*Suggestion
 				b.StartTimer()
-				err := db.Select(&suggs, query)
+				err := db.SelectContext(context.Background(), &suggs, query)
 				b.StopTimer()
 				require.NoError(b, err)
 				require.Len(b, suggs, n)
@@ -65,7 +66,7 @@ func BenchmarkLoadValues(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				var suggs []*Suggestion
 				b.StartTimer()
-				_, err := sess.SelectBySql(query).Load(&suggs)
+				_, err := sess.SelectBySql(query).LoadContext(context.Background(), &suggs)
 				b.StopTimer()
 				require.NoError(b, err)
 				require.Len(b, suggs, n)

util.go

@@ -47,18 +47,22 @@ var (
 	typeValuer = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
 )
 
-func findValueByName(value reflect.Value, name []string, found []interface{}, retPtr bool) {
-	if value.Type().Implements(typeValuer) {
-		return
+type tagStore struct {
+	m map[reflect.Type][]string
+}
+
+func newTagStore() *tagStore {
+	return &tagStore{
+		m: make(map[reflect.Type][]string),
 	}
-	switch value.Kind() {
-	case reflect.Ptr:
-		if value.IsNil() {
-			return
-		}
-		findValueByName(value.Elem(), name, found, retPtr)
-	case reflect.Struct:
-		t := value.Type()
+}
+
+func (s *tagStore) get(t reflect.Type) []string {
+	if t.Kind() != reflect.Struct {
+		return nil
+	}
+	if _, ok := s.m[t]; !ok {
+		l := make([]string, t.NumField())
 		for i := 0; i < t.NumField(); i++ {
 			field := t.Field(i)
 			if field.PkgPath != "" && !field.Anonymous {
@@ -74,20 +78,64 @@ func findValueByName(value reflect.Value, name []string, found []interface{}, re
 				// no tag, but we can record the field name
 				tag = NameMapping(field.Name)
 			}
+			l[i] = tag
+		}
+		s.m[t] = l
+	}
+	return s.m[t]
+}
+
+func (s *tagStore) findPtr(value reflect.Value, name []string, ptr []interface{}) error {
+	if value.CanAddr() && value.Addr().Type().Implements(typeScanner) {
+		ptr[0] = value.Addr().Interface()
+		return nil
+	}
+	switch value.Kind() {
+	case reflect.Struct:
+		s.findValueByName(value, name, ptr, true)
+		return nil
+	case reflect.Ptr:
+		if value.IsNil() {
+			value.Set(reflect.New(value.Type().Elem()))
+		}
+		return s.findPtr(value.Elem(), name, ptr)
+	default:
+		ptr[0] = value.Addr().Interface()
+		return nil
+	}
+}
+
+func (s *tagStore) findValueByName(value reflect.Value, name []string, ret []interface{}, retPtr bool) {
+	if value.Type().Implements(typeValuer) {
+		return
+	}
+	switch value.Kind() {
+	case reflect.Ptr:
+		if value.IsNil() {
+			return
+		}
+		s.findValueByName(value.Elem(), name, ret, retPtr)
+	case reflect.Struct:
+		l := s.get(value.Type())
+		for i := 0; i < value.NumField(); i++ {
+			tag := l[i]
+			if tag == "" {
+				continue
+			}
 			fieldValue := value.Field(i)
 			for i, want := range name {
 				if want != tag {
 					continue
 				}
-				if found[i] == nil {
+				if ret[i] == nil {
 					if retPtr {
-						found[i] = fieldValue.Addr().Interface()
+						ret[i] = fieldValue.Addr().Interface()
 					} else {
-						found[i] = fieldValue
+						ret[i] = fieldValue
 					}
 				}
 			}
-			findValueByName(fieldValue, name, found, retPtr)
+			s.findValueByName(fieldValue, name, ret, retPtr)
 		}
 	}
 }

util_test.go

@@ -99,7 +99,8 @@ func TestFindValueByName(t *testing.T) {
 		},
 	} {
 		found := make([]interface{}, len(test.name))
-		findValueByName(reflect.ValueOf(test.in), test.name, found, false)
+		s := newTagStore()
+		s.findValueByName(reflect.ValueOf(test.in), test.name, found, false)
 
 		var got []string
 		for i, v := range found {