Use go:linkname to call convertAssign instead of copying it

Author: kszafran

reflectx/reflect.go

@@ -7,13 +7,11 @@
 package reflectx
 
 import (
-	"database/sql"
-	"fmt"
 	"reflect"
 	"runtime"
-	"strconv"
 	"strings"
 	"sync"
+	_ "unsafe"
 )
 
 // A FieldInfo is metadata for a struct field.
@@ -224,17 +222,15 @@ func (o *ObjectContext) NewRow(value reflect.Value) {
 // a nestedFieldScanner is returned instead of the standard value reference
 func (o *ObjectContext) FieldForIndexes(indexes []int) reflect.Value {
 	if len(indexes) == 1 {
-		val := FieldByIndexes(o.value, indexes)
-		return val
+		return FieldByIndexes(o.value, indexes)
 	}
 
 	obj := &nestedFieldScanner{
 		parent:  o,
 		indexes: indexes,
 	}
 
-	v := reflect.ValueOf(obj).Elem()
-	return v
+	return reflect.ValueOf(obj).Elem()
 }
 
 // nestedFieldScanner will only forward the Scan to the nested value if
@@ -245,149 +241,16 @@ type nestedFieldScanner struct {
 }
 
 // Scan implements sql.Scanner.
-// This method largely mirrors the sql.convertAssign() method with some minor changes
 func (o *nestedFieldScanner) Scan(src interface{}) error {
 	if src == nil {
 		return nil
 	}
-
-	dv := FieldByIndexes(o.parent.value, o.indexes)
-	// Dereference pointer fields to avoid double pointers **T
-	if dv.Kind() == reflect.Pointer {
-		dv.Set(reflect.New(dv.Type().Elem()))
-		dv = dv.Elem()
-	}
-	iface := dv.Addr().Interface()
-
-	if scan, ok := iface.(sql.Scanner); ok {
-		return scan.Scan(src)
-	}
-
-	sv := reflect.ValueOf(src)
-
-	// below is taken from https://cs.opensource.google/go/go/+/refs/tags/go1.19.5:src/database/sql/convert.go
-	// with a few minor edits
-
-	if sv.IsValid() && sv.Type().AssignableTo(dv.Type()) {
-		switch b := src.(type) {
-		case []byte:
-			dv.Set(reflect.ValueOf(bytesClone(b)))
-		default:
-			dv.Set(sv)
-		}
-
-		return nil
-	}
-
-	if dv.Kind() == sv.Kind() && sv.Type().ConvertibleTo(dv.Type()) {
-		dv.Set(sv.Convert(dv.Type()))
-		return nil
-	}
-
-	// The following conversions use a string value as an intermediate representation
-	// to convert between various numeric types.
-	//
-	// This also allows scanning into user defined types such as "type Int int64".
-	// For symmetry, also check for string destination types.
-	switch dv.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		if src == nil {
-			return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
-		}
-		s := asString(src)
-		i64, err := strconv.ParseInt(s, 10, dv.Type().Bits())
-		if err != nil {
-			err = strconvErr(err)
-			return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
-		}
-		dv.SetInt(i64)
-		return nil
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		if src == nil {
-			return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
-		}
-		s := asString(src)
-		u64, err := strconv.ParseUint(s, 10, dv.Type().Bits())
-		if err != nil {
-			err = strconvErr(err)
-			return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
-		}
-		dv.SetUint(u64)
-		return nil
-	case reflect.Float32, reflect.Float64:
-		if src == nil {
-			return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
-		}
-		s := asString(src)
-		f64, err := strconv.ParseFloat(s, dv.Type().Bits())
-		if err != nil {
-			err = strconvErr(err)
-			return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
-		}
-		dv.SetFloat(f64)
-		return nil
-	case reflect.String:
-		if src == nil {
-			return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
-		}
-		switch v := src.(type) {
-		case string:
-			dv.SetString(v)
-			return nil
-		case []byte:
-			dv.SetString(string(v))
-			return nil
-		}
-	}
-
-	return fmt.Errorf("don't know how to parse type %T -> %T", src, iface)
+	dest := FieldByIndexes(o.parent.value, o.indexes)
+	return convertAssign(dest.Addr().Interface(), src)
 }
 
-// returns internal conversion error if available
-// taken from https://cs.opensource.google/go/go/+/refs/tags/go1.19.5:src/database/sql/convert.go
-func strconvErr(err error) error {
-	if ne, ok := err.(*strconv.NumError); ok {
-		return ne.Err
-	}
-	return err
-}
-
-// converts value to it's string value
-// taken from https://cs.opensource.google/go/go/+/refs/tags/go1.19.5:src/database/sql/convert.go
-func asString(src interface{}) string {
-	switch v := src.(type) {
-	case string:
-		return v
-	case []byte:
-		return string(v)
-	}
-	rv := reflect.ValueOf(src)
-	switch rv.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return strconv.FormatInt(rv.Int(), 10)
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return strconv.FormatUint(rv.Uint(), 10)
-	case reflect.Float64:
-		return strconv.FormatFloat(rv.Float(), 'g', -1, 64)
-	case reflect.Float32:
-		return strconv.FormatFloat(rv.Float(), 'g', -1, 32)
-	case reflect.Bool:
-		return strconv.FormatBool(rv.Bool())
-	}
-	return fmt.Sprintf("%v", src)
-}
-
-// bytesClone returns a copy of b[:len(b)].
-// The result may have additional unused capacity.
-// Clone(nil) returns nil.
-//
-// bytesClone is a mirror of bytes.Clone while our go.mod is on an older version
-func bytesClone(b []byte) []byte {
-	if b == nil {
-		return nil
-	}
-	return append([]byte{}, b...)
-}
+//go:linkname convertAssign database/sql.convertAssign
+func convertAssign(dest, src interface{}) error
 
 // FieldByIndexes returns a value for the field given by the struct traversal
 // for the given value.
@@ -396,8 +259,7 @@ func FieldByIndexes(v reflect.Value, indexes []int) reflect.Value {
 		v = reflect.Indirect(v).Field(i)
 		// if this is a pointer and it's nil, allocate a new value and set it
 		if v.Kind() == reflect.Ptr && v.IsNil() {
-			alloc := reflect.New(Deref(v.Type()))
-			v.Set(alloc)
+			v.Set(reflect.New(v.Type().Elem()))
 		}
 		if v.Kind() == reflect.Map && v.IsNil() {
 			v.Set(reflect.MakeMap(v.Type()))