bump uptrace/bun dependencies from 1.2.6 to 1.2.8 (#3645)

vendor/github.com/uptrace/bun/schema/hook.go

@@ -24,7 +24,7 @@ type BeforeAppendModelHook interface {
 	BeforeAppendModel(ctx context.Context, query Query) error
 }
 
-var beforeAppendModelHookType = reflect.TypeOf((*BeforeAppendModelHook)(nil)).Elem()
+var beforeAppendModelHookType = reflect.TypeFor[BeforeAppendModelHook]()
 
 //------------------------------------------------------------------------------
 
@@ -32,7 +32,7 @@ type BeforeScanRowHook interface {
 	BeforeScanRow(context.Context) error
 }
 
-var beforeScanRowHookType = reflect.TypeOf((*BeforeScanRowHook)(nil)).Elem()
+var beforeScanRowHookType = reflect.TypeFor[BeforeScanRowHook]()
 
 //------------------------------------------------------------------------------
 
@@ -40,4 +40,4 @@ type AfterScanRowHook interface {
 	AfterScanRow(context.Context) error
 }
 
-var afterScanRowHookType = reflect.TypeOf((*AfterScanRowHook)(nil)).Elem()
+var afterScanRowHookType = reflect.TypeFor[AfterScanRowHook]()

vendor/github.com/uptrace/bun/schema/reflect.go

@@ -10,18 +10,18 @@ import (
 )
 
 var (
-	bytesType          = reflect.TypeOf((*[]byte)(nil)).Elem()
-	timePtrType        = reflect.TypeOf((*time.Time)(nil))
-	timeType           = timePtrType.Elem()
-	ipType             = reflect.TypeOf((*net.IP)(nil)).Elem()
-	ipNetType          = reflect.TypeOf((*net.IPNet)(nil)).Elem()
-	netipPrefixType    = reflect.TypeOf((*netip.Prefix)(nil)).Elem()
-	netipAddrType      = reflect.TypeOf((*netip.Addr)(nil)).Elem()
-	jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem()
+	bytesType          = reflect.TypeFor[[]byte]()
+	timePtrType        = reflect.TypeFor[*time.Time]()
+	timeType           = reflect.TypeFor[time.Time]()
+	ipType             = reflect.TypeFor[net.IP]()
+	ipNetType          = reflect.TypeFor[net.IPNet]()
+	netipPrefixType    = reflect.TypeFor[netip.Prefix]()
+	netipAddrType      = reflect.TypeFor[netip.Addr]()
+	jsonRawMessageType = reflect.TypeFor[json.RawMessage]()
 
-	driverValuerType  = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
-	queryAppenderType = reflect.TypeOf((*QueryAppender)(nil)).Elem()
-	jsonMarshalerType = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
+	driverValuerType  = reflect.TypeFor[driver.Valuer]()
+	queryAppenderType = reflect.TypeFor[QueryAppender]()
+	jsonMarshalerType = reflect.TypeFor[json.Marshaler]()
 )
 
 func indirectType(t reflect.Type) reflect.Type {

vendor/github.com/uptrace/bun/schema/scan.go

@@ -18,7 +18,7 @@ import (
 	"github.com/uptrace/bun/internal"
 )
 
-var scannerType = reflect.TypeOf((*sql.Scanner)(nil)).Elem()
+var scannerType = reflect.TypeFor[sql.Scanner]()
 
 type ScannerFunc func(dest reflect.Value, src interface{}) error
 
@@ -38,8 +38,8 @@ func init() {
 		reflect.Uint32:        scanUint64,
 		reflect.Uint64:        scanUint64,
 		reflect.Uintptr:       scanUint64,
-		reflect.Float32:       scanFloat64,
-		reflect.Float64:       scanFloat64,
+		reflect.Float32:       scanFloat,
+		reflect.Float64:       scanFloat,
 		reflect.Complex64:     nil,
 		reflect.Complex128:    nil,
 		reflect.Array:         nil,
@@ -214,11 +214,14 @@ func scanUint64(dest reflect.Value, src interface{}) error {
 	}
 }
 
-func scanFloat64(dest reflect.Value, src interface{}) error {
+func scanFloat(dest reflect.Value, src interface{}) error {
 	switch src := src.(type) {
 	case nil:
 		dest.SetFloat(0)
 		return nil
+	case float32:
+		dest.SetFloat(float64(src))
+		return nil
 	case float64:
 		dest.SetFloat(src)
 		return nil

vendor/github.com/uptrace/bun/schema/sqltype.go

@@ -13,12 +13,12 @@ import (
 )
 
 var (
-	bunNullTimeType = reflect.TypeOf((*NullTime)(nil)).Elem()
-	nullTimeType    = reflect.TypeOf((*sql.NullTime)(nil)).Elem()
-	nullBoolType    = reflect.TypeOf((*sql.NullBool)(nil)).Elem()
-	nullFloatType   = reflect.TypeOf((*sql.NullFloat64)(nil)).Elem()
-	nullIntType     = reflect.TypeOf((*sql.NullInt64)(nil)).Elem()
-	nullStringType  = reflect.TypeOf((*sql.NullString)(nil)).Elem()
+	bunNullTimeType = reflect.TypeFor[NullTime]()
+	nullTimeType    = reflect.TypeFor[sql.NullTime]()
+	nullBoolType    = reflect.TypeFor[sql.NullBool]()
+	nullFloatType   = reflect.TypeFor[sql.NullFloat64]()
+	nullIntType     = reflect.TypeFor[sql.NullInt64]()
+	nullStringType  = reflect.TypeFor[sql.NullString]()
 )
 
 var sqlTypes = []string{

vendor/github.com/uptrace/bun/schema/table.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"fmt"
 	"reflect"
+	"sort"
 	"strings"
 	"time"
 
@@ -22,7 +23,7 @@ const (
 )
 
 var (
-	baseModelType      = reflect.TypeOf((*BaseModel)(nil)).Elem()
+	baseModelType      = reflect.TypeFor[BaseModel]()
 	tableNameInflector = inflection.Plural
 )
 
@@ -75,7 +76,7 @@ type structField struct {
 	Table *Table
 }
 
-func (table *Table) init(dialect Dialect, typ reflect.Type, canAddr bool) {
+func (table *Table) init(dialect Dialect, typ reflect.Type) {
 	table.dialect = dialect
 	table.Type = typ
 	table.ZeroValue = reflect.New(table.Type).Elem()
@@ -90,7 +91,7 @@ func (table *Table) init(dialect Dialect, typ reflect.Type, canAddr bool) {
 
 	table.Fields = make([]*Field, 0, typ.NumField())
 	table.FieldMap = make(map[string]*Field, typ.NumField())
-	table.processFields(typ, canAddr)
+	table.processFields(typ)
 
 	hooks := []struct {
 		typ  reflect.Type
@@ -110,7 +111,7 @@ func (table *Table) init(dialect Dialect, typ reflect.Type, canAddr bool) {
 	}
 }
 
-func (t *Table) processFields(typ reflect.Type, canAddr bool) {
+func (t *Table) processFields(typ reflect.Type) {
 	type embeddedField struct {
 		prefix     string
 		index      []int
@@ -250,6 +251,30 @@ func (t *Table) processFields(typ reflect.Type, canAddr bool) {
 			t.addUnique(subfield, embfield.prefix, v)
 		}
 	}
+
+	if len(embedded) > 0 {
+		// https://github.com/uptrace/bun/issues/1095
+		// < v1.2, all fields follow the order corresponding to the struct
+		// >= v1.2, < v1.2.8, fields of nested structs have been moved to the end.
+		// >= v1.2.8, The default behavior remains the same as initially,
+		sortFieldsByStruct(t.allFields)
+		sortFieldsByStruct(t.Fields)
+		sortFieldsByStruct(t.PKs)
+		sortFieldsByStruct(t.DataFields)
+	}
+}
+
+func sortFieldsByStruct(fields []*Field) {
+	sort.Slice(fields, func(i, j int) bool {
+		left, right := fields[i], fields[j]
+		for k := 0; k < len(left.Index) && k < len(right.Index); k++ {
+			if left.Index[k] != right.Index[k] {
+				return left.Index[k] < right.Index[k]
+			}
+		}
+		// NOTE: should not reach
+		return true
+	})
 }
 
 func (t *Table) addUnique(field *Field, prefix string, tagOptions []string) {

vendor/github.com/uptrace/bun/schema/tables.go

@@ -72,7 +72,7 @@ func (t *Tables) InProgress(typ reflect.Type) *Table {
 
 	table := new(Table)
 	t.inProgress[typ] = table
-	table.init(t.dialect, typ, false)
+	table.init(t.dialect, typ)
 
 	return table
 }

vendor/github.com/uptrace/bun/schema/zerochecker.go

@@ -5,7 +5,7 @@ import (
 	"reflect"
 )
 
-var isZeroerType = reflect.TypeOf((*isZeroer)(nil)).Elem()
+var isZeroerType = reflect.TypeFor[isZeroer]()
 
 type isZeroer interface {
 	IsZero() bool