struct_mapper.go

package dbx

import (
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"sync"
	"time"
)

var structIndexCache sync.Map

func buildStructIndex(t reflect.Type) map[string]int {
	t = indirectType(t)
	out := make(map[string]int, t.NumField())
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		if f.PkgPath != "" { // unexported
			continue
		}
		tag := f.Tag.Get("db")
		if tag == "-" {
			continue
		}
		if tag != "" {
			name := strings.Split(tag, ",")[0]
			if name != "" {
				out[strings.ToLower(name)] = i
				continue
			}
		}
		out[strings.ToLower(toSnakeCase(f.Name))] = i
		out[strings.ToLower(f.Name)] = i
	}
	return out
}

func buildStructIndexCached(t reflect.Type) map[string]int {
	t = indirectType(t)
	if v, ok := structIndexCache.Load(t); ok {
		return v.(map[string]int)
	}
	idx := buildStructIndex(t)
	actual, _ := structIndexCache.LoadOrStore(t, idx)
	return actual.(map[string]int)
}

func assignValue(dst reflect.Value, src any) {
	if !dst.CanSet() {
		return
	}
	if src == nil {
		dst.Set(reflect.Zero(dst.Type()))
		return
	}

	if b, ok := src.([]byte); ok && dst.Kind() != reflect.Slice {
		src = string(b)
	}

	if dst.Kind() == reflect.Ptr {
		if dst.IsNil() {
			dst.Set(reflect.New(dst.Type().Elem()))
		}
		assignValue(dst.Elem(), src)
		return
	}

	sv := reflect.ValueOf(src)
	if sv.IsValid() && sv.Type().AssignableTo(dst.Type()) {
		dst.Set(sv)
		return
	}
	if sv.IsValid() && sv.Type().ConvertibleTo(dst.Type()) {
		dst.Set(sv.Convert(dst.Type()))
		return
	}

	switch dst.Kind() {
	case reflect.String:
		dst.SetString(fmt.Sprint(src))
	case reflect.Bool:
		switch v := src.(type) {
		case bool:
			dst.SetBool(v)
		case int:
			dst.SetBool(v != 0)
		case int8:
			dst.SetBool(v != 0)
		case int16:
			dst.SetBool(v != 0)
		case int32:
			dst.SetBool(v != 0)
		case int64:
			dst.SetBool(v != 0)
		case uint:
			dst.SetBool(v != 0)
		case uint8:
			dst.SetBool(v != 0)
		case uint16:
			dst.SetBool(v != 0)
		case uint32:
			dst.SetBool(v != 0)
		case uint64:
			dst.SetBool(v != 0)
		case []byte:
			p, _ := strconv.ParseBool(strings.TrimSpace(string(v)))
			if len(v) == 1 && (v[0] == '1' || v[0] == '0') {
				dst.SetBool(v[0] == '1')
				return
			}
			dst.SetBool(p)
		case string:
			p, _ := strconv.ParseBool(v)
			if strings.TrimSpace(v) == "1" {
				dst.SetBool(true)
				return
			}
			if strings.TrimSpace(v) == "0" {
				dst.SetBool(false)
				return
			}
			dst.SetBool(p)
		}
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		if dst.Type().PkgPath() == "time" && dst.Type().Name() == "Duration" {
			switch v := src.(type) {
			case int64:
				dst.SetInt(v)
				return
			case string:
				d, err := time.ParseDuration(v)
				if err == nil {
					dst.SetInt(int64(d))
				}
				return
			}
		}
		i, ok := toInt64(src)
		if ok {
			dst.SetInt(i)
		}
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		u, ok := toUint64(src)
		if ok {
			dst.SetUint(u)
		}
	case reflect.Float32, reflect.Float64:
		f, ok := toFloat64(src)
		if ok {
			dst.SetFloat(f)
		}
	}
}

func toInt64(v any) (int64, bool) {
	switch n := v.(type) {
	case int:
		return int64(n), true
	case int8:
		return int64(n), true
	case int16:
		return int64(n), true
	case int32:
		return int64(n), true
	case int64:
		return n, true
	case uint:
		return int64(n), true
	case uint8:
		return int64(n), true
	case uint16:
		return int64(n), true
	case uint32:
		return int64(n), true
	case uint64:
		return int64(n), true
	case float32:
		return int64(n), true
	case float64:
		return int64(n), true
	case string:
		i, err := strconv.ParseInt(strings.TrimSpace(n), 10, 64)
		return i, err == nil
	default:
		return 0, false
	}
}

func toUint64(v any) (uint64, bool) {
	switch n := v.(type) {
	case int:
		return uint64(n), true
	case int8:
		return uint64(n), true
	case int16:
		return uint64(n), true
	case int32:
		return uint64(n), true
	case int64:
		return uint64(n), true
	case uint:
		return uint64(n), true
	case uint8:
		return uint64(n), true
	case uint16:
		return uint64(n), true
	case uint32:
		return uint64(n), true
	case uint64:
		return n, true
	case float32:
		return uint64(n), true
	case float64:
		return uint64(n), true
	case string:
		i, err := strconv.ParseUint(strings.TrimSpace(n), 10, 64)
		return i, err == nil
	default:
		return 0, false
	}
}

func toFloat64(v any) (float64, bool) {
	switch n := v.(type) {
	case float32:
		return float64(n), true
	case float64:
		return n, true
	case int:
		return float64(n), true
	case int8:
		return float64(n), true
	case int16:
		return float64(n), true
	case int32:
		return float64(n), true
	case int64:
		return float64(n), true
	case uint:
		return float64(n), true
	case uint8:
		return float64(n), true
	case uint16:
		return float64(n), true
	case uint32:
		return float64(n), true
	case uint64:
		return float64(n), true
	case string:
		f, err := strconv.ParseFloat(strings.TrimSpace(n), 64)
		return f, err == nil
	default:
		return 0, false
	}
}