Chore: use any rather than interface{} (#74066)

pkg/util/cmputil/reporter.go

@@ -105,7 +105,7 @@ func (d *Diff) String() string {
 	return fmt.Sprintf("%v:\n\t-: %+v\n\t+: %+v\n", d.Path, describeReflectValue(d.Left), describeReflectValue(d.Right))
 }
 
-func describeReflectValue(v reflect.Value) interface{} {
+func describeReflectValue(v reflect.Value) any {
 	// invalid reflect.Value is produced when two collections (slices\maps) are compared and one misses value.
 	// This way go-cmp indicates that an element was added\removed from a list.
 	if !v.IsValid() {

pkg/util/cmputil/reporter_test.go

@@ -12,7 +12,7 @@ import (
 )
 
 type subStruct struct {
-	Data interface{}
+	Data any
 }
 
 type testStruct struct {

pkg/util/converter/jsonitere/jsonitere.go

@@ -17,7 +17,7 @@ func NewIterator(i *j.Iterator) *Iterator {
 	return &Iterator{i}
 }
 
-func (iter *Iterator) Read() (interface{}, error) {
+func (iter *Iterator) Read() (any, error) {
 	return iter.i.Read(), iter.i.Error
 }
 
@@ -46,7 +46,7 @@ func (iter *Iterator) Skip() error {
 	return iter.i.Error
 }
 
-func (iter *Iterator) ReadVal(obj interface{}) error {
+func (iter *Iterator) ReadVal(obj any) error {
 	iter.i.ReadVal(obj)
 	return iter.i.Error
 }

pkg/util/converter/prom.go

@@ -13,7 +13,7 @@ import (
 )
 
 // helpful while debugging all the options that may appear
-func logf(format string, a ...interface{}) {
+func logf(format string, a ...any) {
 	//fmt.Printf(format, a...)
 }
 
@@ -207,7 +207,7 @@ l1Fields:
 					meta = &data.FrameMeta{}
 					rsp.Frames[0].Meta = meta
 				}
-				meta.Custom = map[string]interface{}{
+				meta.Custom = map[string]any{
 					"stats": v,
 				}
 			}

pkg/util/errutil/errors.go

@@ -170,7 +170,7 @@ func WithPublicMessage(message string) BaseOpt {
 // Errorf creates a new [Error] with Reason and MessageID from [Base],
 // and Message and Underlying will be populated using the rules of
 // [fmt.Errorf].
-func (b Base) Errorf(format string, args ...interface{}) Error {
+func (b Base) Errorf(format string, args ...any) Error {
 	err := fmt.Errorf(format, args...)
 
 	return Error{
@@ -270,7 +270,7 @@ type Error struct {
 	PublicMessage string
 	// PublicPayload provides fields for passing structured data to
 	// construct localized error messages in the client.
-	PublicPayload map[string]interface{}
+	PublicPayload map[string]any
 	// LogLevel provides a suggested level of logging for the error.
 	LogLevel LogLevel
 }
@@ -327,10 +327,10 @@ func (e Error) Is(other error) bool {
 // PublicError is derived from Error and only contains information
 // available to the end user.
 type PublicError struct {
-	StatusCode int                    `json:"statusCode"`
-	MessageID  string                 `json:"messageId"`
-	Message    string                 `json:"message,omitempty"`
-	Extra      map[string]interface{} `json:"extra,omitempty"`
+	StatusCode int            `json:"statusCode"`
+	MessageID  string         `json:"messageId"`
+	Message    string         `json:"message,omitempty"`
+	Extra      map[string]any `json:"extra,omitempty"`
 }
 
 // Public returns a subset of the error with non-sensitive information

pkg/util/errutil/log.go

@@ -17,16 +17,16 @@ const (
 // to avoid having to depend on other packages in the module so that
 // there's no risk of circular dependencies.
 type LogInterface interface {
-	Debug(msg string, ctx ...interface{})
-	Info(msg string, ctx ...interface{})
-	Warn(msg string, ctx ...interface{})
-	Error(msg string, ctx ...interface{})
+	Debug(msg string, ctx ...any)
+	Info(msg string, ctx ...any)
+	Warn(msg string, ctx ...any)
+	Error(msg string, ctx ...any)
 }
 
-func (l LogLevel) LogFunc(logger LogInterface) func(msg string, ctx ...interface{}) {
+func (l LogLevel) LogFunc(logger LogInterface) func(msg string, ctx ...any) {
 	switch l {
 	case LevelNever:
-		return func(_ string, _ ...interface{}) {}
+		return func(_ string, _ ...any) {}
 	case LevelDebug:
 		return logger.Debug
 	case LevelInfo:

pkg/util/errutil/template.go

@@ -17,8 +17,8 @@ type Template struct {
 // TemplateData contains data for constructing an Error based on a
 // Template.
 type TemplateData struct {
-	Private map[string]interface{}
-	Public  map[string]interface{}
+	Private map[string]any
+	Public  map[string]any
 	Error   error
 }
 

pkg/util/errutil/template_test.go

@@ -13,7 +13,7 @@ import (
 func TestTemplate(t *testing.T) {
 	tmpl := errutil.Internal("template.sampleError").MustTemplate("[{{ .Public.user }}] got error: {{ .Error }}")
 	err := tmpl.Build(errutil.TemplateData{
-		Public: map[string]interface{}{
+		Public: map[string]any{
 			"user": "grot the bot",
 		},
 		Error: errors.New("oh noes"),
@@ -35,7 +35,7 @@ func ExampleTemplate() {
 
 	// Construct an error based on the template.
 	err := tmpl.Build(errutil.TemplateData{
-		Public: map[string]interface{}{
+		Public: map[string]any{
 			"user": "grot the bot",
 		},
 		Error: errors.New("oh noes"),
@@ -58,7 +58,7 @@ func ExampleTemplate_public() {
 	// Construct an error based on the template.
 	//nolint:errorlint
 	err := tmpl.Build(errutil.TemplateData{
-		Public: map[string]interface{}{
+		Public: map[string]any{
 			"user": "grot the bot",
 		},
 		Error: errors.New("oh noes"),

pkg/util/json.go

@@ -1,4 +1,4 @@
 package util
 
 // DynMap defines a dynamic map interface.
-type DynMap map[string]interface{}
+type DynMap map[string]any

pkg/util/maputil/maputil.go

@@ -2,9 +2,9 @@ package maputil
 
 import "fmt"
 
-func GetMap(obj map[string]interface{}, key string) (map[string]interface{}, error) {
+func GetMap(obj map[string]any, key string) (map[string]any, error) {
 	if untypedValue, ok := obj[key]; ok {
-		if value, ok := untypedValue.(map[string]interface{}); ok {
+		if value, ok := untypedValue.(map[string]any); ok {
 			return value, nil
 		} else {
 			err := fmt.Errorf("the field '%s' should be an object", key)
@@ -16,7 +16,7 @@ func GetMap(obj map[string]interface{}, key string) (map[string]interface{}, err
 	}
 }
 
-func GetBool(obj map[string]interface{}, key string) (bool, error) {
+func GetBool(obj map[string]any, key string) (bool, error) {
 	if untypedValue, ok := obj[key]; ok {
 		if value, ok := untypedValue.(bool); ok {
 			return value, nil
@@ -30,7 +30,7 @@ func GetBool(obj map[string]interface{}, key string) (bool, error) {
 	}
 }
 
-func GetBoolOptional(obj map[string]interface{}, key string) (bool, error) {
+func GetBoolOptional(obj map[string]any, key string) (bool, error) {
 	if untypedValue, ok := obj[key]; ok {
 		if value, ok := untypedValue.(bool); ok {
 			return value, nil
@@ -44,7 +44,7 @@ func GetBoolOptional(obj map[string]interface{}, key string) (bool, error) {
 	}
 }
 
-func GetString(obj map[string]interface{}, key string) (string, error) {
+func GetString(obj map[string]any, key string) (string, error) {
 	if untypedValue, ok := obj[key]; ok {
 		if value, ok := untypedValue.(string); ok {
 			return value, nil
@@ -58,7 +58,7 @@ func GetString(obj map[string]interface{}, key string) (string, error) {
 	}
 }
 
-func GetStringOptional(obj map[string]interface{}, key string) (string, error) {
+func GetStringOptional(obj map[string]any, key string) (string, error) {
 	if untypedValue, ok := obj[key]; ok {
 		if value, ok := untypedValue.(string); ok {
 			return value, nil

pkg/util/xorm/convert.go

@@ -32,7 +32,7 @@ func cloneBytes(b []byte) []byte {
 	}
 }
 
-func asString(src interface{}) string {
+func asString(src any) string {
 	switch v := src.(type) {
 	case string:
 		return v
@@ -77,7 +77,7 @@ func asBytes(buf []byte, rv reflect.Value) (b []byte, ok bool) {
 // convertAssign copies to dest the value in src, converting it if possible.
 // An error is returned if the copy would result in loss of information.
 // dest should be a pointer type.
-func convertAssign(dest, src interface{}) error {
+func convertAssign(dest, src any) error {
 	// Common cases, without reflect.
 	switch s := src.(type) {
 	case string:
@@ -103,7 +103,7 @@ func convertAssign(dest, src interface{}) error {
 			}
 			*d = string(s)
 			return nil
-		case *interface{}:
+		case *any:
 			if d == nil {
 				return errNilPtr
 			}
@@ -131,7 +131,7 @@ func convertAssign(dest, src interface{}) error {
 		}
 	case nil:
 		switch d := dest.(type) {
-		case *interface{}:
+		case *any:
 			if d == nil {
 				return errNilPtr
 			}
@@ -171,7 +171,7 @@ func convertAssign(dest, src interface{}) error {
 			*d = bv.(bool)
 		}
 		return err
-	case *interface{}:
+	case *any:
 		*d = src
 		return nil
 	}
@@ -248,7 +248,7 @@ func convertAssign(dest, src interface{}) error {
 	return fmt.Errorf("unsupported Scan, storing driver.Value type %T into type %T", src, dest)
 }
 
-func asKind(vv reflect.Value, tp reflect.Type) (interface{}, error) {
+func asKind(vv reflect.Value, tp reflect.Type) (any, error) {
 	switch tp.Kind() {
 	case reflect.Int64:
 		return vv.Int(), nil
@@ -285,7 +285,7 @@ func asKind(vv reflect.Value, tp reflect.Type) (interface{}, error) {
 	return nil, fmt.Errorf("unsupported primary key type: %v, %v", tp, vv)
 }
 
-func convertFloat(v interface{}) (float64, error) {
+func convertFloat(v any) (float64, error) {
 	switch v.(type) {
 	case float32:
 		return float64(v.(float32)), nil
@@ -307,7 +307,7 @@ func convertFloat(v interface{}) (float64, error) {
 	return 0, fmt.Errorf("unsupported type: %v", v)
 }
 
-func convertInt(v interface{}) (int64, error) {
+func convertInt(v any) (int64, error) {
 	switch v.(type) {
 	case int:
 		return int64(v.(int)), nil

pkg/util/xorm/dialect_mysql.go

@@ -283,27 +283,27 @@ func (db *mysql) IndexOnTable() bool {
 	return true
 }
 
-func (db *mysql) IndexCheckSql(tableName, idxName string) (string, []interface{}) {
-	args := []interface{}{db.DbName, tableName, idxName}
+func (db *mysql) IndexCheckSql(tableName, idxName string) (string, []any) {
+	args := []any{db.DbName, tableName, idxName}
 	sql := "SELECT `INDEX_NAME` FROM `INFORMATION_SCHEMA`.`STATISTICS`"
 	sql += " WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ? AND `INDEX_NAME`=?"
 	return sql, args
 }
 
-/*func (db *mysql) ColumnCheckSql(tableName, colName string) (string, []interface{}) {
-	args := []interface{}{db.DbName, tableName, colName}
+/*func (db *mysql) ColumnCheckSql(tableName, colName string) (string, []any) {
+	args := []any{db.DbName, tableName, colName}
 	sql := "SELECT `COLUMN_NAME` FROM `INFORMATION_SCHEMA`.`COLUMNS` WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ? AND `COLUMN_NAME` = ?"
 	return sql, args
 }*/
 
-func (db *mysql) TableCheckSql(tableName string) (string, []interface{}) {
-	args := []interface{}{db.DbName, tableName}
+func (db *mysql) TableCheckSql(tableName string) (string, []any) {
+	args := []any{db.DbName, tableName}
 	sql := "SELECT `TABLE_NAME` from `INFORMATION_SCHEMA`.`TABLES` WHERE `TABLE_SCHEMA`=? and `TABLE_NAME`=?"
 	return sql, args
 }
 
 func (db *mysql) GetColumns(tableName string) ([]string, map[string]*core.Column, error) {
-	args := []interface{}{db.DbName, tableName}
+	args := []any{db.DbName, tableName}
 	s := "SELECT `COLUMN_NAME`, `IS_NULLABLE`, `COLUMN_DEFAULT`, `COLUMN_TYPE`," +
 		" `COLUMN_KEY`, `EXTRA`,`COLUMN_COMMENT` FROM `INFORMATION_SCHEMA`.`COLUMNS` WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ?"
 	db.LogSQL(s, args)
@@ -411,7 +411,7 @@ func (db *mysql) GetColumns(tableName string) ([]string, map[string]*core.Column
 }
 
 func (db *mysql) GetTables() ([]*core.Table, error) {
-	args := []interface{}{db.DbName}
+	args := []any{db.DbName}
 	s := "SELECT `TABLE_NAME`, `ENGINE`, `TABLE_ROWS`, `AUTO_INCREMENT`, `TABLE_COMMENT` from " +
 		"`INFORMATION_SCHEMA`.`TABLES` WHERE `TABLE_SCHEMA`=? AND (`ENGINE`='MyISAM' OR `ENGINE` = 'InnoDB' OR `ENGINE` = 'TokuDB')"
 	db.LogSQL(s, args)
@@ -441,7 +441,7 @@ func (db *mysql) GetTables() ([]*core.Table, error) {
 }
 
 func (db *mysql) GetIndexes(tableName string) (map[string]*core.Index, error) {
-	args := []interface{}{db.DbName, tableName}
+	args := []any{db.DbName, tableName}
 	s := "SELECT `INDEX_NAME`, `NON_UNIQUE`, `COLUMN_NAME` FROM `INFORMATION_SCHEMA`.`STATISTICS` WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ?"
 	db.LogSQL(s, args)
 

pkg/util/xorm/dialect_postgres.go

@@ -879,24 +879,24 @@ func (db *postgres) IndexOnTable() bool {
 	return false
 }
 
-func (db *postgres) IndexCheckSql(tableName, idxName string) (string, []interface{}) {
+func (db *postgres) IndexCheckSql(tableName, idxName string) (string, []any) {
 	if len(db.Schema) == 0 {
-		args := []interface{}{tableName, idxName}
+		args := []any{tableName, idxName}
 		return `SELECT indexname FROM pg_indexes WHERE tablename = ? AND indexname = ?`, args
 	}
 
-	args := []interface{}{db.Schema, tableName, idxName}
+	args := []any{db.Schema, tableName, idxName}
 	return `SELECT indexname FROM pg_indexes ` +
 		`WHERE schemaname = ? AND tablename = ? AND indexname = ?`, args
 }
 
-func (db *postgres) TableCheckSql(tableName string) (string, []interface{}) {
+func (db *postgres) TableCheckSql(tableName string) (string, []any) {
 	if len(db.Schema) == 0 {
-		args := []interface{}{tableName}
+		args := []any{tableName}
 		return `SELECT tablename FROM pg_tables WHERE tablename = ?`, args
 	}
 
-	args := []interface{}{db.Schema, tableName}
+	args := []any{db.Schema, tableName}
 	return `SELECT tablename FROM pg_tables WHERE schemaname = ? AND tablename = ?`, args
 }
 
@@ -931,11 +931,11 @@ func (db *postgres) DropIndexSql(tableName string, index *core.Index) string {
 }
 
 func (db *postgres) IsColumnExist(tableName, colName string) (bool, error) {
-	args := []interface{}{db.Schema, tableName, colName}
+	args := []any{db.Schema, tableName, colName}
 	query := "SELECT column_name FROM INFORMATION_SCHEMA.COLUMNS WHERE table_schema = $1 AND table_name = $2" +
 		" AND column_name = $3"
 	if len(db.Schema) == 0 {
-		args = []interface{}{tableName, colName}
+		args = []any{tableName, colName}
 		query = "SELECT column_name FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name = $1" +
 			" AND column_name = $2"
 	}
@@ -951,7 +951,7 @@ func (db *postgres) IsColumnExist(tableName, colName string) (bool, error) {
 }
 
 func (db *postgres) GetColumns(tableName string) ([]string, map[string]*core.Column, error) {
-	args := []interface{}{tableName}
+	args := []any{tableName}
 	s := `SELECT column_name, column_default, is_nullable, data_type, character_maximum_length,
     CASE WHEN p.contype = 'p' THEN true ELSE false END AS primarykey,
     CASE WHEN p.contype = 'u' THEN true ELSE false END AS uniquekey
@@ -1066,7 +1066,7 @@ WHERE c.relkind = 'r'::char AND c.relname = $1%s AND f.attnum > 0 ORDER BY f.att
 }
 
 func (db *postgres) GetTables() ([]*core.Table, error) {
-	args := []interface{}{}
+	args := []any{}
 	s := "SELECT tablename FROM pg_tables"
 	if len(db.Schema) != 0 {
 		args = append(args, db.Schema)
@@ -1107,7 +1107,7 @@ func getIndexColName(indexdef string) []string {
 }
 
 func (db *postgres) GetIndexes(tableName string) (map[string]*core.Index, error) {
-	args := []interface{}{tableName}
+	args := []any{tableName}
 	s := "SELECT indexname, indexdef FROM pg_indexes WHERE tablename=$1"
 	if len(db.Schema) != 0 {
 		args = append(args, db.Schema)

pkg/util/xorm/dialect_sqlite3.go

@@ -218,13 +218,13 @@ func (db *sqlite3) IndexOnTable() bool {
 	return false
 }
 
-func (db *sqlite3) IndexCheckSql(tableName, idxName string) (string, []interface{}) {
-	args := []interface{}{idxName}
+func (db *sqlite3) IndexCheckSql(tableName, idxName string) (string, []any) {
+	args := []any{idxName}
 	return "SELECT name FROM sqlite_master WHERE type='index' and name = ?", args
 }
 
-func (db *sqlite3) TableCheckSql(tableName string) (string, []interface{}) {
-	args := []interface{}{tableName}
+func (db *sqlite3) TableCheckSql(tableName string) (string, []any) {
+	args := []any{tableName}
 	return "SELECT name FROM sqlite_master WHERE type='table' and name = ?", args
 }
 
@@ -249,7 +249,7 @@ func (db *sqlite3) ForUpdateSql(query string) string {
 }
 
 func (db *sqlite3) IsColumnExist(tableName, colName string) (bool, error) {
-	args := []interface{}{tableName}
+	args := []any{tableName}
 	query := "SELECT name FROM sqlite_master WHERE type='table' and name = ? and ((sql like '%`" + colName + "`%') or (sql like '%[" + colName + "]%'))"
 	db.LogSQL(query, args)
 	rows, err := db.DB().Query(query, args...)
@@ -327,7 +327,7 @@ func parseString(colStr string) (*core.Column, error) {
 }
 
 func (db *sqlite3) GetColumns(tableName string) ([]string, map[string]*core.Column, error) {
-	args := []interface{}{tableName}
+	args := []any{tableName}
 	s := "SELECT sql FROM sqlite_master WHERE type='table' and name = ?"
 	db.LogSQL(s, args)
 	rows, err := db.DB().Query(s, args...)
@@ -384,7 +384,7 @@ func (db *sqlite3) GetColumns(tableName string) ([]string, map[string]*core.Colu
 }
 
 func (db *sqlite3) GetTables() ([]*core.Table, error) {
-	args := []interface{}{}
+	args := []any{}
 	s := "SELECT name FROM sqlite_master WHERE type='table'"
 	db.LogSQL(s, args)
 
@@ -410,7 +410,7 @@ func (db *sqlite3) GetTables() ([]*core.Table, error) {
 }
 
 func (db *sqlite3) GetIndexes(tableName string) (map[string]*core.Index, error) {
-	args := []interface{}{tableName}
+	args := []any{tableName}
 	s := "SELECT sql FROM sqlite_master WHERE type='index' and tbl_name = ?"
 	db.LogSQL(s, args)
 

pkg/util/xorm/engine.go

@@ -253,7 +253,7 @@ func (engine *Engine) Ping() error {
 //	engine.SQL("select * from user").Find(&users)
 //
 // This    code will execute "select * from user" and set the records to users
-func (engine *Engine) SQL(query interface{}, args ...interface{}) *Session {
+func (engine *Engine) SQL(query any, args ...any) *Session {
 	session := engine.NewSession()
 	session.isAutoClose = true
 	return session.SQL(query, args...)
@@ -301,28 +301,28 @@ func (engine *Engine) DBMetas() ([]*core.Table, error) {
 }
 
 // Where method provide a condition query
-func (engine *Engine) Where(query interface{}, args ...interface{}) *Session {
+func (engine *Engine) Where(query any, args ...any) *Session {
 	session := engine.NewSession()
 	session.isAutoClose = true
 	return session.Where(query, args...)
 }
 
 // ID method provoide a condition as (id) = ?
-func (engine *Engine) ID(id interface{}) *Session {
+func (engine *Engine) ID(id any) *Session {
 	session := engine.NewSession()
 	session.isAutoClose = true
 	return session.ID(id)
 }
 
 // Before apply before Processor, affected bean is passed to closure arg
-func (engine *Engine) Before(closures func(interface{})) *Session {
+func (engine *Engine) Before(closures func(any)) *Session {
 	session := engine.NewSession()
 	session.isAutoClose = true
 	return session.Before(closures)
 }
 
 // After apply after insert Processor, affected bean is passed to closure arg
-func (engine *Engine) After(closures func(interface{})) *Session {
+func (engine *Engine) After(closures func(any)) *Session {
 	session := engine.NewSession()
 	session.isAutoClose = true
 	return session.After(closures)
@@ -343,7 +343,7 @@ func (engine *Engine) StoreEngine(storeEngine string) *Session {
 }
 
 // Table temporarily change the Get, Find, Update's table
-func (engine *Engine) Table(tableNameOrBean interface{}) *Session {
+func (engine *Engine) Table(tableNameOrBean any) *Session {
 	session := engine.NewSession()
 	session.isAutoClose = true
 	return session.Table(tableNameOrBean)
@@ -374,7 +374,7 @@ func (engine *Engine) autoMapType(v reflect.Value) (*core.Table, error) {
 }
 
 // GobRegister register one struct to gob for cache use
-func (engine *Engine) GobRegister(v interface{}) *Engine {
+func (engine *Engine) GobRegister(v any) *Engine {
 	gob.Register(v)
 	return engine
 }
@@ -573,7 +573,7 @@ func (engine *Engine) mapType(v reflect.Value) (*core.Table, error) {
 }
 
 // IsTableExist if a table is exist
-func (engine *Engine) IsTableExist(beanOrTableName interface{}) (bool, error) {
+func (engine *Engine) IsTableExist(beanOrTableName any) (bool, error) {
 	session := engine.NewSession()
 	defer session.Close()
 	return session.IsTableExist(beanOrTableName)
@@ -582,7 +582,7 @@ func (engine *Engine) IsTableExist(beanOrTableName interface{}) (bool, error) {
 // Sync the new struct changes to database, this method will automatically add
 // table, column, index, unique. but will not delete or change anything.
 // If you change some field, you should change the database manually.
-func (engine *Engine) Sync(beans ...interface{}) error {
+func (engine *Engine) Sync(beans ...any) error {
 	session := engine.NewSession()
 	defer session.Close()
 
@@ -676,21 +676,21 @@ func (engine *Engine) Sync(beans ...interface{}) error {
 }
 
 // Sync2 synchronize structs to database tables
-func (engine *Engine) Sync2(beans ...interface{}) error {
+func (engine *Engine) Sync2(beans ...any) error {
 	s := engine.NewSession()
 	defer s.Close()
 	return s.Sync2(beans...)
 }
 
 // Exec raw sql
-func (engine *Engine) Exec(sqlOrArgs ...interface{}) (sql.Result, error) {
+func (engine *Engine) Exec(sqlOrArgs ...any) (sql.Result, error) {
 	session := engine.NewSession()
 	defer session.Close()
 	return session.Exec(sqlOrArgs...)
 }
 
 // Insert one or more records
-func (engine *Engine) Insert(beans ...interface{}) (int64, error) {
+func (engine *Engine) Insert(beans ...any) (int64, error) {
 	session := engine.NewSession()
 	defer session.Close()
 	return session.Insert(beans...)
@@ -699,14 +699,14 @@ func (engine *Engine) Insert(beans ...interface{}) (int64, error) {
 // Find retrieve records from table, condiBeans's non-empty fields
 // are conditions. beans could be []Struct, []*Struct, map[int64]Struct
 // map[int64]*Struct
-func (engine *Engine) Find(beans interface{}, condiBeans ...interface{}) error {
+func (engine *Engine) Find(beans any, condiBeans ...any) error {
 	session := engine.NewSession()
 	defer session.Close()
 	return session.Find(beans, condiBeans...)
 }
 
 // nowTime return current time
-func (engine *Engine) nowTime(col *core.Column) (interface{}, time.Time) {
+func (engine *Engine) nowTime(col *core.Column) (any, time.Time) {
 	t := time.Now()
 	var tz = engine.DatabaseTZ
 	if !col.DisableTimeZone && col.TimeZone != nil {
@@ -715,7 +715,7 @@ func (engine *Engine) nowTime(col *core.Column) (interface{}, time.Time) {
 	return engine.formatTime(col.SQLType.Name, t.In(tz)), t.In(engine.TZLocation)
 }
 
-func (engine *Engine) formatColTime(col *core.Column, t time.Time) (v interface{}) {
+func (engine *Engine) formatColTime(col *core.Column, t time.Time) (v any) {
 	if t.IsZero() {
 		if col.Nullable {
 			return nil
@@ -730,7 +730,7 @@ func (engine *Engine) formatColTime(col *core.Column, t time.Time) (v interface{
 }
 
 // formatTime format time as column type
-func (engine *Engine) formatTime(sqlTypeName string, t time.Time) (v interface{}) {
+func (engine *Engine) formatTime(sqlTypeName string, t time.Time) (v any) {
 	switch sqlTypeName {
 	case core.Time:
 		s := t.Format("2006-01-02 15:04:05") // time.RFC3339

pkg/util/xorm/engine_cond.go

@@ -15,7 +15,7 @@ import (
 	"xorm.io/core"
 )
 
-func (engine *Engine) buildConds(table *core.Table, bean interface{},
+func (engine *Engine) buildConds(table *core.Table, bean any,
 	includeVersion bool, includeUpdated bool, includeNil bool,
 	includeAutoIncr bool, allUseBool bool, useAllCols bool, unscoped bool,
 	mustColumnMap map[string]bool, tableName, aliasName string, addedTableName bool) (builder.Cond, error) {
@@ -90,7 +90,7 @@ func (engine *Engine) buildConds(table *core.Table, bean interface{},
 			}
 		}
 
-		var val interface{}
+		var val any
 		switch fieldType.Kind() {
 		case reflect.Bool:
 			if allUseBool || requiredField {

pkg/util/xorm/engine_table.go

@@ -35,7 +35,7 @@ func isSubQuery(tbName string) bool {
 }
 
 // TableName returns table name with schema prefix if has
-func (engine *Engine) TableName(bean interface{}, includeSchema ...bool) string {
+func (engine *Engine) TableName(bean any, includeSchema ...bool) string {
 	tbName := engine.tbNameNoSchema(bean)
 	if len(includeSchema) > 0 && includeSchema[0] && !isSubQuery(tbName) {
 		tbName = engine.tbNameWithSchema(tbName)
@@ -43,7 +43,7 @@ func (engine *Engine) TableName(bean interface{}, includeSchema ...bool) string
 	return tbName
 }
 
-func (engine *Engine) tbNameNoSchema(tablename interface{}) string {
+func (engine *Engine) tbNameNoSchema(tablename any) string {
 	switch tablename.(type) {
 	case []string:
 		t := tablename.([]string)
@@ -52,8 +52,8 @@ func (engine *Engine) tbNameNoSchema(tablename interface{}) string {
 		} else if len(t) == 1 {
 			return engine.Quote(t[0])
 		}
-	case []interface{}:
-		t := tablename.([]interface{})
+	case []any:
+		t := tablename.([]any)
 		l := len(t)
 		var table string
 		if l > 0 {

pkg/util/xorm/helpers.go

@@ -15,7 +15,7 @@ type zeroable interface {
 	IsZero() bool
 }
 
-func isZero(k interface{}) bool {
+func isZero(k any) bool {
 	switch k.(type) {
 	case int:
 		return k.(int) == 0
@@ -121,7 +121,7 @@ func isArrayValueZero(v reflect.Value) bool {
 }
 
 func int64ToIntValue(id int64, tp reflect.Type) reflect.Value {
-	var v interface{}
+	var v any
 	kind := tp.Kind()
 
 	if kind == reflect.Ptr {
@@ -161,11 +161,11 @@ func int64ToIntValue(id int64, tp reflect.Type) reflect.Value {
 	return reflect.ValueOf(v).Elem().Convert(tp)
 }
 
-func int64ToInt(id int64, tp reflect.Type) interface{} {
+func int64ToInt(id int64, tp reflect.Type) any {
 	return int64ToIntValue(id, tp).Interface()
 }
 
-func rValue(bean interface{}) reflect.Value {
+func rValue(bean any) reflect.Value {
 	return reflect.Indirect(reflect.ValueOf(bean))
 }
 

pkg/util/xorm/json.go

@@ -8,8 +8,8 @@ import "encoding/json"
 
 // JSONInterface represents an interface to handle json data
 type JSONInterface interface {
-	Marshal(v interface{}) ([]byte, error)
-	Unmarshal(data []byte, v interface{}) error
+	Marshal(v any) ([]byte, error)
+	Unmarshal(data []byte, v any) error
 }
 
 var (
@@ -21,11 +21,11 @@ var (
 type StdJSON struct{}
 
 // Marshal implements JSONInterface
-func (StdJSON) Marshal(v interface{}) ([]byte, error) {
+func (StdJSON) Marshal(v any) ([]byte, error) {
 	return json.Marshal(v)
 }
 
 // Unmarshal implements JSONInterface
-func (StdJSON) Unmarshal(data []byte, v interface{}) error {
+func (StdJSON) Unmarshal(data []byte, v any) error {
 	return json.Unmarshal(data, v)
 }

pkg/util/xorm/logger.go

@@ -25,28 +25,28 @@ var _ core.ILogger = DiscardLogger{}
 type DiscardLogger struct{}
 
 // Debug empty implementation
-func (DiscardLogger) Debug(v ...interface{}) {}
+func (DiscardLogger) Debug(v ...any) {}
 
 // Debugf empty implementation
-func (DiscardLogger) Debugf(format string, v ...interface{}) {}
+func (DiscardLogger) Debugf(format string, v ...any) {}
 
 // Error empty implementation
-func (DiscardLogger) Error(v ...interface{}) {}
+func (DiscardLogger) Error(v ...any) {}
 
 // Errorf empty implementation
-func (DiscardLogger) Errorf(format string, v ...interface{}) {}
+func (DiscardLogger) Errorf(format string, v ...any) {}
 
 // Info empty implementation
-func (DiscardLogger) Info(v ...interface{}) {}
+func (DiscardLogger) Info(v ...any) {}
 
 // Infof empty implementation
-func (DiscardLogger) Infof(format string, v ...interface{}) {}
+func (DiscardLogger) Infof(format string, v ...any) {}
 
 // Warn empty implementation
-func (DiscardLogger) Warn(v ...interface{}) {}
+func (DiscardLogger) Warn(v ...any) {}
 
 // Warnf empty implementation
-func (DiscardLogger) Warnf(format string, v ...interface{}) {}
+func (DiscardLogger) Warnf(format string, v ...any) {}
 
 // Level empty implementation
 func (DiscardLogger) Level() core.LogLevel {
@@ -88,56 +88,56 @@ func NewSimpleLogger(out io.Writer) *SimpleLogger {
 }
 
 // Error implement core.ILogger
-func (s *SimpleLogger) Error(v ...interface{}) {
+func (s *SimpleLogger) Error(v ...any) {
 	if s.level <= core.LOG_ERR {
 		s.ERR.Output(2, fmt.Sprint(v...))
 	}
 }
 
 // Errorf implement core.ILogger
-func (s *SimpleLogger) Errorf(format string, v ...interface{}) {
+func (s *SimpleLogger) Errorf(format string, v ...any) {
 	if s.level <= core.LOG_ERR {
 		s.ERR.Output(2, fmt.Sprintf(format, v...))
 	}
 }
 
 // Debug implement core.ILogger
-func (s *SimpleLogger) Debug(v ...interface{}) {
+func (s *SimpleLogger) Debug(v ...any) {
 	if s.level <= core.LOG_DEBUG {
 		s.DEBUG.Output(2, fmt.Sprint(v...))
 	}
 }
 
 // Debugf implement core.ILogger
-func (s *SimpleLogger) Debugf(format string, v ...interface{}) {
+func (s *SimpleLogger) Debugf(format string, v ...any) {
 	if s.level <= core.LOG_DEBUG {
 		s.DEBUG.Output(2, fmt.Sprintf(format, v...))
 	}
 }
 
 // Info implement core.ILogger
-func (s *SimpleLogger) Info(v ...interface{}) {
+func (s *SimpleLogger) Info(v ...any) {
 	if s.level <= core.LOG_INFO {
 		s.INFO.Output(2, fmt.Sprint(v...))
 	}
 }
 
 // Infof implement core.ILogger
-func (s *SimpleLogger) Infof(format string, v ...interface{}) {
+func (s *SimpleLogger) Infof(format string, v ...any) {
 	if s.level <= core.LOG_INFO {
 		s.INFO.Output(2, fmt.Sprintf(format, v...))
 	}
 }
 
 // Warn implement core.ILogger
-func (s *SimpleLogger) Warn(v ...interface{}) {
+func (s *SimpleLogger) Warn(v ...any) {
 	if s.level <= core.LOG_WARNING {
 		s.WARN.Output(2, fmt.Sprint(v...))
 	}
 }
 
 // Warnf implement core.ILogger
-func (s *SimpleLogger) Warnf(format string, v ...interface{}) {
+func (s *SimpleLogger) Warnf(format string, v ...any) {
 	if s.level <= core.LOG_WARNING {
 		s.WARN.Output(2, fmt.Sprintf(format, v...))
 	}

pkg/util/xorm/rows.go

@@ -20,13 +20,13 @@ type Rows struct {
 	lastError error
 }
 
-func newRows(session *Session, bean interface{}) (*Rows, error) {
+func newRows(session *Session, bean any) (*Rows, error) {
 	rows := new(Rows)
 	rows.session = session
 	rows.beanType = reflect.Indirect(reflect.ValueOf(bean)).Type()
 
 	var sqlStr string
-	var args []interface{}
+	var args []any
 	var err error
 
 	if err = rows.session.statement.setRefBean(bean); err != nil {
@@ -75,7 +75,7 @@ func (rows *Rows) Err() error {
 }
 
 // Scan row record to bean properties
-func (rows *Rows) Scan(bean interface{}) error {
+func (rows *Rows) Scan(bean any) error {
 	if rows.lastError != nil {
 		return rows.lastError
 	}

pkg/util/xorm/session.go

@@ -32,13 +32,13 @@ type Session struct {
 	autoResetStatement bool
 
 	// !nashtsai! storing these beans due to yet committed tx
-	afterInsertBeans map[interface{}]*[]func(interface{})
-	afterUpdateBeans map[interface{}]*[]func(interface{})
-	afterDeleteBeans map[interface{}]*[]func(interface{})
+	afterInsertBeans map[any]*[]func(any)
+	afterUpdateBeans map[any]*[]func(any)
+	afterDeleteBeans map[any]*[]func(any)
 	// --
 
-	beforeClosures []func(interface{})
-	afterClosures  []func(interface{})
+	beforeClosures []func(any)
+	afterClosures  []func(any)
 
 	afterProcessors []executedProcessor
 
@@ -47,7 +47,7 @@ type Session struct {
 
 	// !evalphobia! stored the last executed query on this session
 	lastSQL     string
-	lastSQLArgs []interface{}
+	lastSQLArgs []any
 	showSQL     bool
 
 	ctx context.Context
@@ -65,17 +65,17 @@ func (session *Session) Init() {
 	session.prepareStmt = false
 
 	// !nashtsai! is lazy init better?
-	session.afterInsertBeans = make(map[interface{}]*[]func(interface{}), 0)
-	session.afterUpdateBeans = make(map[interface{}]*[]func(interface{}), 0)
-	session.afterDeleteBeans = make(map[interface{}]*[]func(interface{}), 0)
-	session.beforeClosures = make([]func(interface{}), 0)
-	session.afterClosures = make([]func(interface{}), 0)
+	session.afterInsertBeans = make(map[any]*[]func(any), 0)
+	session.afterUpdateBeans = make(map[any]*[]func(any), 0)
+	session.afterDeleteBeans = make(map[any]*[]func(any), 0)
+	session.beforeClosures = make([]func(any), 0)
+	session.afterClosures = make([]func(any), 0)
 	session.stmtCache = make(map[uint32]*core.Stmt)
 
 	session.afterProcessors = make([]executedProcessor, 0)
 
 	session.lastSQL = ""
-	session.lastSQLArgs = []interface{}{}
+	session.lastSQLArgs = []any{}
 
 	session.ctx = session.engine.defaultContext
 }
@@ -116,7 +116,7 @@ func (session *Session) Prepare() *Session {
 }
 
 // Before Apply before Processor, affected bean is passed to closure arg
-func (session *Session) Before(closures func(interface{})) *Session {
+func (session *Session) Before(closures func(any)) *Session {
 	if closures != nil {
 		session.beforeClosures = append(session.beforeClosures, closures)
 	}
@@ -124,7 +124,7 @@ func (session *Session) Before(closures func(interface{})) *Session {
 }
 
 // After Apply after Processor, affected bean is passed to closure arg
-func (session *Session) After(closures func(interface{})) *Session {
+func (session *Session) After(closures func(any)) *Session {
 	if closures != nil {
 		session.afterClosures = append(session.afterClosures, closures)
 	}
@@ -132,7 +132,7 @@ func (session *Session) After(closures func(interface{})) *Session {
 }
 
 // Table can input a string or pointer to struct for special a table to operate.
-func (session *Session) Table(tableNameOrBean interface{}) *Session {
+func (session *Session) Table(tableNameOrBean any) *Session {
 	session.statement.Table(tableNameOrBean)
 	return session
 }
@@ -210,7 +210,7 @@ func (session *Session) NoCache() *Session {
 }
 
 // Join join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN
-func (session *Session) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session {
+func (session *Session) Join(joinOperator string, tablename any, condition string, args ...any) *Session {
 	session.statement.Join(joinOperator, tablename, condition, args...)
 	return session
 }
@@ -236,9 +236,9 @@ func (session *Session) DB() *core.DB {
 	return session.db
 }
 
-func cleanupProcessorsClosures(slices *[]func(interface{})) {
+func cleanupProcessorsClosures(slices *[]func(any)) {
 	if len(*slices) > 0 {
-		*slices = make([]func(interface{}), 0)
+		*slices = make([]func(any), 0)
 	}
 }
 
@@ -276,7 +276,7 @@ func (session *Session) getField(dataStruct *reflect.Value, key string, table *c
 }
 
 // Cell cell is a result of one column field
-type Cell *interface{}
+type Cell *any
 
 func (session *Session) rows2Beans(rows *core.Rows, fields []string,
 	table *core.Table, newElemFunc func([]string) reflect.Value,
@@ -296,7 +296,7 @@ func (session *Session) rows2Beans(rows *core.Rows, fields []string,
 			return err
 		}
 		session.afterProcessors = append(session.afterProcessors, executedProcessor{
-			fun: func(*Session, interface{}) error {
+			fun: func(*Session, any) error {
 				return sliceValueSetFunc(&newValue, pk)
 			},
 			session: session,
@@ -306,14 +306,14 @@ func (session *Session) rows2Beans(rows *core.Rows, fields []string,
 	return rows.Err()
 }
 
-func (session *Session) row2Slice(rows *core.Rows, fields []string, bean interface{}) ([]interface{}, error) {
+func (session *Session) row2Slice(rows *core.Rows, fields []string, bean any) ([]any, error) {
 	for _, closure := range session.beforeClosures {
 		closure(bean)
 	}
 
-	scanResults := make([]interface{}, len(fields))
+	scanResults := make([]any, len(fields))
 	for i := 0; i < len(fields); i++ {
-		var cell interface{}
+		var cell any
 		scanResults[i] = &cell
 	}
 	if err := rows.Scan(scanResults...); err != nil {
@@ -322,17 +322,17 @@ func (session *Session) row2Slice(rows *core.Rows, fields []string, bean interfa
 
 	if b, hasBeforeSet := bean.(BeforeSetProcessor); hasBeforeSet {
 		for ii, key := range fields {
-			b.BeforeSet(key, Cell(scanResults[ii].(*interface{})))
+			b.BeforeSet(key, Cell(scanResults[ii].(*any)))
 		}
 	}
 	return scanResults, nil
 }
 
-func (session *Session) slice2Bean(scanResults []interface{}, fields []string, bean interface{}, dataStruct *reflect.Value, table *core.Table) (core.PK, error) {
+func (session *Session) slice2Bean(scanResults []any, fields []string, bean any, dataStruct *reflect.Value, table *core.Table) (core.PK, error) {
 	defer func() {
 		if b, hasAfterSet := bean.(AfterSetProcessor); hasAfterSet {
 			for ii, key := range fields {
-				b.AfterSet(key, Cell(scanResults[ii].(*interface{})))
+				b.AfterSet(key, Cell(scanResults[ii].(*any)))
 			}
 		}
 	}()
@@ -340,7 +340,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 	// handle afterClosures
 	for _, closure := range session.afterClosures {
 		session.afterProcessors = append(session.afterProcessors, executedProcessor{
-			fun: func(sess *Session, bean interface{}) error {
+			fun: func(sess *Session, bean any) error {
 				closure(bean)
 				return nil
 			},
@@ -351,7 +351,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 
 	if a, has := bean.(AfterLoadProcessor); has {
 		session.afterProcessors = append(session.afterProcessors, executedProcessor{
-			fun: func(sess *Session, bean interface{}) error {
+			fun: func(sess *Session, bean any) error {
 				a.AfterLoad()
 				return nil
 			},
@@ -362,7 +362,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 
 	if a, has := bean.(AfterLoadSessionProcessor); has {
 		session.afterProcessors = append(session.afterProcessors, executedProcessor{
-			fun: func(sess *Session, bean interface{}) error {
+			fun: func(sess *Session, bean any) error {
 				a.AfterLoad(sess)
 				return nil
 			},
@@ -771,13 +771,13 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 }
 
 // saveLastSQL stores executed query information
-func (session *Session) saveLastSQL(sql string, args ...interface{}) {
+func (session *Session) saveLastSQL(sql string, args ...any) {
 	session.lastSQL = sql
 	session.lastSQLArgs = args
 	session.logSQL(sql, args...)
 }
 
-func (session *Session) logSQL(sqlStr string, sqlArgs ...interface{}) {
+func (session *Session) logSQL(sqlStr string, sqlArgs ...any) {
 	if session.showSQL && !session.engine.showExecTime {
 		if len(sqlArgs) > 0 {
 			session.engine.logger.Infof("[SQL] %v %#v", sqlStr, sqlArgs)
@@ -788,7 +788,7 @@ func (session *Session) logSQL(sqlStr string, sqlArgs ...interface{}) {
 }
 
 // LastSQL returns last query information
-func (session *Session) LastSQL() (string, []interface{}) {
+func (session *Session) LastSQL() (string, []any) {
 	return session.lastSQL, session.lastSQLArgs
 }
 

pkg/util/xorm/session_cols.go

@@ -12,7 +12,7 @@ import (
 	"xorm.io/core"
 )
 
-func setColumnInt(bean interface{}, col *core.Column, t int64) {
+func setColumnInt(bean any, col *core.Column, t int64) {
 	v, err := col.ValueOf(bean)
 	if err != nil {
 		return
@@ -27,7 +27,7 @@ func setColumnInt(bean interface{}, col *core.Column, t int64) {
 	}
 }
 
-func setColumnTime(bean interface{}, col *core.Column, t time.Time) {
+func setColumnTime(bean any, col *core.Column, t time.Time) {
 	v, err := col.ValueOf(bean)
 	if err != nil {
 		return

pkg/util/xorm/session_cond.go

@@ -10,31 +10,31 @@ import "xorm.io/builder"
 // and cannot use Where, Id, In and etc. Methods to describe, you can use SQL.
 //
 // Deprecated: use SQL instead.
-func (session *Session) Sql(query string, args ...interface{}) *Session {
+func (session *Session) Sql(query string, args ...any) *Session {
 	return session.SQL(query, args...)
 }
 
 // SQL provides raw sql input parameter. When you have a complex SQL statement
 // and cannot use Where, Id, In and etc. Methods to describe, you can use SQL.
-func (session *Session) SQL(query interface{}, args ...interface{}) *Session {
+func (session *Session) SQL(query any, args ...any) *Session {
 	session.statement.SQL(query, args...)
 	return session
 }
 
 // Where provides custom query condition.
-func (session *Session) Where(query interface{}, args ...interface{}) *Session {
+func (session *Session) Where(query any, args ...any) *Session {
 	session.statement.Where(query, args...)
 	return session
 }
 
 // And provides custom query condition.
-func (session *Session) And(query interface{}, args ...interface{}) *Session {
+func (session *Session) And(query any, args ...any) *Session {
 	session.statement.And(query, args...)
 	return session
 }
 
 // Or provides custom query condition.
-func (session *Session) Or(query interface{}, args ...interface{}) *Session {
+func (session *Session) Or(query any, args ...any) *Session {
 	session.statement.Or(query, args...)
 	return session
 }
@@ -42,24 +42,24 @@ func (session *Session) Or(query interface{}, args ...interface{}) *Session {
 // Id provides converting id as a query condition
 //
 // Deprecated: use ID instead
-func (session *Session) Id(id interface{}) *Session {
+func (session *Session) Id(id any) *Session {
 	return session.ID(id)
 }
 
 // ID provides converting id as a query condition
-func (session *Session) ID(id interface{}) *Session {
+func (session *Session) ID(id any) *Session {
 	session.statement.ID(id)
 	return session
 }
 
 // In provides a query string like "id in (1, 2, 3)"
-func (session *Session) In(column string, args ...interface{}) *Session {
+func (session *Session) In(column string, args ...any) *Session {
 	session.statement.In(column, args...)
 	return session
 }
 
 // NotIn provides a query string like "id in (1, 2, 3)"
-func (session *Session) NotIn(column string, args ...interface{}) *Session {
+func (session *Session) NotIn(column string, args ...any) *Session {
 	session.statement.NotIn(column, args...)
 	return session
 }

pkg/util/xorm/session_convert.go

@@ -102,7 +102,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 		return structConvert.FromDB(data)
 	}
 
-	var v interface{}
+	var v any
 	key := col.Name
 	fieldType := fieldValue.Type()
 
@@ -471,7 +471,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 }
 
 // convert a field value of a struct to interface for put into db
-func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Value) (interface{}, error) {
+func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Value) (any, error) {
 	if fieldValue.CanAddr() {
 		if fieldConvert, ok := fieldValue.Addr().Interface().(core.Conversion); ok {
 			data, err := fieldConvert.ToDB()

pkg/util/xorm/session_delete.go

@@ -11,7 +11,7 @@ import (
 )
 
 // Delete records, bean's non-empty fields are conditions
-func (session *Session) Delete(bean interface{}) (int64, error) {
+func (session *Session) Delete(bean any) (int64, error) {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -30,7 +30,7 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 	}
 	cleanupProcessorsClosures(&session.beforeClosures)
 
-	if processor, ok := interface{}(bean).(BeforeDeleteProcessor); ok {
+	if processor, ok := any(bean).(BeforeDeleteProcessor); ok {
 		processor.BeforeDelete()
 	}
 
@@ -124,7 +124,7 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 		condArgs[0] = val
 
 		var colName = deletedColumn.Name
-		session.afterClosures = append(session.afterClosures, func(bean interface{}) {
+		session.afterClosures = append(session.afterClosures, func(bean any) {
 			col := table.GetColumn(colName)
 			setColumnTime(bean, col, t)
 		})
@@ -140,7 +140,7 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 		for _, closure := range session.afterClosures {
 			closure(bean)
 		}
-		if processor, ok := interface{}(bean).(AfterDeleteProcessor); ok {
+		if processor, ok := any(bean).(AfterDeleteProcessor); ok {
 			processor.AfterDelete()
 		}
 	} else {
@@ -149,12 +149,12 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 			if value, has := session.afterDeleteBeans[bean]; has && value != nil {
 				*value = append(*value, session.afterClosures...)
 			} else {
-				afterClosures := make([]func(interface{}), lenAfterClosures)
+				afterClosures := make([]func(any), lenAfterClosures)
 				copy(afterClosures, session.afterClosures)
 				session.afterDeleteBeans[bean] = &afterClosures
 			}
 		} else {
-			if _, ok := interface{}(bean).(AfterDeleteProcessor); ok {
+			if _, ok := any(bean).(AfterDeleteProcessor); ok {
 				session.afterDeleteBeans[bean] = nil
 			}
 		}

pkg/util/xorm/session_exist.go

@@ -14,7 +14,7 @@ import (
 )
 
 // Exist returns true if the record exist otherwise return false
-func (session *Session) Exist(bean ...interface{}) (bool, error) {
+func (session *Session) Exist(bean ...any) (bool, error) {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -24,7 +24,7 @@ func (session *Session) Exist(bean ...interface{}) (bool, error) {
 	}
 
 	var sqlStr string
-	var args []interface{}
+	var args []any
 	var joinStr string
 	var err error
 	if session.statement.RawSQL == "" {
@@ -57,7 +57,7 @@ func (session *Session) Exist(bean ...interface{}) (bool, error) {
 				} else {
 					sqlStr = fmt.Sprintf("SELECT * FROM %s %s LIMIT 1", tableName, joinStr)
 				}
-				args = []interface{}{}
+				args = []any{}
 			}
 		} else {
 			beanValue := reflect.ValueOf(bean[0])

pkg/util/xorm/session_find.go

@@ -21,7 +21,7 @@ const (
 // Find retrieve records from table, condiBeans's non-empty fields
 // are conditions. beans could be []Struct, []*Struct, map[int64]Struct
 // map[int64]*Struct
-func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{}) error {
+func (session *Session) Find(rowsSlicePtr any, condiBean ...any) error {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -29,7 +29,7 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
 }
 
 // FindAndCount find the results and also return the counts
-func (session *Session) FindAndCount(rowsSlicePtr interface{}, condiBean ...interface{}) (int64, error) {
+func (session *Session) FindAndCount(rowsSlicePtr any, condiBean ...any) (int64, error) {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -61,7 +61,7 @@ func (session *Session) FindAndCount(rowsSlicePtr interface{}, condiBean ...inte
 	return session.Count(reflect.New(sliceElementType).Interface())
 }
 
-func (session *Session) find(rowsSlicePtr interface{}, condiBean ...interface{}) error {
+func (session *Session) find(rowsSlicePtr any, condiBean ...any) error {
 	defer session.resetStatement()
 
 	if session.statement.lastError != nil {
@@ -126,7 +126,7 @@ func (session *Session) find(rowsSlicePtr interface{}, condiBean ...interface{})
 	}
 
 	var sqlStr string
-	var args []interface{}
+	var args []any
 	// var err error
 	if session.statement.RawSQL == "" {
 		if len(session.statement.TableName()) <= 0 {
@@ -183,7 +183,7 @@ func (session *Session) find(rowsSlicePtr interface{}, condiBean ...interface{})
 	return session.noCacheFind(table, sliceValue, sqlStr, args...)
 }
 
-func (session *Session) noCacheFind(table *core.Table, containerValue reflect.Value, sqlStr string, args ...interface{}) error {
+func (session *Session) noCacheFind(table *core.Table, containerValue reflect.Value, sqlStr string, args ...any) error {
 	rows, err := session.queryRows(sqlStr, args...)
 	if err != nil {
 		return err
@@ -296,7 +296,7 @@ func (session *Session) noCacheFind(table *core.Table, containerValue reflect.Va
 	return rows.Err()
 }
 
-func convertPKToValue(table *core.Table, dst interface{}, pk core.PK) error {
+func convertPKToValue(table *core.Table, dst any, pk core.PK) error {
 	cols := table.PKColumns()
 	if len(cols) == 1 {
 		return convertAssign(dst, pk[0])

pkg/util/xorm/session_get.go

@@ -14,14 +14,14 @@ import (
 
 // Get retrieve one record from database, bean's non-empty fields
 // will be as conditions
-func (session *Session) Get(bean interface{}) (bool, error) {
+func (session *Session) Get(bean any) (bool, error) {
 	if session.isAutoClose {
 		defer session.Close()
 	}
 	return session.get(bean)
 }
 
-func (session *Session) get(bean interface{}) (bool, error) {
+func (session *Session) get(bean any) (bool, error) {
 	defer session.resetStatement()
 
 	if session.statement.lastError != nil {
@@ -42,7 +42,7 @@ func (session *Session) get(bean interface{}) (bool, error) {
 	}
 
 	var sqlStr string
-	var args []interface{}
+	var args []any
 	var err error
 
 	if session.statement.RawSQL == "" {
@@ -69,7 +69,7 @@ func (session *Session) get(bean interface{}) (bool, error) {
 	return true, nil
 }
 
-func (session *Session) nocacheGet(beanKind reflect.Kind, table *core.Table, bean interface{}, sqlStr string, args ...interface{}) (bool, error) {
+func (session *Session) nocacheGet(beanKind reflect.Kind, table *core.Table, bean any, sqlStr string, args ...any) (bool, error) {
 	rows, err := session.queryRows(sqlStr, args...)
 	if err != nil {
 		return false, err

pkg/util/xorm/session_insert.go

@@ -20,7 +20,7 @@ import (
 var ErrNoElementsOnSlice = errors.New("no element on slice when insert")
 
 // Insert insert one or more beans
-func (session *Session) Insert(beans ...interface{}) (int64, error) {
+func (session *Session) Insert(beans ...any) (int64, error) {
 	var affected int64
 	var err error
 
@@ -36,13 +36,13 @@ func (session *Session) Insert(beans ...interface{}) (int64, error) {
 
 	for _, bean := range beans {
 		switch bean := bean.(type) {
-		case map[string]interface{}:
+		case map[string]any:
 			cnt, err := session.insertMapInterface(bean)
 			if err != nil {
 				return affected, err
 			}
 			affected += cnt
-		case []map[string]interface{}:
+		case []map[string]any:
 			for i := 0; i < len(bean); i++ {
 				cnt, err := session.insertMapInterface(bean[i])
 				if err != nil {
@@ -100,7 +100,7 @@ func (session *Session) Insert(beans ...interface{}) (int64, error) {
 	return affected, err
 }
 
-func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error) {
+func (session *Session) innerInsertMulti(rowsSlicePtr any) (int64, error) {
 	sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr))
 	if sliceValue.Kind() != reflect.Slice {
 		return 0, errors.New("needs a pointer to a slice")
@@ -124,7 +124,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 
 	var colNames []string
 	var colMultiPlaces []string
-	var args []interface{}
+	var args []any
 	var cols []*core.Column
 
 	for i := 0; i < size; i++ {
@@ -139,7 +139,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 			closure(elemValue)
 		}
 
-		if processor, ok := interface{}(elemValue).(BeforeInsertProcessor); ok {
+		if processor, ok := any(elemValue).(BeforeInsertProcessor); ok {
 			processor.BeforeInsert()
 		}
 
@@ -170,14 +170,14 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 					args = append(args, val)
 
 					var colName = col.Name
-					session.afterClosures = append(session.afterClosures, func(bean interface{}) {
+					session.afterClosures = append(session.afterClosures, func(bean any) {
 						col := table.GetColumn(colName)
 						setColumnTime(bean, col, t)
 					})
 				} else if col.IsVersion && session.statement.checkVersion {
 					args = append(args, 1)
 					var colName = col.Name
-					session.afterClosures = append(session.afterClosures, func(bean interface{}) {
+					session.afterClosures = append(session.afterClosures, func(bean any) {
 						col := table.GetColumn(colName)
 						setColumnInt(bean, col, 1)
 					})
@@ -221,14 +221,14 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 					args = append(args, val)
 
 					var colName = col.Name
-					session.afterClosures = append(session.afterClosures, func(bean interface{}) {
+					session.afterClosures = append(session.afterClosures, func(bean any) {
 						col := table.GetColumn(colName)
 						setColumnTime(bean, col, t)
 					})
 				} else if col.IsVersion && session.statement.checkVersion {
 					args = append(args, 1)
 					var colName = col.Name
-					session.afterClosures = append(session.afterClosures, func(bean interface{}) {
+					session.afterClosures = append(session.afterClosures, func(bean any) {
 						col := table.GetColumn(colName)
 						setColumnInt(bean, col, 1)
 					})
@@ -277,7 +277,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 			for _, closure := range session.afterClosures {
 				closure(elemValue)
 			}
-			if processor, ok := interface{}(elemValue).(AfterInsertProcessor); ok {
+			if processor, ok := any(elemValue).(AfterInsertProcessor); ok {
 				processor.AfterInsert()
 			}
 		} else {
@@ -285,12 +285,12 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 				if value, has := session.afterInsertBeans[elemValue]; has && value != nil {
 					*value = append(*value, session.afterClosures...)
 				} else {
-					afterClosures := make([]func(interface{}), lenAfterClosures)
+					afterClosures := make([]func(any), lenAfterClosures)
 					copy(afterClosures, session.afterClosures)
 					session.afterInsertBeans[elemValue] = &afterClosures
 				}
 			} else {
-				if _, ok := interface{}(elemValue).(AfterInsertProcessor); ok {
+				if _, ok := any(elemValue).(AfterInsertProcessor); ok {
 					session.afterInsertBeans[elemValue] = nil
 				}
 			}
@@ -302,7 +302,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 }
 
 // InsertMulti insert multiple records
-func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error) {
+func (session *Session) InsertMulti(rowsSlicePtr any) (int64, error) {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -320,7 +320,7 @@ func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error) {
 	return session.innerInsertMulti(rowsSlicePtr)
 }
 
-func (session *Session) innerInsert(bean interface{}) (int64, error) {
+func (session *Session) innerInsert(bean any) (int64, error) {
 	if err := session.statement.setRefBean(bean); err != nil {
 		return 0, err
 	}
@@ -336,7 +336,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 	}
 	cleanupProcessorsClosures(&session.beforeClosures) // cleanup after used
 
-	if processor, ok := interface{}(bean).(BeforeInsertProcessor); ok {
+	if processor, ok := any(bean).(BeforeInsertProcessor); ok {
 		processor.BeforeInsert()
 	}
 
@@ -431,12 +431,12 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 	sqlStr := buf.String()
 	args = buf.Args()
 
-	handleAfterInsertProcessorFunc := func(bean interface{}) {
+	handleAfterInsertProcessorFunc := func(bean any) {
 		if session.isAutoCommit {
 			for _, closure := range session.afterClosures {
 				closure(bean)
 			}
-			if processor, ok := interface{}(bean).(AfterInsertProcessor); ok {
+			if processor, ok := any(bean).(AfterInsertProcessor); ok {
 				processor.AfterInsert()
 			}
 		} else {
@@ -445,13 +445,13 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 				if value, has := session.afterInsertBeans[bean]; has && value != nil {
 					*value = append(*value, session.afterClosures...)
 				} else {
-					afterClosures := make([]func(interface{}), lenAfterClosures)
+					afterClosures := make([]func(any), lenAfterClosures)
 					copy(afterClosures, session.afterClosures)
 					session.afterInsertBeans[bean] = &afterClosures
 				}
 
 			} else {
-				if _, ok := interface{}(bean).(AfterInsertProcessor); ok {
+				if _, ok := any(bean).(AfterInsertProcessor); ok {
 					session.afterInsertBeans[bean] = nil
 				}
 			}
@@ -584,7 +584,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 // InsertOne insert only one struct into database as a record.
 // The in parameter bean must a struct or a point to struct. The return
 // parameter is inserted and error
-func (session *Session) InsertOne(bean interface{}) (int64, error) {
+func (session *Session) InsertOne(bean any) (int64, error) {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -593,10 +593,10 @@ func (session *Session) InsertOne(bean interface{}) (int64, error) {
 }
 
 // genInsertColumns generates insert needed columns
-func (session *Session) genInsertColumns(bean interface{}) ([]string, []interface{}, error) {
+func (session *Session) genInsertColumns(bean any) ([]string, []any, error) {
 	table := session.statement.RefTable
 	colNames := make([]string, 0, len(table.ColumnsSeq()))
-	args := make([]interface{}, 0, len(table.ColumnsSeq()))
+	args := make([]any, 0, len(table.ColumnsSeq()))
 
 	for _, col := range table.Columns() {
 		if col.MapType == core.ONLYFROMDB {
@@ -664,7 +664,7 @@ func (session *Session) genInsertColumns(bean interface{}) ([]string, []interfac
 			args = append(args, val)
 
 			var colName = col.Name
-			session.afterClosures = append(session.afterClosures, func(bean interface{}) {
+			session.afterClosures = append(session.afterClosures, func(bean any) {
 				col := table.GetColumn(colName)
 				setColumnTime(bean, col, t)
 			})
@@ -683,7 +683,7 @@ func (session *Session) genInsertColumns(bean interface{}) ([]string, []interfac
 	return colNames, args, nil
 }
 
-func (session *Session) insertMapInterface(m map[string]interface{}) (int64, error) {
+func (session *Session) insertMapInterface(m map[string]any) (int64, error) {
 	if len(m) == 0 {
 		return 0, ErrParamsType
 	}
@@ -702,7 +702,7 @@ func (session *Session) insertMapInterface(m map[string]interface{}) (int64, err
 	}
 	sort.Strings(columns)
 
-	var args = make([]interface{}, 0, len(m))
+	var args = make([]any, 0, len(m))
 	for _, colName := range columns {
 		args = append(args, m[colName])
 	}
@@ -730,7 +730,7 @@ func (session *Session) insertMapString(m map[string]string) (int64, error) {
 
 	sort.Strings(columns)
 
-	var args = make([]interface{}, 0, len(m))
+	var args = make([]any, 0, len(m))
 	for _, colName := range columns {
 		args = append(args, m[colName])
 	}
@@ -738,7 +738,7 @@ func (session *Session) insertMapString(m map[string]string) (int64, error) {
 	return session.insertMap(columns, args)
 }
 
-func (session *Session) insertMap(columns []string, args []interface{}) (int64, error) {
+func (session *Session) insertMap(columns []string, args []any) (int64, error) {
 	tableName := session.statement.TableName()
 	if len(tableName) <= 0 {
 		return 0, ErrTableNotFound

pkg/util/xorm/session_raw.go

@@ -13,7 +13,7 @@ import (
 	"xorm.io/core"
 )
 
-func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{}) {
+func (session *Session) queryPreprocess(sqlStr *string, paramStr ...any) {
 	for _, filter := range session.engine.dialect.Filters() {
 		*sqlStr = filter.Do(*sqlStr, session.engine.dialect, session.statement.RefTable)
 	}
@@ -22,7 +22,7 @@ func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{})
 	session.lastSQLArgs = paramStr
 }
 
-func (session *Session) queryRows(sqlStr string, args ...interface{}) (*core.Rows, error) {
+func (session *Session) queryRows(sqlStr string, args ...any) (*core.Rows, error) {
 	defer session.resetStatement()
 
 	session.queryPreprocess(&sqlStr, args...)
@@ -79,7 +79,7 @@ func (session *Session) queryRows(sqlStr string, args ...interface{}) (*core.Row
 	return rows, nil
 }
 
-func (session *Session) queryRow(sqlStr string, args ...interface{}) *core.Row {
+func (session *Session) queryRow(sqlStr string, args ...any) *core.Row {
 	return core.NewRow(session.queryRows(sqlStr, args...))
 }
 
@@ -93,9 +93,9 @@ func value2Bytes(rawValue *reflect.Value) ([]byte, error) {
 
 func row2map(rows *core.Rows, fields []string) (resultsMap map[string][]byte, err error) {
 	result := make(map[string][]byte)
-	scanResultContainers := make([]interface{}, len(fields))
+	scanResultContainers := make([]any, len(fields))
 	for i := 0; i < len(fields); i++ {
-		var scanResultContainer interface{}
+		var scanResultContainer any
 		scanResultContainers[i] = &scanResultContainer
 	}
 	if err := rows.Scan(scanResultContainers...); err != nil {
@@ -135,7 +135,7 @@ func rows2maps(rows *core.Rows) (resultsSlice []map[string][]byte, err error) {
 	return resultsSlice, nil
 }
 
-func (session *Session) queryBytes(sqlStr string, args ...interface{}) ([]map[string][]byte, error) {
+func (session *Session) queryBytes(sqlStr string, args ...any) ([]map[string][]byte, error) {
 	rows, err := session.queryRows(sqlStr, args...)
 	if err != nil {
 		return nil, err
@@ -145,7 +145,7 @@ func (session *Session) queryBytes(sqlStr string, args ...interface{}) ([]map[st
 	return rows2maps(rows)
 }
 
-func (session *Session) exec(sqlStr string, args ...interface{}) (sql.Result, error) {
+func (session *Session) exec(sqlStr string, args ...any) (sql.Result, error) {
 	defer session.resetStatement()
 
 	session.queryPreprocess(&sqlStr, args...)
@@ -190,7 +190,7 @@ func (session *Session) exec(sqlStr string, args ...interface{}) (sql.Result, er
 	return session.DB().ExecContext(session.ctx, sqlStr, args...)
 }
 
-func convertSQLOrArgs(sqlOrArgs ...interface{}) (string, []interface{}, error) {
+func convertSQLOrArgs(sqlOrArgs ...any) (string, []any, error) {
 	switch sqlOrArgs[0].(type) {
 	case string:
 		return sqlOrArgs[0].(string), sqlOrArgs[1:], nil
@@ -205,7 +205,7 @@ func convertSQLOrArgs(sqlOrArgs ...interface{}) (string, []interface{}, error) {
 }
 
 // Exec raw sql
-func (session *Session) Exec(sqlOrArgs ...interface{}) (sql.Result, error) {
+func (session *Session) Exec(sqlOrArgs ...any) (sql.Result, error) {
 	if session.isAutoClose {
 		defer session.Close()
 	}

pkg/util/xorm/session_schema.go

@@ -23,7 +23,7 @@ func (session *Session) Ping() error {
 }
 
 // CreateTable create a table according a bean
-func (session *Session) CreateTable(bean interface{}) error {
+func (session *Session) CreateTable(bean any) error {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -31,7 +31,7 @@ func (session *Session) CreateTable(bean interface{}) error {
 	return session.createTable(bean)
 }
 
-func (session *Session) createTable(bean interface{}) error {
+func (session *Session) createTable(bean any) error {
 	if err := session.statement.setRefBean(bean); err != nil {
 		return err
 	}
@@ -42,7 +42,7 @@ func (session *Session) createTable(bean interface{}) error {
 }
 
 // CreateIndexes create indexes
-func (session *Session) CreateIndexes(bean interface{}) error {
+func (session *Session) CreateIndexes(bean any) error {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -50,7 +50,7 @@ func (session *Session) CreateIndexes(bean interface{}) error {
 	return session.createIndexes(bean)
 }
 
-func (session *Session) createIndexes(bean interface{}) error {
+func (session *Session) createIndexes(bean any) error {
 	if err := session.statement.setRefBean(bean); err != nil {
 		return err
 	}
@@ -66,14 +66,14 @@ func (session *Session) createIndexes(bean interface{}) error {
 }
 
 // CreateUniques create uniques
-func (session *Session) CreateUniques(bean interface{}) error {
+func (session *Session) CreateUniques(bean any) error {
 	if session.isAutoClose {
 		defer session.Close()
 	}
 	return session.createUniques(bean)
 }
 
-func (session *Session) createUniques(bean interface{}) error {
+func (session *Session) createUniques(bean any) error {
 	if err := session.statement.setRefBean(bean); err != nil {
 		return err
 	}
@@ -89,7 +89,7 @@ func (session *Session) createUniques(bean interface{}) error {
 }
 
 // DropIndexes drop indexes
-func (session *Session) DropIndexes(bean interface{}) error {
+func (session *Session) DropIndexes(bean any) error {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -97,7 +97,7 @@ func (session *Session) DropIndexes(bean interface{}) error {
 	return session.dropIndexes(bean)
 }
 
-func (session *Session) dropIndexes(bean interface{}) error {
+func (session *Session) dropIndexes(bean any) error {
 	if err := session.statement.setRefBean(bean); err != nil {
 		return err
 	}
@@ -113,7 +113,7 @@ func (session *Session) dropIndexes(bean interface{}) error {
 }
 
 // DropTable drop table will drop table if exist, if drop failed, it will return error
-func (session *Session) DropTable(beanOrTableName interface{}) error {
+func (session *Session) DropTable(beanOrTableName any) error {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -121,7 +121,7 @@ func (session *Session) DropTable(beanOrTableName interface{}) error {
 	return session.dropTable(beanOrTableName)
 }
 
-func (session *Session) dropTable(beanOrTableName interface{}) error {
+func (session *Session) dropTable(beanOrTableName any) error {
 	tableName := session.engine.TableName(beanOrTableName)
 	var needDrop = true
 	if !session.engine.dialect.SupportDropIfExists() {
@@ -142,7 +142,7 @@ func (session *Session) dropTable(beanOrTableName interface{}) error {
 }
 
 // IsTableExist if a table is exist
-func (session *Session) IsTableExist(beanOrTableName interface{}) (bool, error) {
+func (session *Session) IsTableExist(beanOrTableName any) (bool, error) {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -159,7 +159,7 @@ func (session *Session) isTableExist(tableName string) (bool, error) {
 }
 
 // IsTableEmpty if table have any records
-func (session *Session) IsTableEmpty(bean interface{}) (bool, error) {
+func (session *Session) IsTableEmpty(bean any) (bool, error) {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -220,7 +220,7 @@ func (session *Session) addUnique(tableName, uqeName string) error {
 }
 
 // Sync2 synchronize structs to database tables
-func (session *Session) Sync2(beans ...interface{}) error {
+func (session *Session) Sync2(beans ...any) error {
 	engine := session.engine
 
 	if session.isAutoClose {

pkg/util/xorm/session_tx.go

@@ -39,7 +39,7 @@ func (session *Session) Commit() error {
 		var err error
 		if err = session.tx.Commit(); err == nil {
 			// handle processors after tx committed
-			closureCallFunc := func(closuresPtr *[]func(interface{}), bean interface{}) {
+			closureCallFunc := func(closuresPtr *[]func(any), bean any) {
 				if closuresPtr != nil {
 					for _, closure := range *closuresPtr {
 						closure(bean)
@@ -50,27 +50,27 @@ func (session *Session) Commit() error {
 			for bean, closuresPtr := range session.afterInsertBeans {
 				closureCallFunc(closuresPtr, bean)
 
-				if processor, ok := interface{}(bean).(AfterInsertProcessor); ok {
+				if processor, ok := any(bean).(AfterInsertProcessor); ok {
 					processor.AfterInsert()
 				}
 			}
 			for bean, closuresPtr := range session.afterUpdateBeans {
 				closureCallFunc(closuresPtr, bean)
 
-				if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
+				if processor, ok := any(bean).(AfterUpdateProcessor); ok {
 					processor.AfterUpdate()
 				}
 			}
 			for bean, closuresPtr := range session.afterDeleteBeans {
 				closureCallFunc(closuresPtr, bean)
 
-				if processor, ok := interface{}(bean).(AfterDeleteProcessor); ok {
+				if processor, ok := any(bean).(AfterDeleteProcessor); ok {
 					processor.AfterDelete()
 				}
 			}
-			cleanUpFunc := func(slices *map[interface{}]*[]func(interface{})) {
+			cleanUpFunc := func(slices *map[any]*[]func(any)) {
 				if len(*slices) > 0 {
-					*slices = make(map[interface{}]*[]func(interface{}), 0)
+					*slices = make(map[any]*[]func(any), 0)
 				}
 			}
 			cleanUpFunc(&session.afterInsertBeans)

pkg/util/xorm/session_update.go

@@ -21,7 +21,7 @@ import (
 //	1.bool will defaultly be updated content nor conditions
 //	 You should call UseBool if you have bool to use.
 //	2.float32 & float64 may be not inexact as conditions
-func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int64, error) {
+func (session *Session) Update(bean any, condiBean ...any) (int64, error) {
 	if session.isAutoClose {
 		defer session.Close()
 	}
@@ -34,14 +34,14 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 	t := v.Type()
 
 	var colNames []string
-	var args []interface{}
+	var args []any
 
 	// handle before update processors
 	for _, closure := range session.beforeClosures {
 		closure(bean)
 	}
 	cleanupProcessorsClosures(&session.beforeClosures) // cleanup after used
-	if processor, ok := interface{}(bean).(BeforeUpdateProcessor); ok {
+	if processor, ok := any(bean).(BeforeUpdateProcessor); ok {
 		processor.BeforeUpdate()
 	}
 	// --
@@ -69,7 +69,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 		}
 	} else if isMap {
 		colNames = make([]string, 0)
-		args = make([]interface{}, 0)
+		args = make([]any, 0)
 		bValue := reflect.Indirect(reflect.ValueOf(bean))
 
 		for _, v := range bValue.MapKeys() {
@@ -92,7 +92,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 
 			var colName = col.Name
 			if isStruct {
-				session.afterClosures = append(session.afterClosures, func(bean interface{}) {
+				session.afterClosures = append(session.afterClosures, func(bean any) {
 					col := table.GetColumn(colName)
 					setColumnTime(bean, col, t)
 				})
@@ -142,7 +142,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 	if !session.statement.noAutoCondition {
 		condBeanIsStruct := false
 		if len(condiBean) > 0 {
-			if c, ok := condiBean[0].(map[string]interface{}); ok {
+			if c, ok := condiBean[0].(map[string]any); ok {
 				autoCond = builder.Eq(c)
 			} else {
 				ct := reflect.TypeOf(condiBean[0])
@@ -180,7 +180,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 
 	var (
 		sqlStr   string
-		condArgs []interface{}
+		condArgs []any
 		condSQL  string
 		cond     = session.statement.cond.And(autoCond)
 
@@ -276,7 +276,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 		for _, closure := range session.afterClosures {
 			closure(bean)
 		}
-		if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
+		if processor, ok := any(bean).(AfterUpdateProcessor); ok {
 			session.engine.logger.Debug("[event]", tableName, " has after update processor")
 			processor.AfterUpdate()
 		}
@@ -286,14 +286,14 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 			if value, has := session.afterUpdateBeans[bean]; has && value != nil {
 				*value = append(*value, session.afterClosures...)
 			} else {
-				afterClosures := make([]func(interface{}), lenAfterClosures)
+				afterClosures := make([]func(any), lenAfterClosures)
 				copy(afterClosures, session.afterClosures)
 				// FIXME: if bean is a map type, it will panic because map cannot be as map key
 				session.afterUpdateBeans[bean] = &afterClosures
 			}
 
 		} else {
-			if _, ok := interface{}(bean).(AfterUpdateProcessor); ok {
+			if _, ok := any(bean).(AfterUpdateProcessor); ok {
 				session.afterUpdateBeans[bean] = nil
 			}
 		}
@@ -304,10 +304,10 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 	return res.RowsAffected()
 }
 
-func (session *Session) genUpdateColumns(bean interface{}) ([]string, []interface{}, error) {
+func (session *Session) genUpdateColumns(bean any) ([]string, []any, error) {
 	table := session.statement.RefTable
 	colNames := make([]string, 0, len(table.ColumnsSeq()))
-	args := make([]interface{}, 0, len(table.ColumnsSeq()))
+	args := make([]any, 0, len(table.ColumnsSeq()))
 
 	for _, col := range table.Columns() {
 		if !col.IsVersion && !col.IsCreated && !col.IsUpdated {
@@ -377,7 +377,7 @@ func (session *Session) genUpdateColumns(bean interface{}) ([]string, []interfac
 			args = append(args, val)
 
 			var colName = col.Name
-			session.afterClosures = append(session.afterClosures, func(bean interface{}) {
+			session.afterClosures = append(session.afterClosures, func(bean any) {
 				col := table.GetColumn(colName)
 				setColumnTime(bean, col, t)
 			})

pkg/util/xorm/statement.go

@@ -24,7 +24,7 @@ type Statement struct {
 	idParam         *core.PK
 	OrderStr        string
 	JoinStr         string
-	joinArgs        []interface{}
+	joinArgs        []any
 	GroupByStr      string
 	HavingStr       string
 	ColumnStr       string
@@ -34,7 +34,7 @@ type Statement struct {
 	AltTableName    string
 	tableName       string
 	RawSQL          string
-	RawParams       []interface{}
+	RawParams       []any
 	UseAutoJoin     bool
 	StoreEngine     string
 	Charset         string
@@ -66,7 +66,7 @@ func (statement *Statement) Init() {
 	statement.LimitN = nil
 	statement.OrderStr = ""
 	statement.JoinStr = ""
-	statement.joinArgs = make([]interface{}, 0)
+	statement.joinArgs = make([]any, 0)
 	statement.GroupByStr = ""
 	statement.HavingStr = ""
 	statement.ColumnStr = ""
@@ -77,7 +77,7 @@ func (statement *Statement) Init() {
 	statement.tableName = ""
 	statement.idParam = nil
 	statement.RawSQL = ""
-	statement.RawParams = make([]interface{}, 0)
+	statement.RawParams = make([]any, 0)
 	statement.UseCache = true
 	statement.UseAutoTime = true
 	statement.noAutoCondition = false
@@ -120,7 +120,7 @@ func (statement *Statement) Alias(alias string) *Statement {
 }
 
 // SQL adds raw sql statement
-func (statement *Statement) SQL(query interface{}, args ...interface{}) *Statement {
+func (statement *Statement) SQL(query any, args ...any) *Statement {
 	switch query.(type) {
 	case (*builder.Builder):
 		var err error
@@ -139,19 +139,19 @@ func (statement *Statement) SQL(query interface{}, args ...interface{}) *Stateme
 }
 
 // Where add Where statement
-func (statement *Statement) Where(query interface{}, args ...interface{}) *Statement {
+func (statement *Statement) Where(query any, args ...any) *Statement {
 	return statement.And(query, args...)
 }
 
 // And add Where & and statement
-func (statement *Statement) And(query interface{}, args ...interface{}) *Statement {
+func (statement *Statement) And(query any, args ...any) *Statement {
 	switch query.(type) {
 	case string:
 		cond := builder.Expr(query.(string), args...)
 		statement.cond = statement.cond.And(cond)
-	case map[string]interface{}:
-		queryMap := query.(map[string]interface{})
-		newMap := make(map[string]interface{})
+	case map[string]any:
+		queryMap := query.(map[string]any)
+		newMap := make(map[string]any)
 		for k, v := range queryMap {
 			newMap[statement.Engine.Quote(k)] = v
 		}
@@ -172,13 +172,13 @@ func (statement *Statement) And(query interface{}, args ...interface{}) *Stateme
 }
 
 // Or add Where & Or statement
-func (statement *Statement) Or(query interface{}, args ...interface{}) *Statement {
+func (statement *Statement) Or(query any, args ...any) *Statement {
 	switch query.(type) {
 	case string:
 		cond := builder.Expr(query.(string), args...)
 		statement.cond = statement.cond.Or(cond)
-	case map[string]interface{}:
-		cond := builder.Eq(query.(map[string]interface{}))
+	case map[string]any:
+		cond := builder.Eq(query.(map[string]any))
 		statement.cond = statement.cond.Or(cond)
 	case builder.Cond:
 		cond := query.(builder.Cond)
@@ -195,14 +195,14 @@ func (statement *Statement) Or(query interface{}, args ...interface{}) *Statemen
 }
 
 // In generate "Where column IN (?) " statement
-func (statement *Statement) In(column string, args ...interface{}) *Statement {
+func (statement *Statement) In(column string, args ...any) *Statement {
 	in := builder.In(statement.Engine.Quote(column), args...)
 	statement.cond = statement.cond.And(in)
 	return statement
 }
 
 // NotIn generate "Where column NOT IN (?) " statement
-func (statement *Statement) NotIn(column string, args ...interface{}) *Statement {
+func (statement *Statement) NotIn(column string, args ...any) *Statement {
 	notIn := builder.NotIn(statement.Engine.Quote(column), args...)
 	statement.cond = statement.cond.And(notIn)
 	return statement
@@ -218,7 +218,7 @@ func (statement *Statement) setRefValue(v reflect.Value) error {
 	return nil
 }
 
-func (statement *Statement) setRefBean(bean interface{}) error {
+func (statement *Statement) setRefBean(bean any) error {
 	var err error
 	statement.RefTable, err = statement.Engine.autoMapType(rValue(bean))
 	if err != nil {
@@ -229,9 +229,9 @@ func (statement *Statement) setRefBean(bean interface{}) error {
 }
 
 // Auto generating update columnes and values according a struct
-func (statement *Statement) buildUpdates(bean interface{},
+func (statement *Statement) buildUpdates(bean any,
 	includeVersion, includeUpdated, includeNil,
-	includeAutoIncr, update bool) ([]string, []interface{}) {
+	includeAutoIncr, update bool) ([]string, []any) {
 	engine := statement.Engine
 	table := statement.RefTable
 	allUseBool := statement.allUseBool
@@ -243,7 +243,7 @@ func (statement *Statement) buildUpdates(bean interface{},
 	unscoped := statement.unscoped
 
 	var colNames = make([]string, 0)
-	var args = make([]interface{}, 0)
+	var args = make([]any, 0)
 	for _, col := range table.Columns() {
 		if !includeVersion && col.IsVersion {
 			continue
@@ -312,7 +312,7 @@ func (statement *Statement) buildUpdates(bean interface{},
 			}
 		}
 
-		var val interface{}
+		var val any
 
 		if fieldValue.CanAddr() {
 			if structConvert, ok := fieldValue.Addr().Interface().(core.Conversion); ok {
@@ -518,7 +518,7 @@ func (statement *Statement) TableName() string {
 }
 
 // ID generate "where id = ? " statement or for composite key "where key1 = ? and key2 = ?"
-func (statement *Statement) ID(id interface{}) *Statement {
+func (statement *Statement) ID(id any) *Statement {
 	idValue := reflect.ValueOf(id)
 	idType := reflect.TypeOf(idValue.Interface())
 
@@ -546,7 +546,7 @@ func (statement *Statement) ID(id interface{}) *Statement {
 }
 
 // Incr Generate  "Update ... Set column = column + arg" statement
-func (statement *Statement) Incr(column string, arg ...interface{}) *Statement {
+func (statement *Statement) Incr(column string, arg ...any) *Statement {
 	if len(arg) > 0 {
 		statement.incrColumns.addParam(column, arg[0])
 	} else {
@@ -556,7 +556,7 @@ func (statement *Statement) Incr(column string, arg ...interface{}) *Statement {
 }
 
 // Decr Generate  "Update ... Set column = column - arg" statement
-func (statement *Statement) Decr(column string, arg ...interface{}) *Statement {
+func (statement *Statement) Decr(column string, arg ...any) *Statement {
 	if len(arg) > 0 {
 		statement.decrColumns.addParam(column, arg[0])
 	} else {
@@ -566,7 +566,7 @@ func (statement *Statement) Decr(column string, arg ...interface{}) *Statement {
 }
 
 // SetExpr Generate  "Update ... Set column = {expression}" statement
-func (statement *Statement) SetExpr(column string, expression interface{}) *Statement {
+func (statement *Statement) SetExpr(column string, expression any) *Statement {
 	statement.exprColumns.addParam(column, expression)
 	return statement
 }
@@ -713,7 +713,7 @@ func (statement *Statement) Asc(colNames ...string) *Statement {
 }
 
 // Table tempororily set table name, the parameter could be a string or a pointer of struct
-func (statement *Statement) Table(tableNameOrBean interface{}) *Statement {
+func (statement *Statement) Table(tableNameOrBean any) *Statement {
 	v := rValue(tableNameOrBean)
 	t := v.Type()
 	if t.Kind() == reflect.Struct {
@@ -730,7 +730,7 @@ func (statement *Statement) Table(tableNameOrBean interface{}) *Statement {
 }
 
 // Join The joinOP should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN
-func (statement *Statement) Join(joinOP string, tablename interface{}, condition string, args ...interface{}) *Statement {
+func (statement *Statement) Join(joinOP string, tablename any, condition string, args ...any) *Statement {
 	var buf strings.Builder
 	if len(statement.JoinStr) > 0 {
 		fmt.Fprintf(&buf, "%v %v JOIN ", statement.JoinStr, joinOP)
@@ -886,7 +886,7 @@ func (statement *Statement) genDelIndexSQL() []string {
 	return sqls
 }
 
-func (statement *Statement) genAddColumnStr(col *core.Column) (string, []interface{}) {
+func (statement *Statement) genAddColumnStr(col *core.Column) (string, []any) {
 	quote := statement.Engine.Quote
 	sql := fmt.Sprintf("ALTER TABLE %v ADD %v", quote(statement.TableName()),
 		col.String(statement.Engine.dialect))
@@ -894,15 +894,15 @@ func (statement *Statement) genAddColumnStr(col *core.Column) (string, []interfa
 		sql += " COMMENT '" + col.Comment + "'"
 	}
 	sql += ";"
-	return sql, []interface{}{}
+	return sql, []any{}
 }
 
-func (statement *Statement) buildConds(table *core.Table, bean interface{}, includeVersion bool, includeUpdated bool, includeNil bool, includeAutoIncr bool, addedTableName bool) (builder.Cond, error) {
+func (statement *Statement) buildConds(table *core.Table, bean any, includeVersion bool, includeUpdated bool, includeNil bool, includeAutoIncr bool, addedTableName bool) (builder.Cond, error) {
 	return statement.Engine.buildConds(table, bean, includeVersion, includeUpdated, includeNil, includeAutoIncr, statement.allUseBool, statement.useAllCols,
 		statement.unscoped, statement.mustColumnMap, statement.TableName(), statement.TableAlias, addedTableName)
 }
 
-func (statement *Statement) mergeConds(bean interface{}) error {
+func (statement *Statement) mergeConds(bean any) error {
 	if !statement.noAutoCondition {
 		var addedTableName = (len(statement.JoinStr) > 0)
 		autoCond, err := statement.buildConds(statement.RefTable, bean, true, true, false, true, addedTableName)
@@ -918,7 +918,7 @@ func (statement *Statement) mergeConds(bean interface{}) error {
 	return nil
 }
 
-func (statement *Statement) genConds(bean interface{}) (string, []interface{}, error) {
+func (statement *Statement) genConds(bean any) (string, []any, error) {
 	if err := statement.mergeConds(bean); err != nil {
 		return "", nil, err
 	}
@@ -926,7 +926,7 @@ func (statement *Statement) genConds(bean interface{}) (string, []interface{}, e
 	return builder.ToSQL(statement.cond)
 }
 
-func (statement *Statement) genGetSQL(bean interface{}) (string, []interface{}, error) {
+func (statement *Statement) genGetSQL(bean any) (string, []any, error) {
 	v := rValue(bean)
 	isStruct := v.Kind() == reflect.Struct
 	if isStruct {
@@ -981,9 +981,9 @@ func (statement *Statement) genGetSQL(bean interface{}) (string, []interface{},
 	return sqlStr, append(statement.joinArgs, condArgs...), nil
 }
 
-func (statement *Statement) genCountSQL(beans ...interface{}) (string, []interface{}, error) {
+func (statement *Statement) genCountSQL(beans ...any) (string, []any, error) {
 	var condSQL string
-	var condArgs []interface{}
+	var condArgs []any
 	var err error
 	if len(beans) > 0 {
 		statement.setRefBean(beans[0])
@@ -1011,7 +1011,7 @@ func (statement *Statement) genCountSQL(beans ...interface{}) (string, []interfa
 	return sqlStr, append(statement.joinArgs, condArgs...), nil
 }
 
-func (statement *Statement) genSumSQL(bean interface{}, columns ...string) (string, []interface{}, error) {
+func (statement *Statement) genSumSQL(bean any, columns ...string) (string, []any, error) {
 	statement.setRefBean(bean)
 
 	var sumStrs = make([]string, 0, len(columns))

pkg/util/xorm/statement_args.go

@@ -14,7 +14,7 @@ import (
 	"xorm.io/core"
 )
 
-func quoteNeeded(a interface{}) bool {
+func quoteNeeded(a any) bool {
 	switch a.(type) {
 	case int, int8, int16, int32, int64:
 		return false
@@ -66,7 +66,7 @@ func convertString(arg string) string {
 	return buf.String()
 }
 
-func convertArg(arg interface{}, convertFunc func(string) string) string {
+func convertArg(arg any, convertFunc func(string) string) string {
 	if quoteNeeded(arg) {
 		argv := fmt.Sprintf("%v", arg)
 		return convertFunc(argv)
@@ -77,7 +77,7 @@ func convertArg(arg interface{}, convertFunc func(string) string) string {
 
 const insertSelectPlaceHolder = true
 
-func (statement *Statement) writeArg(w *builder.BytesWriter, arg interface{}) error {
+func (statement *Statement) writeArg(w *builder.BytesWriter, arg any) error {
 	switch argv := arg.(type) {
 	case bool:
 		if argv {
@@ -118,7 +118,7 @@ func (statement *Statement) writeArg(w *builder.BytesWriter, arg interface{}) er
 	return nil
 }
 
-func (statement *Statement) writeArgs(w *builder.BytesWriter, args []interface{}) error {
+func (statement *Statement) writeArgs(w *builder.BytesWriter, args []any) error {
 	for i, arg := range args {
 		if err := statement.writeArg(w, arg); err != nil {
 			return err

pkg/util/xorm/statement_exprparam.go

@@ -21,19 +21,19 @@ func (err ErrUnsupportedExprType) Error() string {
 
 type exprParam struct {
 	colName string
-	arg     interface{}
+	arg     any
 }
 
 type exprParams struct {
 	colNames []string
-	args     []interface{}
+	args     []any
 }
 
 func (exprs *exprParams) Len() int {
 	return len(exprs.colNames)
 }
 
-func (exprs *exprParams) addParam(colName string, arg interface{}) {
+func (exprs *exprParams) addParam(colName string, arg any) {
 	exprs.colNames = append(exprs.colNames, colName)
 	exprs.args = append(exprs.args, arg)
 }

pkg/util/xorm/syslogger.go

@@ -28,42 +28,42 @@ func NewSyslogLogger(w *syslog.Writer) *SyslogLogger {
 }
 
 // Debug log content as Debug
-func (s *SyslogLogger) Debug(v ...interface{}) {
+func (s *SyslogLogger) Debug(v ...any) {
 	s.w.Debug(fmt.Sprint(v...))
 }
 
 // Debugf log content as Debug and format
-func (s *SyslogLogger) Debugf(format string, v ...interface{}) {
+func (s *SyslogLogger) Debugf(format string, v ...any) {
 	s.w.Debug(fmt.Sprintf(format, v...))
 }
 
 // Error log content as Error
-func (s *SyslogLogger) Error(v ...interface{}) {
+func (s *SyslogLogger) Error(v ...any) {
 	s.w.Err(fmt.Sprint(v...))
 }
 
 // Errorf log content as Errorf and format
-func (s *SyslogLogger) Errorf(format string, v ...interface{}) {
+func (s *SyslogLogger) Errorf(format string, v ...any) {
 	s.w.Err(fmt.Sprintf(format, v...))
 }
 
 // Info log content as Info
-func (s *SyslogLogger) Info(v ...interface{}) {
+func (s *SyslogLogger) Info(v ...any) {
 	s.w.Info(fmt.Sprint(v...))
 }
 
 // Infof log content as Infof and format
-func (s *SyslogLogger) Infof(format string, v ...interface{}) {
+func (s *SyslogLogger) Infof(format string, v ...any) {
 	s.w.Info(fmt.Sprintf(format, v...))
 }
 
 // Warn log content as Warn
-func (s *SyslogLogger) Warn(v ...interface{}) {
+func (s *SyslogLogger) Warn(v ...any) {
 	s.w.Warning(fmt.Sprint(v...))
 }
 
 // Warnf log content as Warnf and format
-func (s *SyslogLogger) Warnf(format string, v ...interface{}) {
+func (s *SyslogLogger) Warnf(format string, v ...any) {
 	s.w.Warning(fmt.Sprintf(format, v...))
 }