optimize ScanColumnsToStruct

Author: xgfone

dml_select.go

@@ -217,8 +217,7 @@ func (b *SelectBuilder) SelectStructWithTable(s any, table string) *SelectBuilde
 		defer ttlock.Unlock()
 
 		columntables = typetables.Load().(map[typetable][]string)
-		columns, ok = columntables[key]
-		if !ok {
+		if columns, ok = columntables[key]; !ok {
 			columns = b.getColumnsFromStruct(s, table)
 
 			_columntables := make(map[typetable][]string, len(columntables)+1)

dml_select_row_scanner_struct.go

@@ -15,10 +15,14 @@
 package sqlx
 
 import (
+	"database/sql"
 	"database/sql/driver"
 	"fmt"
+	"maps"
 	"reflect"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"time"
 )
 
@@ -33,41 +37,86 @@ func ScanColumnsToStruct(scan func(...any) error, columns []string, s any) (err
 		panic("sqlx.ScanColumnsToStruct: no selected columns")
 	}
 
-	fields := getFields(s)
-	vs := make([]any, len(columns))
-	for i, c := range columns {
-		if _, ok := fields[c]; ok {
-			vs[i] = fields[c].Addr().Interface()
-		} else {
-			vs[i] = new(any)
+	value := reflect.ValueOf(s)
+	extract := getscannerextractfunc(value.Type())
+	scanners := make([]any, len(columns))
+	extract(value, scanners, columns)
+	return scan(scanners...)
+}
+
+func getscannerextractfunc(vtype reflect.Type) scannerExtractFunc {
+	extract, ok := _scannedstructmaps.Load().(map[reflect.Type]scannerExtractFunc)[vtype]
+	if !ok {
+		_scannedstructlock.Lock()
+		defer _scannedstructlock.Unlock()
+
+		types := _scannedstructmaps.Load().(map[reflect.Type]scannerExtractFunc)
+		if extract, ok = types[vtype]; !ok {
+			extract = getScannerFieldsFromStruct(vtype)
+
+			newtypes := make(map[reflect.Type]scannerExtractFunc, len(types)+1)
+			maps.Copy(newtypes, types)
+			newtypes[vtype] = extract
+
+			_scannedstructmaps.Store(newtypes)
 		}
 	}
-	return scan(vs...)
+	return extract
 }
 
-func getFields(s any) map[string]reflect.Value {
-	v := reflect.ValueOf(s)
-	if v.Kind() != reflect.Ptr {
-		panic("not a pointer to struct")
-	} else if v = v.Elem(); v.Kind() != reflect.Struct {
-		panic("not a pointer to struct")
+type scannerExtractFunc func(value reflect.Value, scanners []any, columns []string)
+
+var (
+	_scannedstructlock sync.Mutex
+	_scannedstructmaps atomic.Value // map[reflect.Type]scannerExtractFunc
+)
+
+func init() {
+	_scannedstructmaps.Store(map[reflect.Type]scannerExtractFunc(nil))
+}
+
+func getScannerFieldsFromStruct(vtype reflect.Type) scannerExtractFunc {
+	if vtype.Kind() != reflect.Ptr {
+		panic("sqlx.ScanColumnsToStruct: not a pointer to struct")
+	} else if vtype = vtype.Elem(); vtype.Kind() != reflect.Struct {
+		panic("sqlx.ScanColumnsToStruct: not a pointer to struct")
 	}
 
-	vs := make(map[string]reflect.Value, v.NumField())
-	getFieldsFromStruct("", v, vs)
-	return vs
+	fields := make(map[string]scannedfield, 16)
+	_getScannerFieldsFromStruct(fields, vtype, "", nil)
+
+	return func(value reflect.Value, scanners []any, columns []string) {
+		value = value.Elem()
+		for i, column := range columns {
+			if field, ok := fields[column]; ok && column != "deleted_at" {
+				scanners[i] = field.Scanner(value)
+			} else {
+				scanners[i] = nullScanner{}
+			}
+		}
+	}
+}
+
+type scannedfield struct {
+	Indexes []int
 }
 
-func getFieldsFromStruct(prefix string, v reflect.Value, vs map[string]reflect.Value) {
-	vt := v.Type()
-	_len := v.NumField()
+func (f scannedfield) Scanner(value reflect.Value) sql.Scanner {
+	for _, index := range f.Indexes {
+		value = value.Field(index)
+	}
+	return nullScanner{Value: value.Addr().Interface()}
+}
+
+func _getScannerFieldsFromStruct(fields map[string]scannedfield, vtype reflect.Type, prefix string, indexes []int) {
+	_len := vtype.NumField()
 
 LOOP:
 	for i := 0; i < _len; i++ {
-		vft := vt.Field(i)
+		ftype := vtype.Field(i)
 
 		var targs string
-		tname := vft.Tag.Get("sql")
+		tname := ftype.Tag.Get("sql")
 		if index := strings.IndexByte(tname, ','); index > -1 {
 			targs = tname[index+1:]
 			tname = strings.TrimSpace(tname[:index])
@@ -77,29 +126,31 @@ LOOP:
 			continue
 		}
 
-		name := vft.Name
+		name := ftype.Name
 		if tname != "" {
 			name = tname
 		}
 
-		vf := v.Field(i)
-		if vft.Type.Kind() == reflect.Struct {
+		_indexes := make([]int, 0, len(indexes)+1)
+		_indexes = append(_indexes, indexes...)
+		_indexes = append(_indexes, i)
+
+		if ftype.Type.Kind() == reflect.Struct {
 			if tagContainAttr(targs, "notpropagate") {
 				continue
 			}
 
-			switch vf.Interface().(type) {
+			fvalue := reflect.New(ftype.Type).Elem()
+			switch fvalue.Interface().(type) {
 			case time.Time:
 			case driver.Valuer:
 			default:
-				getFieldsFromStruct(formatFieldName(prefix, tname), vf, vs)
+				_getScannerFieldsFromStruct(fields, ftype.Type, formatFieldName(prefix, tname), _indexes)
 				continue LOOP
 			}
 		}
 
-		if vf.CanSet() {
-			vs[formatFieldName(prefix, name)] = v.Field(i)
-		}
+		fields[formatFieldName(prefix, name)] = scannedfield{Indexes: _indexes}
 	}
 }