HiPoweredDev
/
xorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use any instead of interface{}

This commit is contained in:
Lunny Xiao 2023-10-28 17:48:25 +08:00
parent 607f715634
commit 6e78cff477
No known key found for this signature in database
GPG Key ID: C3B7C91B632F738A
91 changed files with 678 additions and 683 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
README.md
View File

@ -105,7 +105,7 @@ engineGroup, err := xorm.NewEngineGroup(masterEngine, []*Engine{slave1Engine, sl
Then all place where `engine` you can just use `engineGroup`. Then all place where `engine` you can just use `engineGroup`.
* `Query` runs a SQL string, the returned results is `[]map[string][]byte`, `QueryString` returns `[]map[string]string`, `QueryInterface` returns `[]map[string]interface{}`. * `Query` runs a SQL string, the returned results is `[]map[string][]byte`, `QueryString` returns `[]map[string]string`, `QueryInterface` returns `[]map[string]any`.
```Go ```Go
results, err := engine.Query("select * from user") results, err := engine.Query("select * from user")
@ -141,13 +141,13 @@ affected, err := engine.Insert(&user1, &users)
// INSERT INTO struct1 () values () // INSERT INTO struct1 () values ()
// INSERT INTO struct2 () values (),(),() // INSERT INTO struct2 () values (),(),()
affected, err := engine.Table("user").Insert(map[string]interface{}{ affected, err := engine.Table("user").Insert(map[string]any{
"name": "lunny", "name": "lunny",
"age": 18, "age": 18,
}) })
// INSERT INTO user (name, age) values (?,?) // INSERT INTO user (name, age) values (?,?)
affected, err := engine.Table("user").Insert([]map[string]interface{}{ affected, err := engine.Table("user").Insert([]map[string]any{
{ {
"name": "lunny", "name": "lunny",
"age": 18, "age": 18,
@ -187,7 +187,7 @@ var valuesMap = make(map[string]string)
has, err := engine.Table(&user).Where("id = ?", id).Get(&valuesMap) has, err := engine.Table(&user).Where("id = ?", id).Get(&valuesMap)
// SELECT * FROM user WHERE id = ? // SELECT * FROM user WHERE id = ?
var valuesSlice = make([]interface{}, len(cols)) var valuesSlice = make([]any, len(cols))
has, err := engine.Table(&user).Where("id = ?", id).Cols(cols...).Get(&valuesSlice) has, err := engine.Table(&user).Where("id = ?", id).Cols(cols...).Get(&valuesSlice)
// SELECT col1, col2, col3 FROM user WHERE id = ? // SELECT col1, col2, col3 FROM user WHERE id = ?
``` ```
@ -244,13 +244,13 @@ err := engine.Table("user").Select("user.*, detail.*").
* `Iterate` and `Rows` query multiple records and record by record handle, there are two methods Iterate and Rows * `Iterate` and `Rows` query multiple records and record by record handle, there are two methods Iterate and Rows
```Go ```Go
err := engine.Iterate(&User{Name:name}, func(idx int, bean interface{}) error { err := engine.Iterate(&User{Name:name}, func(idx int, bean any) error {
user := bean.(*User) user := bean.(*User)
return nil return nil
}) })
// SELECT * FROM user // SELECT * FROM user
err := engine.BufferSize(100).Iterate(&User{Name:name}, func(idx int, bean interface{}) error { err := engine.BufferSize(100).Iterate(&User{Name:name}, func(idx int, bean any) error {
user := bean.(*User) user := bean.(*User)
return nil return nil
}) })
@ -414,7 +414,7 @@ return session.Commit()
* Or you can use `Transaction` to replace above codes. * Or you can use `Transaction` to replace above codes.
```Go ```Go
res, err := engine.Transaction(func(session *xorm.Session) (interface{}, error) { res, err := engine.Transaction(func(session *xorm.Session) (any, error) {
user1 := Userinfo{Username: "xiaoxiao", Departname: "dev", Alias: "lunny", Created: time.Now()} user1 := Userinfo{Username: "xiaoxiao", Departname: "dev", Alias: "lunny", Created: time.Now()}
if _, err := session.Insert(&user1); err != nil { if _, err := session.Insert(&user1); err != nil {
return nil, err return nil, err

14
README_CN.md
View File

@ -103,7 +103,7 @@ engineGroup, err := xorm.NewEngineGroup(masterEngine, []*Engine{slave1Engine, sl
所有使用 `engine` 都可以简单的用 `engineGroup` 来替换。 所有使用 `engine` 都可以简单的用 `engineGroup` 来替换。
* `Query` 最原始的也支持SQL语句查询，返回的结果类型为 `[]map[string][]byte`。`QueryString` 返回 `[]map[string]string`, `QueryInterface` 返回 `[]map[string]interface{}`. * `Query` 最原始的也支持SQL语句查询，返回的结果类型为 `[]map[string][]byte`。`QueryString` 返回 `[]map[string]string`, `QueryInterface` 返回 `[]map[string]any`.
```Go ```Go
results, err := engine.Query("select * from user") results, err := engine.Query("select * from user")
@ -139,13 +139,13 @@ affected, err := engine.Insert(&user1, &users)
// INSERT INTO struct1 () values () // INSERT INTO struct1 () values ()
// INSERT INTO struct2 () values (),(),() // INSERT INTO struct2 () values (),(),()
affected, err := engine.Table("user").Insert(map[string]interface{}{ affected, err := engine.Table("user").Insert(map[string]any{
"name": "lunny", "name": "lunny",
"age": 18, "age": 18,
}) })
// INSERT INTO user (name, age) values (?,?) // INSERT INTO user (name, age) values (?,?)
affected, err := engine.Table("user").Insert([]map[string]interface{}{ affected, err := engine.Table("user").Insert([]map[string]any{
{ {
"name": "lunny", "name": "lunny",
"age": 18, "age": 18,
@ -185,7 +185,7 @@ var valuesMap = make(map[string]string)
has, err := engine.Table(&user).Where("id = ?", id).Get(&valuesMap) has, err := engine.Table(&user).Where("id = ?", id).Get(&valuesMap)
// SELECT * FROM user WHERE id = ? // SELECT * FROM user WHERE id = ?
var valuesSlice = make([]interface{}, len(cols)) var valuesSlice = make([]any, len(cols))
has, err := engine.Table(&user).Where("id = ?", id).Cols(cols...).Get(&valuesSlice) has, err := engine.Table(&user).Where("id = ?", id).Cols(cols...).Get(&valuesSlice)
// SELECT col1, col2, col3 FROM user WHERE id = ? // SELECT col1, col2, col3 FROM user WHERE id = ?
``` ```
@ -242,13 +242,13 @@ err := engine.Table("user").Select("user.*, detail.*").
* `Iterate` 和 `Rows` 根据条件遍历数据库，可以有两种方式: Iterate and Rows * `Iterate` 和 `Rows` 根据条件遍历数据库，可以有两种方式: Iterate and Rows
```Go ```Go
err := engine.Iterate(&User{Name:name}, func(idx int, bean interface{}) error { err := engine.Iterate(&User{Name:name}, func(idx int, bean any) error {
user := bean.(*User) user := bean.(*User)
return nil return nil
}) })
// SELECT * FROM user // SELECT * FROM user
err := engine.BufferSize(100).Iterate(&User{Name:name}, func(idx int, bean interface{}) error { err := engine.BufferSize(100).Iterate(&User{Name:name}, func(idx int, bean any) error {
user := bean.(*User) user := bean.(*User)
return nil return nil
}) })
@ -405,7 +405,7 @@ return session.Commit()
* 事务的简写方法 * 事务的简写方法
```Go ```Go
res, err := engine.Transaction(func(session *xorm.Session) (interface{}, error) { res, err := engine.Transaction(func(session *xorm.Session) (any, error) {
user1 := Userinfo{Username: "xiaoxiao", Departname: "dev", Alias: "lunny", Created: time.Now()} user1 := Userinfo{Username: "xiaoxiao", Departname: "dev", Alias: "lunny", Created: time.Now()}
if _, err := session.Insert(&user1); err != nil { if _, err := session.Insert(&user1); err != nil {
return nil, err return nil, err

10
columns.go
View File

@ -12,7 +12,7 @@ import (
"xorm.io/xorm/v2/schemas" "xorm.io/xorm/v2/schemas"
) )
func setColumnInt(bean interface{}, col *schemas.Column, t int64) { func setColumnInt(bean any, col *schemas.Column, t int64) {
v, err := col.ValueOf(bean) v, err := col.ValueOf(bean)
if err != nil { if err != nil {
return return
@ -27,7 +27,7 @@ func setColumnInt(bean interface{}, col *schemas.Column, t int64) {
} }
} }
func setColumnTime(bean interface{}, col *schemas.Column, t time.Time) { func setColumnTime(bean any, col *schemas.Column, t time.Time) {
v, err := col.ValueOf(bean) v, err := col.ValueOf(bean)
if err != nil { if err != nil {
return return
@ -64,19 +64,19 @@ func getFlagForColumn(m map[string]bool, col *schemas.Column) (val bool, has boo
} }
// Incr provides a query string like "count = count + 1" // Incr provides a query string like "count = count + 1"
func (session *Session) Incr(column string, arg ...interface{}) *Session { func (session *Session) Incr(column string, arg ...any) *Session {
session.statement.Incr(column, arg...) session.statement.Incr(column, arg...)
return session return session
} }
// Decr provides a query string like "count = count - 1" // Decr provides a query string like "count = count - 1"
func (session *Session) Decr(column string, arg ...interface{}) *Session { func (session *Session) Decr(column string, arg ...any) *Session {
session.statement.Decr(column, arg...) session.statement.Decr(column, arg...)
return session return session
} }
// SetExpr provides a query string like "column = {expression}" // SetExpr provides a query string like "column = {expression}"
func (session *Session) SetExpr(column string, expression interface{}) *Session { func (session *Session) SetExpr(column string, expression any) *Session {
session.statement.SetExpr(column, expression) session.statement.SetExpr(column, expression)
return session return session
} }

14
conditions.go
View File

@ -8,43 +8,43 @@ import "xorm.io/builder"
// SQL provides raw sql input parameter. When you have a complex SQL statement // 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. // 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...) session.statement.SQL(query, args...)
return session return session
} }
// Where provides custom query condition. // 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...) session.statement.Where(query, args...)
return session return session
} }
// And provides custom query condition. // 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...) session.statement.And(query, args...)
return session return session
} }
// Or provides custom query condition. // 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...) session.statement.Or(query, args...)
return session return session
} }
// ID provides converting id as a query condition // 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) session.statement.ID(id)
return session return session
} }
// In provides a query string like "id in (1, 2, 3)" // 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...) session.statement.In(column, args...)
return session return session
} }
// NotIn provides a query string like "id in (1, 2, 3)" // 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...) session.statement.NotIn(column, args...)
return session return session
} }

12
contexts/context_cache.go
View File

@ -7,24 +7,24 @@ package contexts
// ContextCache is the interface that operates the cache data. // ContextCache is the interface that operates the cache data.
type ContextCache interface { type ContextCache interface {
// Put puts value into cache with key. // Put puts value into cache with key.
Put(key string, val interface{}) Put(key string, val any)
// Get gets cached value by given key. // Get gets cached value by given key.
Get(key string) interface{} Get(key string) any
} }
type memoryContextCache map[string]interface{} type memoryContextCache map[string]any
// NewMemoryContextCache return memoryContextCache // NewMemoryContextCache return memoryContextCache
func NewMemoryContextCache() memoryContextCache { func NewMemoryContextCache() memoryContextCache {
return make(map[string]interface{}) return make(map[string]any)
} }
// Put puts value into cache with key. // Put puts value into cache with key.
func (m memoryContextCache) Put(key string, val interface{}) { func (m memoryContextCache) Put(key string, val any) {
m[key] = val m[key] = val
} }
// Get gets cached value by given key. // Get gets cached value by given key.
func (m memoryContextCache) Get(key string) interface{} { func (m memoryContextCache) Get(key string) any {
return m[key] return m[key]
} }

4
contexts/hook.go
View File

@ -15,14 +15,14 @@ type ContextHook struct {
start time.Time start time.Time
Ctx context.Context Ctx context.Context
SQL string // log content or SQL SQL string // log content or SQL
Args []interface{} // if it's a SQL, it's the arguments Args []any // if it's a SQL, it's the arguments
Result sql.Result Result sql.Result
ExecuteTime time.Duration ExecuteTime time.Duration
Err error // SQL executed error Err error // SQL executed error
} }
// NewContextHook return context for hook // NewContextHook return context for hook
func NewContextHook(ctx context.Context, sql string, args []interface{}) *ContextHook { func NewContextHook(ctx context.Context, sql string, args []any) *ContextHook {
return &ContextHook{ return &ContextHook{
start: time.Now(), start: time.Now(),
Ctx: ctx, Ctx: ctx,

18
delete.go
View File

@ -15,17 +15,17 @@ var ErrNeedDeletedCond = errors.New("Delete action needs at least one condition"
// Delete records, bean's non-empty fields are conditions // Delete records, bean's non-empty fields are conditions
// At least one condition must be set. // At least one condition must be set.
func (session *Session) Delete(beans ...interface{}) (int64, error) { func (session *Session) Delete(beans ...any) (int64, error) {
return session.delete(beans, true) return session.delete(beans, true)
} }
// Truncate records, bean's non-empty fields are conditions // Truncate records, bean's non-empty fields are conditions
// In contrast to Delete this method allows deletes without conditions. // In contrast to Delete this method allows deletes without conditions.
func (session *Session) Truncate(beans ...interface{}) (int64, error) { func (session *Session) Truncate(beans ...any) (int64, error) {
return session.delete(beans, false) return session.delete(beans, false)
} }
func (session *Session) delete(beans []interface{}, mustHaveConditions bool) (int64, error) { func (session *Session) delete(beans []any, mustHaveConditions bool) (int64, error) {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -36,7 +36,7 @@ func (session *Session) delete(beans []interface{}, mustHaveConditions bool) (in
var ( var (
err error err error
bean interface{} bean any
) )
if len(beans) > 0 { if len(beans) > 0 {
bean = beans[0] bean = beans[0]
@ -46,7 +46,7 @@ func (session *Session) delete(beans []interface{}, mustHaveConditions bool) (in
executeBeforeClosures(session, bean) executeBeforeClosures(session, bean)
if processor, ok := interface{}(bean).(BeforeDeleteProcessor); ok { if processor, ok := any(bean).(BeforeDeleteProcessor); ok {
processor.BeforeDelete() processor.BeforeDelete()
} }
@ -77,7 +77,7 @@ func (session *Session) delete(beans []interface{}, mustHaveConditions bool) (in
} }
colName := deletedColumn.Name colName := deletedColumn.Name
session.afterClosures = append(session.afterClosures, func(bean interface{}) { session.afterClosures = append(session.afterClosures, func(bean any) {
col := table.GetColumn(colName) col := table.GetColumn(colName)
setColumnTime(bean, col, t) setColumnTime(bean, col, t)
}) })
@ -95,7 +95,7 @@ func (session *Session) delete(beans []interface{}, mustHaveConditions bool) (in
for _, closure := range session.afterClosures { for _, closure := range session.afterClosures {
closure(bean) closure(bean)
} }
if processor, ok := interface{}(bean).(AfterDeleteProcessor); ok { if processor, ok := any(bean).(AfterDeleteProcessor); ok {
processor.AfterDelete() processor.AfterDelete()
} }
} else { } else {
@ -104,12 +104,12 @@ func (session *Session) delete(beans []interface{}, mustHaveConditions bool) (in
if value, has := session.afterDeleteBeans[beans[0]]; has && value != nil { if value, has := session.afterDeleteBeans[beans[0]]; has && value != nil {
*value = append(*value, session.afterClosures...) *value = append(*value, session.afterClosures...)
} else { } else {
afterClosures := make([]func(interface{}), lenAfterClosures) afterClosures := make([]func(any), lenAfterClosures)
copy(afterClosures, session.afterClosures) copy(afterClosures, session.afterClosures)
session.afterDeleteBeans[bean] = &afterClosures session.afterDeleteBeans[bean] = &afterClosures
} }
} else { } else {
if _, ok := interface{}(bean).(AfterDeleteProcessor); ok { if _, ok := any(bean).(AfterDeleteProcessor); ok {
session.afterDeleteBeans[bean] = nil session.afterDeleteBeans[bean] = nil
} }
} }

22
dialects/dameng.go
View File

@ -749,8 +749,8 @@ func (db *dameng) SetQuotePolicy(quotePolicy QuotePolicy) {
} }
} }
func (db *dameng) IndexCheckSQL(tableName, idxName string) (string, []interface{}) { func (db *dameng) IndexCheckSQL(tableName, idxName string) (string, []any) {
args := []interface{}{tableName, idxName} args := []any{tableName, idxName}
return `SELECT INDEX_NAME FROM USER_INDEXES ` + return `SELECT INDEX_NAME FROM USER_INDEXES ` +
`WHERE TABLE_NAME = ? AND INDEX_NAME = ?`, args `WHERE TABLE_NAME = ? AND INDEX_NAME = ?`, args
} }
@ -780,7 +780,7 @@ func (db *dameng) IsSequenceExist(ctx context.Context, queryer core.Queryer, seq
} }
func (db *dameng) IsColumnExist(queryer core.Queryer, ctx context.Context, tableName, colName string) (bool, error) { func (db *dameng) IsColumnExist(queryer core.Queryer, ctx context.Context, tableName, colName string) (bool, error) {
args := []interface{}{tableName, colName} args := []any{tableName, colName}
query := "SELECT column_name FROM USER_TAB_COLUMNS WHERE table_name = ?" + query := "SELECT column_name FROM USER_TAB_COLUMNS WHERE table_name = ?" +
" AND column_name = ?" " AND column_name = ?"
return db.HasRecords(queryer, ctx, query, args...) return db.HasRecords(queryer, ctx, query, args...)
@ -800,7 +800,7 @@ type dmClobObject interface {
// var _ dmClobObject = &dm.DmClob{} // var _ dmClobObject = &dm.DmClob{}
func (d *dmClobScanner) Scan(data interface{}) error { func (d *dmClobScanner) Scan(data any) error {
if data == nil { if data == nil {
return nil return nil
} }
@ -1004,7 +1004,7 @@ func (db *dameng) GetColumns(queryer core.Queryer, ctx context.Context, tableNam
func (db *dameng) GetTables(queryer core.Queryer, ctx context.Context) ([]*schemas.Table, error) { func (db *dameng) GetTables(queryer core.Queryer, ctx context.Context) ([]*schemas.Table, error) {
s := "SELECT table_name FROM user_tables WHERE temporary = 'N' AND table_name NOT LIKE ?" s := "SELECT table_name FROM user_tables WHERE temporary = 'N' AND table_name NOT LIKE ?"
args := []interface{}{strings.ToUpper(db.uri.User), "%$%"} args := []any{strings.ToUpper(db.uri.User), "%$%"}
rows, err := queryer.QueryContext(ctx, s, args...) rows, err := queryer.QueryContext(ctx, s, args...)
if err != nil { if err != nil {
@ -1029,7 +1029,7 @@ func (db *dameng) GetTables(queryer core.Queryer, ctx context.Context) ([]*schem
} }
func (db *dameng) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) { func (db *dameng) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) {
args := []interface{}{tableName, tableName} args := []any{tableName, tableName}
s := "SELECT t.column_name,i.uniqueness,i.index_name FROM user_ind_columns t,user_indexes i " + s := "SELECT t.column_name,i.uniqueness,i.index_name FROM user_ind_columns t,user_indexes i " +
"WHERE t.index_name = i.index_name and t.table_name = i.table_name and t.table_name =?" + "WHERE t.index_name = i.index_name and t.table_name = i.table_name and t.table_name =?" +
" AND t.index_name not in (SELECT index_name FROM ALL_CONSTRAINTS WHERE CONSTRAINT_TYPE='P' AND table_name = ?)" " AND t.index_name not in (SELECT index_name FROM ALL_CONSTRAINTS WHERE CONSTRAINT_TYPE='P' AND table_name = ?)"
@ -1120,7 +1120,7 @@ func (d *damengDriver) Parse(driverName, dataSourceName string) (*URI, error) {
}, nil }, nil
} }
func (d *damengDriver) GenScanResult(colType string) (interface{}, error) { func (d *damengDriver) GenScanResult(colType string) (any, error) {
switch colType { switch colType {
case "CHAR", "NCHAR", "VARCHAR", "VARCHAR2", "NVARCHAR2", "LONG", "CLOB", "NCLOB": case "CHAR", "NCHAR", "VARCHAR", "VARCHAR2", "NVARCHAR2", "LONG", "CLOB", "NCLOB":
var s sql.NullString var s sql.NullString
@ -1149,13 +1149,13 @@ func (d *damengDriver) GenScanResult(colType string) (interface{}, error) {
} }
} }
func (d *damengDriver) Scan(ctx *ScanContext, rows *core.Rows, types []*sql.ColumnType, vv ...interface{}) error { func (d *damengDriver) Scan(ctx *ScanContext, rows *core.Rows, types []*sql.ColumnType, vv ...any) error {
scanResults := make([]interface{}, 0, len(types)) scanResults := make([]any, 0, len(types))
replaces := make([]bool, 0, len(types)) replaces := make([]bool, 0, len(types))
var err error var err error
for i, v := range vv { for i, v := range vv {
var replaced bool var replaced bool
var scanResult interface{} var scanResult any
switch types[i].DatabaseTypeName() { switch types[i].DatabaseTypeName() {
case "CLOB", "TEXT": case "CLOB", "TEXT":
scanResult = &dmClobScanner{} scanResult = &dmClobScanner{}
@ -1179,7 +1179,7 @@ func (d *damengDriver) Scan(ctx *ScanContext, rows *core.Rows, types []*sql.Colu
if replaced { if replaced {
switch t := scanResults[i].(type) { switch t := scanResults[i].(type) {
case *dmClobScanner: case *dmClobScanner:
var d interface{} var d any
if t.valid { if t.valid {
d = t.data d = t.data
} else { } else {

4
dialects/dialect.go
View File

@ -67,7 +67,7 @@ type Dialect interface {
AutoIncrStr() string AutoIncrStr() string
GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error)
IndexCheckSQL(tableName, idxName string) (string, []interface{}) IndexCheckSQL(tableName, idxName string) (string, []any)
CreateIndexSQL(tableName string, index *schemas.Index) string CreateIndexSQL(tableName string, index *schemas.Index) string
DropIndexSQL(tableName string, index *schemas.Index) string DropIndexSQL(tableName string, index *schemas.Index) string
@ -177,7 +177,7 @@ func (db *Base) DropTableSQL(tableName string) (string, bool) {
} }
// HasRecords returns true if the SQL has records returned // HasRecords returns true if the SQL has records returned
func (db *Base) HasRecords(queryer core.Queryer, ctx context.Context, query string, args ...interface{}) (bool, error) { func (db *Base) HasRecords(queryer core.Queryer, ctx context.Context, query string, args ...any) (bool, error) {
rows, err := queryer.QueryContext(ctx, query, args...) rows, err := queryer.QueryContext(ctx, query, args...)
if err != nil { if err != nil {
return false, err return false, err

6
dialects/driver.go
View File

@ -27,8 +27,8 @@ type DriverFeatures struct {
type Driver interface { type Driver interface {
Parse(string, string) (*URI, error) Parse(string, string) (*URI, error)
Features() *DriverFeatures Features() *DriverFeatures
GenScanResult(string) (interface{}, error) // according given column type generating a suitable scan interface GenScanResult(string) (any, error) // according given column type generating a suitable scan interface
Scan(*ScanContext, *core.Rows, []*sql.ColumnType, ...interface{}) error Scan(*ScanContext, *core.Rows, []*sql.ColumnType, ...any) error
} }
var drivers = map[string]Driver{} var drivers = map[string]Driver{}
@ -78,6 +78,6 @@ func OpenDialect(driverName, connstr string) (Dialect, error) {
type baseDriver struct{} type baseDriver struct{}
func (b *baseDriver) Scan(ctx *ScanContext, rows *core.Rows, types []*sql.ColumnType, v ...interface{}) error { func (b *baseDriver) Scan(ctx *ScanContext, rows *core.Rows, types []*sql.ColumnType, v ...any) error {
return rows.Scan(v...) return rows.Scan(v...)
} }

12
dialects/mssql.go
View File

@ -442,8 +442,8 @@ func (db *mssql) ModifyColumnSQL(tableName string, col *schemas.Column) string {
return fmt.Sprintf("ALTER TABLE %s ALTER COLUMN %s", db.quoter.Quote(tableName), s) return fmt.Sprintf("ALTER TABLE %s ALTER COLUMN %s", db.quoter.Quote(tableName), s)
} }
func (db *mssql) IndexCheckSQL(tableName, idxName string) (string, []interface{}) { func (db *mssql) IndexCheckSQL(tableName, idxName string) (string, []any) {
args := []interface{}{idxName} args := []any{idxName}
sql := "select name from sysindexes where id=object_id('" + tableName + "') and name=?" sql := "select name from sysindexes where id=object_id('" + tableName + "') and name=?"
return sql, args return sql, args
} }
@ -460,7 +460,7 @@ func (db *mssql) IsTableExist(queryer core.Queryer, ctx context.Context, tableNa
} }
func (db *mssql) GetColumns(queryer core.Queryer, ctx context.Context, tableName string) ([]string, map[string]*schemas.Column, error) { func (db *mssql) GetColumns(queryer core.Queryer, ctx context.Context, tableName string) ([]string, map[string]*schemas.Column, error) {
args := []interface{}{} args := []any{}
s := `select a.name as name, b.name as ctype,a.max_length,a.precision,a.scale,a.is_nullable as nullable, s := `select a.name as name, b.name as ctype,a.max_length,a.precision,a.scale,a.is_nullable as nullable,
"default_is_null" = (CASE WHEN c.text is null THEN 1 ELSE 0 END), "default_is_null" = (CASE WHEN c.text is null THEN 1 ELSE 0 END),
replace(replace(isnull(c.text,''),'(',''),')','') as vdefault, replace(replace(isnull(c.text,''),'(',''),')','') as vdefault,
@ -554,7 +554,7 @@ func (db *mssql) GetColumns(queryer core.Queryer, ctx context.Context, tableName
} }
func (db *mssql) GetTables(queryer core.Queryer, ctx context.Context) ([]*schemas.Table, error) { func (db *mssql) GetTables(queryer core.Queryer, ctx context.Context) ([]*schemas.Table, error) {
args := []interface{}{} args := []any{}
s := `select name from sysobjects where xtype ='U'` s := `select name from sysobjects where xtype ='U'`
rows, err := queryer.QueryContext(ctx, s, args...) rows, err := queryer.QueryContext(ctx, s, args...)
@ -581,7 +581,7 @@ func (db *mssql) GetTables(queryer core.Queryer, ctx context.Context) ([]*schema
} }
func (db *mssql) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) { func (db *mssql) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) {
args := []interface{}{tableName} args := []any{tableName}
s := `SELECT s := `SELECT
IXS.NAME AS [INDEX_NAME], IXS.NAME AS [INDEX_NAME],
C.NAME AS [COLUMN_NAME], C.NAME AS [COLUMN_NAME],
@ -719,7 +719,7 @@ func (p *odbcDriver) Parse(driverName, dataSourceName string) (*URI, error) {
return &URI{DBName: dbName, DBType: schemas.MSSQL}, nil return &URI{DBName: dbName, DBType: schemas.MSSQL}, nil
} }
func (p *odbcDriver) GenScanResult(colType string) (interface{}, error) { func (p *odbcDriver) GenScanResult(colType string) (any, error) {
switch colType { switch colType {
case "VARCHAR", "TEXT", "CHAR", "NVARCHAR", "NCHAR", "NTEXT": case "VARCHAR", "TEXT", "CHAR", "NVARCHAR", "NCHAR", "NTEXT":
fallthrough fallthrough

12
dialects/mysql.go
View File

@ -370,8 +370,8 @@ func (db *mysql) AutoIncrStr() string {
return "AUTO_INCREMENT" return "AUTO_INCREMENT"
} }
func (db *mysql) IndexCheckSQL(tableName, idxName string) (string, []interface{}) { func (db *mysql) IndexCheckSQL(tableName, idxName string) (string, []any) {
args := []interface{}{db.uri.DBName, tableName, idxName} args := []any{db.uri.DBName, tableName, idxName}
sql := "SELECT `INDEX_NAME` FROM `INFORMATION_SCHEMA`.`STATISTICS`" sql := "SELECT `INDEX_NAME` FROM `INFORMATION_SCHEMA`.`STATISTICS`"
sql += " WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ? AND `INDEX_NAME`=?" sql += " WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ? AND `INDEX_NAME`=?"
return sql, args return sql, args
@ -408,7 +408,7 @@ func (db *mysql) ModifyColumnSQL(tableName string, col *schemas.Column) string {
} }
func (db *mysql) GetColumns(queryer core.Queryer, ctx context.Context, tableName string) ([]string, map[string]*schemas.Column, error) { func (db *mysql) GetColumns(queryer core.Queryer, ctx context.Context, tableName string) ([]string, map[string]*schemas.Column, error) {
args := []interface{}{db.uri.DBName, tableName} args := []any{db.uri.DBName, tableName}
alreadyQuoted := "(INSTR(VERSION(), 'maria') > 0 && " + alreadyQuoted := "(INSTR(VERSION(), 'maria') > 0 && " +
"(SUBSTRING_INDEX(VERSION(), '.', 1) > 10 || " + "(SUBSTRING_INDEX(VERSION(), '.', 1) > 10 || " +
"(SUBSTRING_INDEX(VERSION(), '.', 1) = 10 && " + "(SUBSTRING_INDEX(VERSION(), '.', 1) = 10 && " +
@ -545,7 +545,7 @@ func (db *mysql) GetColumns(queryer core.Queryer, ctx context.Context, tableName
} }
func (db *mysql) GetTables(queryer core.Queryer, ctx context.Context) ([]*schemas.Table, error) { func (db *mysql) GetTables(queryer core.Queryer, ctx context.Context) ([]*schemas.Table, error) {
args := []interface{}{db.uri.DBName} args := []any{db.uri.DBName}
s := "SELECT `TABLE_NAME`, `ENGINE`, `AUTO_INCREMENT`, `TABLE_COMMENT`, `TABLE_COLLATION` from " + s := "SELECT `TABLE_NAME`, `ENGINE`, `AUTO_INCREMENT`, `TABLE_COMMENT`, `TABLE_COLLATION` from " +
"`INFORMATION_SCHEMA`.`TABLES` WHERE `TABLE_SCHEMA`=? AND (`ENGINE`='MyISAM' OR `ENGINE` = 'InnoDB' OR `ENGINE` = 'TokuDB')" "`INFORMATION_SCHEMA`.`TABLES` WHERE `TABLE_SCHEMA`=? AND (`ENGINE`='MyISAM' OR `ENGINE` = 'InnoDB' OR `ENGINE` = 'TokuDB')"
@ -597,7 +597,7 @@ func (db *mysql) SetQuotePolicy(quotePolicy QuotePolicy) {
} }
func (db *mysql) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) { func (db *mysql) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) {
args := []interface{}{db.uri.DBName, tableName} args := []any{db.uri.DBName, tableName}
s := "SELECT `INDEX_NAME`, `NON_UNIQUE`, `COLUMN_NAME` FROM `INFORMATION_SCHEMA`.`STATISTICS` WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ? ORDER BY `SEQ_IN_INDEX`" s := "SELECT `INDEX_NAME`, `NON_UNIQUE`, `COLUMN_NAME` FROM `INFORMATION_SCHEMA`.`STATISTICS` WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ? ORDER BY `SEQ_IN_INDEX`"
rows, err := queryer.QueryContext(ctx, s, args...) rows, err := queryer.QueryContext(ctx, s, args...)
@ -759,7 +759,7 @@ func (p *mysqlDriver) Parse(driverName, dataSourceName string) (*URI, error) {
return uri, nil return uri, nil
} }
func (p *mysqlDriver) GenScanResult(colType string) (interface{}, error) { func (p *mysqlDriver) GenScanResult(colType string) (any, error) {
colType = strings.Replace(colType, "UNSIGNED ", "", -1) colType = strings.Replace(colType, "UNSIGNED ", "", -1)
switch colType { switch colType {
case "CHAR", "VARCHAR", "TINYTEXT", "TEXT", "MEDIUMTEXT", "LONGTEXT", "ENUM", "SET", "JSON": case "CHAR", "VARCHAR", "TINYTEXT", "TEXT", "MEDIUMTEXT", "LONGTEXT", "ENUM", "SET", "JSON":

14
dialects/oracle.go
View File

@ -678,8 +678,8 @@ func (db *oracle) SetQuotePolicy(quotePolicy QuotePolicy) {
} }
} }
func (db *oracle) IndexCheckSQL(tableName, idxName string) (string, []interface{}) { func (db *oracle) IndexCheckSQL(tableName, idxName string) (string, []any) {
args := []interface{}{tableName, idxName} args := []any{tableName, idxName}
return `SELECT INDEX_NAME FROM USER_INDEXES ` + return `SELECT INDEX_NAME FROM USER_INDEXES ` +
`WHERE TABLE_NAME = :1 AND INDEX_NAME = :2`, args `WHERE TABLE_NAME = :1 AND INDEX_NAME = :2`, args
} }
@ -689,14 +689,14 @@ func (db *oracle) IsTableExist(queryer core.Queryer, ctx context.Context, tableN
} }
func (db *oracle) IsColumnExist(queryer core.Queryer, ctx context.Context, tableName, colName string) (bool, error) { func (db *oracle) IsColumnExist(queryer core.Queryer, ctx context.Context, tableName, colName string) (bool, error) {
args := []interface{}{tableName, colName} args := []any{tableName, colName}
query := "SELECT column_name FROM USER_TAB_COLUMNS WHERE table_name = :1" + query := "SELECT column_name FROM USER_TAB_COLUMNS WHERE table_name = :1" +
" AND column_name = :2" " AND column_name = :2"
return db.HasRecords(queryer, ctx, query, args...) return db.HasRecords(queryer, ctx, query, args...)
} }
func (db *oracle) GetColumns(queryer core.Queryer, ctx context.Context, tableName string) ([]string, map[string]*schemas.Column, error) { func (db *oracle) GetColumns(queryer core.Queryer, ctx context.Context, tableName string) ([]string, map[string]*schemas.Column, error) {
args := []interface{}{tableName} args := []any{tableName}
s := "SELECT column_name,data_default,data_type,data_length,data_precision,data_scale," + s := "SELECT column_name,data_default,data_type,data_length,data_precision,data_scale," +
"nullable FROM USER_TAB_COLUMNS WHERE table_name = :1" "nullable FROM USER_TAB_COLUMNS WHERE table_name = :1"
@ -796,7 +796,7 @@ func (db *oracle) GetColumns(queryer core.Queryer, ctx context.Context, tableNam
} }
func (db *oracle) GetTables(queryer core.Queryer, ctx context.Context) ([]*schemas.Table, error) { func (db *oracle) GetTables(queryer core.Queryer, ctx context.Context) ([]*schemas.Table, error) {
args := []interface{}{} args := []any{}
s := "SELECT table_name FROM user_tables" s := "SELECT table_name FROM user_tables"
rows, err := queryer.QueryContext(ctx, s, args...) rows, err := queryer.QueryContext(ctx, s, args...)
@ -822,7 +822,7 @@ func (db *oracle) GetTables(queryer core.Queryer, ctx context.Context) ([]*schem
} }
func (db *oracle) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) { func (db *oracle) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) {
args := []interface{}{tableName} args := []any{tableName}
s := "SELECT t.column_name,i.uniqueness,i.index_name FROM user_ind_columns t,user_indexes i " + s := "SELECT t.column_name,i.uniqueness,i.index_name FROM user_ind_columns t,user_indexes i " +
"WHERE t.index_name = i.index_name and t.table_name = i.table_name and t.table_name =:1" "WHERE t.index_name = i.index_name and t.table_name = i.table_name and t.table_name =:1"
@ -911,7 +911,7 @@ func (g *godrorDriver) Parse(driverName, dataSourceName string) (*URI, error) {
return db, nil return db, nil
} }
func (g *godrorDriver) GenScanResult(colType string) (interface{}, error) { func (g *godrorDriver) GenScanResult(colType string) (any, error) {
switch colType { switch colType {
case "CHAR", "NCHAR", "VARCHAR", "VARCHAR2", "NVARCHAR2", "LONG", "CLOB", "NCLOB": case "CHAR", "NCHAR", "VARCHAR", "VARCHAR2", "NVARCHAR2", "LONG", "CLOB", "NCLOB":
var s sql.NullString var s sql.NullString

18
dialects/postgres.go
View File

@ -998,13 +998,13 @@ func (db *postgres) AutoIncrStr() string {
return "" return ""
} }
func (db *postgres) IndexCheckSQL(tableName, idxName string) (string, []interface{}) { func (db *postgres) IndexCheckSQL(tableName, idxName string) (string, []any) {
if len(db.getSchema()) == 0 { if len(db.getSchema()) == 0 {
args := []interface{}{tableName, idxName} args := []any{tableName, idxName}
return `SELECT indexname FROM pg_indexes WHERE tablename = ? AND indexname = ?`, args return `SELECT indexname FROM pg_indexes WHERE tablename = ? AND indexname = ?`, args
} }
args := []interface{}{db.getSchema(), tableName, idxName} args := []any{db.getSchema(), tableName, idxName}
return `SELECT indexname FROM pg_indexes ` + return `SELECT indexname FROM pg_indexes ` +
`WHERE schemaname = ? AND tablename = ? AND indexname = ?`, args `WHERE schemaname = ? AND tablename = ? AND indexname = ?`, args
} }
@ -1071,11 +1071,11 @@ func (db *postgres) DropIndexSQL(tableName string, index *schemas.Index) string
} }
func (db *postgres) IsColumnExist(queryer core.Queryer, ctx context.Context, tableName, colName string) (bool, error) { func (db *postgres) IsColumnExist(queryer core.Queryer, ctx context.Context, tableName, colName string) (bool, error) {
args := []interface{}{db.getSchema(), tableName, colName} args := []any{db.getSchema(), tableName, colName}
query := "SELECT column_name FROM INFORMATION_SCHEMA.COLUMNS WHERE table_schema = $1 AND table_name = $2" + query := "SELECT column_name FROM INFORMATION_SCHEMA.COLUMNS WHERE table_schema = $1 AND table_name = $2" +
" AND column_name = $3" " AND column_name = $3"
if len(db.getSchema()) == 0 { if len(db.getSchema()) == 0 {
args = []interface{}{tableName, colName} args = []any{tableName, colName}
query = "SELECT column_name FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name = $1" + query = "SELECT column_name FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name = $1" +
" AND column_name = $2" " AND column_name = $2"
} }
@ -1093,7 +1093,7 @@ func (db *postgres) IsColumnExist(queryer core.Queryer, ctx context.Context, tab
} }
func (db *postgres) GetColumns(queryer core.Queryer, ctx context.Context, tableName string) ([]string, map[string]*schemas.Column, error) { func (db *postgres) GetColumns(queryer core.Queryer, ctx context.Context, tableName string) ([]string, map[string]*schemas.Column, error) {
args := []interface{}{tableName} args := []any{tableName}
s := `SELECT column_name, column_default, is_nullable, data_type, character_maximum_length, description, s := `SELECT column_name, column_default, is_nullable, data_type, character_maximum_length, description,
CASE WHEN p.contype = 'p' THEN true ELSE false END AS primarykey, CASE WHEN p.contype = 'p' THEN true ELSE false END AS primarykey,
CASE WHEN p.contype = 'u' THEN true ELSE false END AS uniquekey CASE WHEN p.contype = 'u' THEN true ELSE false END AS uniquekey
@ -1246,7 +1246,7 @@ WHERE n.nspname= s.table_schema AND c.relkind = 'r' AND c.relname = $1%s AND f.a
} }
func (db *postgres) GetTables(queryer core.Queryer, ctx context.Context) ([]*schemas.Table, error) { func (db *postgres) GetTables(queryer core.Queryer, ctx context.Context) ([]*schemas.Table, error) {
args := []interface{}{} args := []any{}
s := "SELECT tablename FROM pg_tables" s := "SELECT tablename FROM pg_tables"
schema := db.getSchema() schema := db.getSchema()
if schema != "" { if schema != "" {
@ -1289,7 +1289,7 @@ func getIndexColName(indexdef string) []string {
} }
func (db *postgres) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) { func (db *postgres) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) {
args := []interface{}{tableName} args := []any{tableName}
s := "SELECT indexname, indexdef FROM pg_indexes WHERE tablename=$1" s := "SELECT indexname, indexdef FROM pg_indexes WHERE tablename=$1"
if len(db.getSchema()) != 0 { if len(db.getSchema()) != 0 {
args = append(args, db.getSchema()) args = append(args, db.getSchema())
@ -1522,7 +1522,7 @@ func (p *pqDriver) Parse(driverName, dataSourceName string) (*URI, error) {
return db, nil return db, nil
} }
func (p *pqDriver) GenScanResult(colType string) (interface{}, error) { func (p *pqDriver) GenScanResult(colType string) (any, error) {
switch colType { switch colType {
case "VARCHAR", "TEXT": case "VARCHAR", "TEXT":
var s sql.NullString var s sql.NullString

12
dialects/sqlite3.go
View File

@ -267,8 +267,8 @@ func (db *sqlite3) AutoIncrStr() string {
return "AUTOINCREMENT" return "AUTOINCREMENT"
} }
func (db *sqlite3) IndexCheckSQL(tableName, idxName string) (string, []interface{}) { func (db *sqlite3) IndexCheckSQL(tableName, idxName string) (string, []any) {
args := []interface{}{idxName} args := []any{idxName}
return "SELECT name FROM sqlite_master WHERE type='index' and name = ?", args return "SELECT name FROM sqlite_master WHERE type='index' and name = ?", args
} }
@ -376,7 +376,7 @@ func parseString(colStr string) (*schemas.Column, error) {
} }
func (db *sqlite3) GetColumns(queryer core.Queryer, ctx context.Context, tableName string) ([]string, map[string]*schemas.Column, error) { func (db *sqlite3) GetColumns(queryer core.Queryer, ctx context.Context, tableName string) ([]string, map[string]*schemas.Column, error) {
args := []interface{}{tableName} args := []any{tableName}
s := "SELECT sql FROM sqlite_master WHERE type='table' and name = ?" s := "SELECT sql FROM sqlite_master WHERE type='table' and name = ?"
rows, err := queryer.QueryContext(ctx, s, args...) rows, err := queryer.QueryContext(ctx, s, args...)
@ -435,7 +435,7 @@ func (db *sqlite3) GetColumns(queryer core.Queryer, ctx context.Context, tableNa
} }
func (db *sqlite3) GetTables(queryer core.Queryer, ctx context.Context) ([]*schemas.Table, error) { func (db *sqlite3) GetTables(queryer core.Queryer, ctx context.Context) ([]*schemas.Table, error) {
args := []interface{}{} args := []any{}
s := "SELECT name FROM sqlite_master WHERE type='table'" s := "SELECT name FROM sqlite_master WHERE type='table'"
rows, err := queryer.QueryContext(ctx, s, args...) rows, err := queryer.QueryContext(ctx, s, args...)
@ -463,7 +463,7 @@ func (db *sqlite3) GetTables(queryer core.Queryer, ctx context.Context) ([]*sche
} }
func (db *sqlite3) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) { func (db *sqlite3) GetIndexes(queryer core.Queryer, ctx context.Context, tableName string) (map[string]*schemas.Index, error) {
args := []interface{}{tableName} args := []any{tableName}
s := "SELECT sql FROM sqlite_master WHERE type='index' and tbl_name = ?" s := "SELECT sql FROM sqlite_master WHERE type='index' and tbl_name = ?"
rows, err := queryer.QueryContext(ctx, s, args...) rows, err := queryer.QueryContext(ctx, s, args...)
@ -547,7 +547,7 @@ func (p *sqlite3Driver) Parse(driverName, dataSourceName string) (*URI, error) {
return &URI{DBType: schemas.SQLITE, DBName: dataSourceName}, nil return &URI{DBType: schemas.SQLITE, DBName: dataSourceName}, nil
} }
func (p *sqlite3Driver) GenScanResult(colType string) (interface{}, error) { func (p *sqlite3Driver) GenScanResult(colType string) (any, error) {
switch colType { switch colType {
case "TEXT": case "TEXT":
var s sql.NullString var s sql.NullString

6
dialects/table_name.go
View File

@ -25,7 +25,7 @@ func TableNameWithSchema(dialect Dialect, tableName string) string {
} }
// TableNameNoSchema returns table name with given tableName // TableNameNoSchema returns table name with given tableName
func TableNameNoSchema(dialect Dialect, mapper names.Mapper, tableName interface{}) string { func TableNameNoSchema(dialect Dialect, mapper names.Mapper, tableName any) string {
quote := dialect.Quoter().Quote quote := dialect.Quoter().Quote
switch tt := tableName.(type) { switch tt := tableName.(type) {
case []string: case []string:
@ -37,7 +37,7 @@ func TableNameNoSchema(dialect Dialect, mapper names.Mapper, tableName interface
} else if len(tt) == 1 { } else if len(tt) == 1 {
return quote(tt[0]) return quote(tt[0])
} }
case []interface{}: case []any:
l := len(tt) l := len(tt)
var table string var table string
if l > 0 { if l > 0 {
@ -84,7 +84,7 @@ func TableNameNoSchema(dialect Dialect, mapper names.Mapper, tableName interface
} }
// FullTableName returns table name with quote and schema according parameter // FullTableName returns table name with quote and schema according parameter
func FullTableName(dialect Dialect, mapper names.Mapper, bean interface{}, includeSchema ...bool) string { func FullTableName(dialect Dialect, mapper names.Mapper, bean any, includeSchema ...bool) string {
tbName := TableNameNoSchema(dialect, mapper, bean) tbName := TableNameNoSchema(dialect, mapper, bean)
if len(includeSchema) > 0 && includeSchema[0] && !utils.IsSubQuery(tbName) { if len(includeSchema) > 0 && includeSchema[0] && !utils.IsSubQuery(tbName) {
tbName = TableNameWithSchema(dialect, tbName) tbName = TableNameWithSchema(dialect, tbName)

2
dialects/time.go
View File

@ -12,7 +12,7 @@ import (
) )
// FormatColumnTime format column time // FormatColumnTime format column time
func FormatColumnTime(dialect Dialect, dbLocation *time.Location, col *schemas.Column, t time.Time) (interface{}, error) { func FormatColumnTime(dialect Dialect, dbLocation *time.Location, col *schemas.Column, t time.Time) (any, error) {
if t.IsZero() { if t.IsZero() {
if col.Nullable { if col.Nullable {
return nil, nil return nil, nil

2
dialects/time_test.go
View File

@ -31,7 +31,7 @@ func TestFormatColumnTime(t *testing.T) {
location *time.Location location *time.Location
column *schemas.Column column *schemas.Column
time time.Time time time.Time
wantRes interface{} wantRes any
wantErr error wantErr error
}{ }{
{ {

4
doc.go
View File

@ -32,7 +32,7 @@ XORM supports raw SQL execution:
results, err := engine.QueryString("select * from user") results, err := engine.QueryString("select * from user")
3. query with a SQL string, the returned results is []map[string]interface{} 3. query with a SQL string, the returned results is []map[string]any
results, err := engine.QueryInterface("select * from user") results, err := engine.QueryInterface("select * from user")
@ -88,7 +88,7 @@ There are 8 major ORM methods and many helpful methods to use to operate databas
4. Query multiple records and record by record handle, there two methods, one is Iterate, 4. Query multiple records and record by record handle, there two methods, one is Iterate,
another is Rows another is Rows
err := engine.Iterate(new(User), func(i int, bean interface{}) error { err := engine.Iterate(new(User), func(i int, bean any) error {
// do something // do something
}) })
// SELECT * FROM user // SELECT * FROM user

92
engine.go
View File

@ -149,7 +149,7 @@ func (engine *Engine) Logger() log.ContextLogger {
} }
// SetLogger set the new logger // SetLogger set the new logger
func (engine *Engine) SetLogger(logger interface{}) { func (engine *Engine) SetLogger(logger any) {
var realLogger log.ContextLogger var realLogger log.ContextLogger
switch t := logger.(type) { switch t := logger.(type) {
case log.ContextLogger: case log.ContextLogger:
@ -285,7 +285,7 @@ func (engine *Engine) Ping() error {
// engine.SQL("select * from user").Find(&users) // engine.SQL("select * from user").Find(&users)
// //
// This code will execute "select * from user" and set the records to 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 := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.SQL(query, args...) return session.SQL(query, args...)
@ -781,28 +781,28 @@ func (engine *Engine) Cascade(trueOrFalse ...bool) *Session {
} }
// Where method provide a condition query // 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 := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.Where(query, args...) return session.Where(query, args...)
} }
// ID method provoide a condition as (id) = ? // 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 := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.ID(id) return session.ID(id)
} }
// Before apply before Processor, affected bean is passed to closure arg // 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 := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.Before(closures) return session.Before(closures)
} }
// After apply after insert Processor, affected bean is passed to closure arg // 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 := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.After(closures) return session.After(closures)
@ -883,42 +883,42 @@ func (engine *Engine) Nullable(columns ...string) *Session {
} }
// In will generate "column IN (?, ?)" // In will generate "column IN (?, ?)"
func (engine *Engine) In(column string, args ...interface{}) *Session { func (engine *Engine) In(column string, args ...any) *Session {
session := engine.NewSession() session := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.In(column, args...) return session.In(column, args...)
} }
// NotIn will generate "column NOT IN (?, ?)" // NotIn will generate "column NOT IN (?, ?)"
func (engine *Engine) NotIn(column string, args ...interface{}) *Session { func (engine *Engine) NotIn(column string, args ...any) *Session {
session := engine.NewSession() session := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.NotIn(column, args...) return session.NotIn(column, args...)
} }
// Incr provides a update string like "column = column + ?" // Incr provides a update string like "column = column + ?"
func (engine *Engine) Incr(column string, arg ...interface{}) *Session { func (engine *Engine) Incr(column string, arg ...any) *Session {
session := engine.NewSession() session := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.Incr(column, arg...) return session.Incr(column, arg...)
} }
// Decr provides a update string like "column = column - ?" // Decr provides a update string like "column = column - ?"
func (engine *Engine) Decr(column string, arg ...interface{}) *Session { func (engine *Engine) Decr(column string, arg ...any) *Session {
session := engine.NewSession() session := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.Decr(column, arg...) return session.Decr(column, arg...)
} }
// SetExpr provides a update string like "column = {expression}" // SetExpr provides a update string like "column = {expression}"
func (engine *Engine) SetExpr(column string, expression interface{}) *Session { func (engine *Engine) SetExpr(column string, expression any) *Session {
session := engine.NewSession() session := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.SetExpr(column, expression) return session.SetExpr(column, expression)
} }
// Table temporarily change the Get, Find, Update's table // 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 := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.Table(tableNameOrBean) return session.Table(tableNameOrBean)
@ -957,7 +957,7 @@ func (engine *Engine) Asc(colNames ...string) *Session {
} }
// OrderBy will generate "ORDER BY order" // OrderBy will generate "ORDER BY order"
func (engine *Engine) OrderBy(order interface{}, args ...interface{}) *Session { func (engine *Engine) OrderBy(order any, args ...any) *Session {
session := engine.NewSession() session := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.OrderBy(order, args...) return session.OrderBy(order, args...)
@ -971,7 +971,7 @@ func (engine *Engine) Prepare() *Session {
} }
// Join the join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN // Join the join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN
func (engine *Engine) Join(joinOperator string, tablename interface{}, condition interface{}, args ...interface{}) *Session { func (engine *Engine) Join(joinOperator string, tablename any, condition any, args ...any) *Session {
session := engine.NewSession() session := engine.NewSession()
session.isAutoClose = true session.isAutoClose = true
return session.Join(joinOperator, tablename, condition, args...) return session.Join(joinOperator, tablename, condition, args...)
@ -997,39 +997,39 @@ func (engine *Engine) DBVersion() (*schemas.Version, error) {
} }
// TableInfo get table info according to bean's content // TableInfo get table info according to bean's content
func (engine *Engine) TableInfo(bean interface{}) (*schemas.Table, error) { func (engine *Engine) TableInfo(bean any) (*schemas.Table, error) {
v := utils.ReflectValue(bean) v := utils.ReflectValue(bean)
return engine.tagParser.ParseWithCache(v) return engine.tagParser.ParseWithCache(v)
} }
// IsTableEmpty if a table has any reocrd // IsTableEmpty if a table has any reocrd
func (engine *Engine) IsTableEmpty(bean interface{}) (bool, error) { func (engine *Engine) IsTableEmpty(bean any) (bool, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.IsTableEmpty(bean) return session.IsTableEmpty(bean)
} }
// IsTableExist if a table is exist // 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() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.IsTableExist(beanOrTableName) return session.IsTableExist(beanOrTableName)
} }
// TableName returns table name with schema prefix if has // 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 {
return dialects.FullTableName(engine.dialect, engine.GetTableMapper(), bean, includeSchema...) return dialects.FullTableName(engine.dialect, engine.GetTableMapper(), bean, includeSchema...)
} }
// CreateIndexes create indexes // CreateIndexes create indexes
func (engine *Engine) CreateIndexes(bean interface{}) error { func (engine *Engine) CreateIndexes(bean any) error {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.CreateIndexes(bean) return session.CreateIndexes(bean)
} }
// CreateUniques create uniques // CreateUniques create uniques
func (engine *Engine) CreateUniques(bean interface{}) error { func (engine *Engine) CreateUniques(bean any) error {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.CreateUniques(bean) return session.CreateUniques(bean)
@ -1041,7 +1041,7 @@ func (engine *Engine) UnMapType(t reflect.Type) {
} }
// CreateTables create tabls according bean // CreateTables create tabls according bean
func (engine *Engine) CreateTables(beans ...interface{}) error { func (engine *Engine) CreateTables(beans ...any) error {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
@ -1061,7 +1061,7 @@ func (engine *Engine) CreateTables(beans ...interface{}) error {
} }
// DropTables drop specify tables // DropTables drop specify tables
func (engine *Engine) DropTables(beans ...interface{}) error { func (engine *Engine) DropTables(beans ...any) error {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
@ -1081,49 +1081,49 @@ func (engine *Engine) DropTables(beans ...interface{}) error {
} }
// DropIndexes drop indexes of a table // DropIndexes drop indexes of a table
func (engine *Engine) DropIndexes(bean interface{}) error { func (engine *Engine) DropIndexes(bean any) error {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.DropIndexes(bean) return session.DropIndexes(bean)
} }
// Exec raw sql // Exec raw sql
func (engine *Engine) Exec(sqlOrArgs ...interface{}) (sql.Result, error) { func (engine *Engine) Exec(sqlOrArgs ...any) (sql.Result, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Exec(sqlOrArgs...) return session.Exec(sqlOrArgs...)
} }
// Query a raw sql and return records as []map[string][]byte // Query a raw sql and return records as []map[string][]byte
func (engine *Engine) Query(sqlOrArgs ...interface{}) (resultsSlice []map[string][]byte, err error) { func (engine *Engine) Query(sqlOrArgs ...any) (resultsSlice []map[string][]byte, err error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Query(sqlOrArgs...) return session.Query(sqlOrArgs...)
} }
// QueryString runs a raw sql and return records as []map[string]string // QueryString runs a raw sql and return records as []map[string]string
func (engine *Engine) QueryString(sqlOrArgs ...interface{}) ([]map[string]string, error) { func (engine *Engine) QueryString(sqlOrArgs ...any) ([]map[string]string, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.QueryString(sqlOrArgs...) return session.QueryString(sqlOrArgs...)
} }
// QueryInterface runs a raw sql and return records as []map[string]interface{} // QueryInterface runs a raw sql and return records as []map[string]any
func (engine *Engine) QueryInterface(sqlOrArgs ...interface{}) ([]map[string]interface{}, error) { func (engine *Engine) QueryInterface(sqlOrArgs ...any) ([]map[string]any, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.QueryInterface(sqlOrArgs...) return session.QueryInterface(sqlOrArgs...)
} }
// Insert one or more records // Insert one or more records
func (engine *Engine) Insert(beans ...interface{}) (int64, error) { func (engine *Engine) Insert(beans ...any) (int64, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Insert(beans...) return session.Insert(beans...)
} }
// InsertOne insert only one record // InsertOne insert only one record
func (engine *Engine) InsertOne(bean interface{}) (int64, error) { func (engine *Engine) InsertOne(bean any) (int64, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.InsertOne(bean) return session.InsertOne(bean)
@ -1136,7 +1136,7 @@ func (engine *Engine) InsertOne(bean interface{}) (int64, error) {
// 1.bool will defaultly be updated content nor conditions // 1.bool will defaultly be updated content nor conditions
// You should call UseBool if you have bool to use. // You should call UseBool if you have bool to use.
// 2.float32 & float64 may be not inexact as conditions // 2.float32 & float64 may be not inexact as conditions
func (engine *Engine) Update(bean interface{}, condiBeans ...interface{}) (int64, error) { func (engine *Engine) Update(bean any, condiBeans ...any) (int64, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Update(bean, condiBeans...) return session.Update(bean, condiBeans...)
@ -1144,7 +1144,7 @@ func (engine *Engine) Update(bean interface{}, condiBeans ...interface{}) (int64
// Delete records, bean's non-empty fields are conditions // Delete records, bean's non-empty fields are conditions
// At least one condition must be set. // At least one condition must be set.
func (engine *Engine) Delete(beans ...interface{}) (int64, error) { func (engine *Engine) Delete(beans ...any) (int64, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Delete(beans...) return session.Delete(beans...)
@ -1152,7 +1152,7 @@ func (engine *Engine) Delete(beans ...interface{}) (int64, error) {
// Truncate records, bean's non-empty fields are conditions // Truncate records, bean's non-empty fields are conditions
// In contrast to Delete this method allows deletes without conditions. // In contrast to Delete this method allows deletes without conditions.
func (engine *Engine) Truncate(beans ...interface{}) (int64, error) { func (engine *Engine) Truncate(beans ...any) (int64, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Truncate(beans...) return session.Truncate(beans...)
@ -1160,14 +1160,14 @@ func (engine *Engine) Truncate(beans ...interface{}) (int64, error) {
// Get retrieve one record from table, bean's non-empty fields // Get retrieve one record from table, bean's non-empty fields
// are conditions // are conditions
func (engine *Engine) Get(beans ...interface{}) (bool, error) { func (engine *Engine) Get(beans ...any) (bool, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Get(beans...) return session.Get(beans...)
} }
// Exist returns true if the record exist otherwise return false // Exist returns true if the record exist otherwise return false
func (engine *Engine) Exist(bean ...interface{}) (bool, error) { func (engine *Engine) Exist(bean ...any) (bool, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Exist(bean...) return session.Exist(bean...)
@ -1176,14 +1176,14 @@ func (engine *Engine) Exist(bean ...interface{}) (bool, error) {
// Find retrieve records from table, condiBeans's non-empty fields // Find retrieve records from table, condiBeans's non-empty fields
// are conditions. beans could be []Struct, []*Struct, map[int64]Struct // are conditions. beans could be []Struct, []*Struct, map[int64]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() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Find(beans, condiBeans...) return session.Find(beans, condiBeans...)
} }
// FindAndCount find the results and also return the counts // FindAndCount find the results and also return the counts
func (engine *Engine) FindAndCount(rowsSlicePtr interface{}, condiBean ...interface{}) (int64, error) { func (engine *Engine) FindAndCount(rowsSlicePtr any, condiBean ...any) (int64, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.FindAndCount(rowsSlicePtr, condiBean...) return session.FindAndCount(rowsSlicePtr, condiBean...)
@ -1191,7 +1191,7 @@ func (engine *Engine) FindAndCount(rowsSlicePtr interface{}, condiBean ...interf
// Iterate record by record handle records from table, bean's non-empty fields // Iterate record by record handle records from table, bean's non-empty fields
// are conditions. // are conditions.
func (engine *Engine) Iterate(bean interface{}, fun IterFunc) error { func (engine *Engine) Iterate(bean any, fun IterFunc) error {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Iterate(bean, fun) return session.Iterate(bean, fun)
@ -1199,41 +1199,41 @@ func (engine *Engine) Iterate(bean interface{}, fun IterFunc) error {
// Rows return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields // Rows return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields
// are conditions. // are conditions.
func (engine *Engine) Rows(bean interface{}) (*Rows, error) { func (engine *Engine) Rows(bean any) (*Rows, error) {
session := engine.NewSession() session := engine.NewSession()
return session.Rows(bean) return session.Rows(bean)
} }
// Count counts the records. bean's non-empty fields are conditions. // Count counts the records. bean's non-empty fields are conditions.
func (engine *Engine) Count(bean ...interface{}) (int64, error) { func (engine *Engine) Count(bean ...any) (int64, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Count(bean...) return session.Count(bean...)
} }
// Sum sum the records by some column. bean's non-empty fields are conditions. // Sum sum the records by some column. bean's non-empty fields are conditions.
func (engine *Engine) Sum(bean interface{}, colName string) (float64, error) { func (engine *Engine) Sum(bean any, colName string) (float64, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Sum(bean, colName) return session.Sum(bean, colName)
} }
// SumInt sum the records by some column. bean's non-empty fields are conditions. // SumInt sum the records by some column. bean's non-empty fields are conditions.
func (engine *Engine) SumInt(bean interface{}, colName string) (int64, error) { func (engine *Engine) SumInt(bean any, colName string) (int64, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.SumInt(bean, colName) return session.SumInt(bean, colName)
} }
// Sums sum the records by some columns. bean's non-empty fields are conditions. // Sums sum the records by some columns. bean's non-empty fields are conditions.
func (engine *Engine) Sums(bean interface{}, colNames ...string) ([]float64, error) { func (engine *Engine) Sums(bean any, colNames ...string) ([]float64, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Sums(bean, colNames...) return session.Sums(bean, colNames...)
} }
// SumsInt like Sums but return slice of int64 instead of float64. // SumsInt like Sums but return slice of int64 instead of float64.
func (engine *Engine) SumsInt(bean interface{}, colNames ...string) ([]int64, error) { func (engine *Engine) SumsInt(bean any, colNames ...string) ([]int64, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.SumsInt(bean, colNames...) return session.SumsInt(bean, colNames...)
@ -1254,7 +1254,7 @@ func (engine *Engine) Import(r io.Reader) ([]sql.Result, error) {
} }
// nowTime return current time // nowTime return current time
func (engine *Engine) nowTime(col *schemas.Column) (interface{}, time.Time, error) { func (engine *Engine) nowTime(col *schemas.Column) (any, time.Time, error) {
t := time.Now() t := time.Now()
result, err := dialects.FormatColumnTime(engine.dialect, engine.DatabaseTZ, col, t) result, err := dialects.FormatColumnTime(engine.dialect, engine.DatabaseTZ, col, t)
if err != nil { if err != nil {
@ -1334,7 +1334,7 @@ func (engine *Engine) PingContext(ctx context.Context) error {
} }
// Transaction Execute sql wrapped in a transaction(abbr as tx), tx will automatic commit if no errors occurred // Transaction Execute sql wrapped in a transaction(abbr as tx), tx will automatic commit if no errors occurred
func (engine *Engine) Transaction(f func(*Session) (interface{}, error)) (interface{}, error) { func (engine *Engine) Transaction(f func(*Session) (any, error)) (any, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()

12
engine_group.go
View File

@ -22,7 +22,7 @@ type EngineGroup struct {
} }
// NewEngineGroup creates a new engine group // NewEngineGroup creates a new engine group
func NewEngineGroup(args1 interface{}, args2 interface{}, policies ...GroupPolicy) (*EngineGroup, error) { func NewEngineGroup(args1 any, args2 any, policies ...GroupPolicy) (*EngineGroup, error) {
var eg EngineGroup var eg EngineGroup
if len(policies) > 0 { if len(policies) > 0 {
eg.policy = policies[0] eg.policy = policies[0]
@ -128,7 +128,7 @@ func (eg *EngineGroup) SetConnMaxLifetime(d time.Duration) {
} }
// SetLogger set the new logger // SetLogger set the new logger
func (eg *EngineGroup) SetLogger(logger interface{}) { func (eg *EngineGroup) SetLogger(logger any) {
eg.Engine.SetLogger(logger) eg.Engine.SetLogger(logger)
for i := 0; i < len(eg.slaves); i++ { for i := 0; i < len(eg.slaves); i++ {
eg.slaves[i].SetLogger(logger) eg.slaves[i].SetLogger(logger)
@ -230,28 +230,28 @@ func (eg *EngineGroup) Slaves() []*Engine {
} }
// Query execcute a select SQL and return the result // Query execcute a select SQL and return the result
func (eg *EngineGroup) Query(sqlOrArgs ...interface{}) (resultsSlice []map[string][]byte, err error) { func (eg *EngineGroup) Query(sqlOrArgs ...any) (resultsSlice []map[string][]byte, err error) {
sess := eg.NewSession() sess := eg.NewSession()
sess.isAutoClose = true sess.isAutoClose = true
return sess.Query(sqlOrArgs...) return sess.Query(sqlOrArgs...)
} }
// QueryInterface execcute a select SQL and return the result // QueryInterface execcute a select SQL and return the result
func (eg *EngineGroup) QueryInterface(sqlOrArgs ...interface{}) ([]map[string]interface{}, error) { func (eg *EngineGroup) QueryInterface(sqlOrArgs ...any) ([]map[string]any, error) {
sess := eg.NewSession() sess := eg.NewSession()
sess.isAutoClose = true sess.isAutoClose = true
return sess.QueryInterface(sqlOrArgs...) return sess.QueryInterface(sqlOrArgs...)
} }
// QueryString execcute a select SQL and return the result // QueryString execcute a select SQL and return the result
func (eg *EngineGroup) QueryString(sqlOrArgs ...interface{}) ([]map[string]string, error) { func (eg *EngineGroup) QueryString(sqlOrArgs ...any) ([]map[string]string, error) {
sess := eg.NewSession() sess := eg.NewSession()
sess.isAutoClose = true sess.isAutoClose = true
return sess.QueryString(sqlOrArgs...) return sess.QueryString(sqlOrArgs...)
} }
// Rows execcute a select SQL and return the result // Rows execcute a select SQL and return the result
func (eg *EngineGroup) Rows(bean interface{}) (*Rows, error) { func (eg *EngineGroup) Rows(bean any) (*Rows, error) {
sess := eg.NewSession() sess := eg.NewSession()
sess.isAutoClose = true sess.isAutoClose = true
return sess.Rows(bean) return sess.Rows(bean)

8
find.go
View File

@ -25,7 +25,7 @@ const (
// Find retrieve records from table, condiBeans's non-empty fields // Find retrieve records from table, condiBeans's non-empty fields
// are conditions. beans could be []Struct, []*Struct, map[int64]Struct // are conditions. beans could be []Struct, []*Struct, map[int64]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 { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -33,7 +33,7 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
} }
// FindAndCount find the results and also return the counts // 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 { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -77,7 +77,7 @@ func (session *Session) FindAndCount(rowsSlicePtr interface{}, condiBean ...inte
return session.Unscoped().Count() return session.Unscoped().Count()
} }
func (session *Session) find(rowsSlicePtr interface{}, condiBean ...interface{}) error { func (session *Session) find(rowsSlicePtr any, condiBean ...any) error {
defer session.resetStatement() defer session.resetStatement()
if session.statement.LastError != nil { if session.statement.LastError != nil {
return session.statement.LastError return session.statement.LastError
@ -208,7 +208,7 @@ func ParseColumnsSchema(fieldNames []string, types []*sql.ColumnType, table *sch
return &columnsSchema return &columnsSchema
} }
func (session *Session) noCacheFind(table *schemas.Table, containerValue reflect.Value, sqlStr string, args ...interface{}) error { func (session *Session) noCacheFind(table *schemas.Table, containerValue reflect.Value, sqlStr string, args ...any) error {
elemType := containerValue.Type().Elem() elemType := containerValue.Type().Elem()
var isPointer bool var isPointer bool
if elemType.Kind() == reflect.Ptr { if elemType.Kind() == reflect.Ptr {

24
get.go
View File

@ -23,14 +23,14 @@ var ErrObjectIsNil = errors.New("object should not be nil")
// Get retrieve one record from database, bean's non-empty fields // Get retrieve one record from database, bean's non-empty fields
// will be as conditions // will be as conditions
func (session *Session) Get(beans ...interface{}) (bool, error) { func (session *Session) Get(beans ...any) (bool, error) {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
return session.get(beans...) return session.get(beans...)
} }
func isPtrOfTime(v interface{}) bool { func isPtrOfTime(v any) bool {
if _, ok := v.(*time.Time); ok { if _, ok := v.(*time.Time); ok {
return true return true
} }
@ -43,7 +43,7 @@ func isPtrOfTime(v interface{}) bool {
return el.Type().ConvertibleTo(schemas.TimeType) return el.Type().ConvertibleTo(schemas.TimeType)
} }
func (session *Session) get(beans ...interface{}) (bool, error) { func (session *Session) get(beans ...any) (bool, error) {
defer session.resetStatement() defer session.resetStatement()
if session.statement.LastError != nil { if session.statement.LastError != nil {
@ -70,7 +70,7 @@ func (session *Session) get(beans ...interface{}) (bool, error) {
} }
var sqlStr string var sqlStr string
var args []interface{} var args []any
var err error var err error
if session.statement.RawSQL == "" { if session.statement.RawSQL == "" {
@ -114,7 +114,7 @@ func (session *Session) get(beans ...interface{}) (bool, error) {
return true, nil return true, nil
} }
func isScannableStruct(bean interface{}, typeLen int) bool { func isScannableStruct(bean any, typeLen int) bool {
switch bean.(type) { switch bean.(type) {
case *time.Time: case *time.Time:
return false return false
@ -128,7 +128,7 @@ func isScannableStruct(bean interface{}, typeLen int) bool {
return true return true
} }
func (session *Session) nocacheGet(beanKind reflect.Kind, table *schemas.Table, beans []interface{}, sqlStr string, args ...interface{}) (bool, error) { func (session *Session) nocacheGet(beanKind reflect.Kind, table *schemas.Table, beans []any, sqlStr string, args ...any) (bool, error) {
rows, err := session.queryRows(sqlStr, args...) rows, err := session.queryRows(sqlStr, args...)
if err != nil { if err != nil {
return false, err return false, err
@ -159,7 +159,7 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, table *schemas.Table,
return true, session.executeProcessors() return true, session.executeProcessors()
} }
func (session *Session) scan(rows *core.Rows, table *schemas.Table, firstBeanKind reflect.Kind, beans []interface{}, columnsSchema *ColumnsSchema, types []*sql.ColumnType, fields []string) error { func (session *Session) scan(rows *core.Rows, table *schemas.Table, firstBeanKind reflect.Kind, beans []any, columnsSchema *ColumnsSchema, types []*sql.ColumnType, fields []string) error {
if len(beans) == 1 { if len(beans) == 1 {
bean := beans[0] bean := beans[0]
switch firstBeanKind { switch firstBeanKind {
@ -189,7 +189,7 @@ func (session *Session) scan(rows *core.Rows, table *schemas.Table, firstBeanKin
return session.engine.scan(rows, fields, types, beans...) return session.engine.scan(rows, fields, types, beans...)
} }
func (session *Session) getSlice(rows *core.Rows, types []*sql.ColumnType, fields []string, bean interface{}) error { func (session *Session) getSlice(rows *core.Rows, types []*sql.ColumnType, fields []string, bean any) error {
switch t := bean.(type) { switch t := bean.(type) {
case *[]string: case *[]string:
res, err := session.engine.scanStringInterface(rows, fields, types) res, err := session.engine.scanStringInterface(rows, fields, types)
@ -206,7 +206,7 @@ func (session *Session) getSlice(rows *core.Rows, types []*sql.ColumnType, field
} }
} }
return nil return nil
case *[]interface{}: case *[]any:
scanResults, err := session.engine.scanInterfaces(rows, fields, types) scanResults, err := session.engine.scanInterfaces(rows, fields, types)
if err != nil { if err != nil {
return err return err
@ -229,7 +229,7 @@ func (session *Session) getSlice(rows *core.Rows, types []*sql.ColumnType, field
} }
} }
func (session *Session) getMap(rows *core.Rows, types []*sql.ColumnType, fields []string, bean interface{}) error { func (session *Session) getMap(rows *core.Rows, types []*sql.ColumnType, fields []string, bean any) error {
switch t := bean.(type) { switch t := bean.(type) {
case *map[string]string: case *map[string]string:
scanResults, err := session.engine.scanStringInterface(rows, fields, types) scanResults, err := session.engine.scanStringInterface(rows, fields, types)
@ -240,7 +240,7 @@ func (session *Session) getMap(rows *core.Rows, types []*sql.ColumnType, fields
(*t)[key] = scanResults[ii].(*sql.NullString).String (*t)[key] = scanResults[ii].(*sql.NullString).String
} }
return nil return nil
case *map[string]interface{}: case *map[string]any:
scanResults, err := session.engine.scanInterfaces(rows, fields, types) scanResults, err := session.engine.scanInterfaces(rows, fields, types)
if err != nil { if err != nil {
return err return err
@ -259,7 +259,7 @@ func (session *Session) getMap(rows *core.Rows, types []*sql.ColumnType, fields
} }
// Exist returns true if the record exist otherwise return false // 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 { if session.isAutoClose {
defer session.Close() defer session.Close()
} }

62
insert.go
View File

@ -26,7 +26,7 @@ var ErrNoElementsOnSlice = errors.New("no element on slice when insert")
var ErrPtrSliceType = errors.New("A point to a slice is needed") var ErrPtrSliceType = errors.New("A point to a slice is needed")
// Insert insert one or more beans // 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 affected int64
var err error var err error
@ -44,9 +44,9 @@ func (session *Session) Insert(beans ...interface{}) (int64, error) {
var cnt int64 var cnt int64
var err error var err error
switch v := bean.(type) { switch v := bean.(type) {
case map[string]interface{}: case map[string]any:
cnt, err = session.insertMapInterface(v) cnt, err = session.insertMapInterface(v)
case []map[string]interface{}: case []map[string]any:
cnt, err = session.insertMultipleMapInterface(v) cnt, err = session.insertMultipleMapInterface(v)
case map[string]string: case map[string]string:
cnt, err = session.insertMapString(v) cnt, err = session.insertMapString(v)
@ -69,7 +69,7 @@ func (session *Session) Insert(beans ...interface{}) (int64, error) {
return affected, err return affected, err
} }
func (session *Session) insertMultipleStruct(rowsSlicePtr interface{}) (int64, error) { func (session *Session) insertMultipleStruct(rowsSlicePtr any) (int64, error) {
sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr)) sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr))
if sliceValue.Kind() != reflect.Slice { if sliceValue.Kind() != reflect.Slice {
return 0, errors.New("needs a pointer to a slice") return 0, errors.New("needs a pointer to a slice")
@ -93,7 +93,7 @@ func (session *Session) insertMultipleStruct(rowsSlicePtr interface{}) (int64, e
size = sliceValue.Len() size = sliceValue.Len()
colNames []string colNames []string
colMultiPlaces []string colMultiPlaces []string
args []interface{} args []any
) )
for i := 0; i < size; i++ { for i := 0; i < size; i++ {
@ -114,7 +114,7 @@ func (session *Session) insertMultipleStruct(rowsSlicePtr interface{}) (int64, e
closure(elemValue) closure(elemValue)
} }
if processor, ok := interface{}(elemValue).(BeforeInsertProcessor); ok { if processor, ok := any(elemValue).(BeforeInsertProcessor); ok {
processor.BeforeInsert() processor.BeforeInsert()
} }
// -- // --
@ -161,14 +161,14 @@ func (session *Session) insertMultipleStruct(rowsSlicePtr interface{}) (int64, e
args = append(args, val) args = append(args, val)
colName := col.Name colName := col.Name
session.afterClosures = append(session.afterClosures, func(bean interface{}) { session.afterClosures = append(session.afterClosures, func(bean any) {
col := table.GetColumn(colName) col := table.GetColumn(colName)
setColumnTime(bean, col, t) setColumnTime(bean, col, t)
}) })
} else if col.IsVersion && session.statement.CheckVersion { } else if col.IsVersion && session.statement.CheckVersion {
args = append(args, 1) args = append(args, 1)
colName := col.Name colName := col.Name
session.afterClosures = append(session.afterClosures, func(bean interface{}) { session.afterClosures = append(session.afterClosures, func(bean any) {
col := table.GetColumn(colName) col := table.GetColumn(colName)
setColumnInt(bean, col, 1) setColumnInt(bean, col, 1)
}) })
@ -218,7 +218,7 @@ func (session *Session) insertMultipleStruct(rowsSlicePtr interface{}) (int64, e
if value, has := session.afterInsertBeans[elemValue]; has && value != nil { if value, has := session.afterInsertBeans[elemValue]; has && value != nil {
*value = append(*value, session.afterClosures...) *value = append(*value, session.afterClosures...)
} else { } else {
afterClosures := make([]func(interface{}), lenAfterClosures) afterClosures := make([]func(any), lenAfterClosures)
copy(afterClosures, session.afterClosures) copy(afterClosures, session.afterClosures)
session.afterInsertBeans[elemValue] = &afterClosures session.afterInsertBeans[elemValue] = &afterClosures
} }
@ -235,7 +235,7 @@ func (session *Session) insertMultipleStruct(rowsSlicePtr interface{}) (int64, e
} }
// InsertMulti insert multiple records // InsertMulti insert multiple records
func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error) { func (session *Session) InsertMulti(rowsSlicePtr any) (int64, error) {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -248,7 +248,7 @@ func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error) {
return session.insertMultipleStruct(rowsSlicePtr) return session.insertMultipleStruct(rowsSlicePtr)
} }
func (session *Session) insertStruct(bean interface{}) (int64, error) { func (session *Session) insertStruct(bean any) (int64, error) {
if err := session.statement.SetRefBean(bean); err != nil { if err := session.statement.SetRefBean(bean); err != nil {
return 0, err return 0, err
} }
@ -262,7 +262,7 @@ func (session *Session) insertStruct(bean interface{}) (int64, error) {
} }
cleanupProcessorsClosures(&session.beforeClosures) // cleanup after used cleanupProcessorsClosures(&session.beforeClosures) // cleanup after used
if processor, ok := interface{}(bean).(BeforeInsertProcessor); ok { if processor, ok := any(bean).(BeforeInsertProcessor); ok {
processor.BeforeInsert() processor.BeforeInsert()
} }
@ -280,12 +280,12 @@ func (session *Session) insertStruct(bean interface{}) (int64, error) {
} }
sqlStr = session.engine.dialect.Quoter().Replace(sqlStr) sqlStr = session.engine.dialect.Quoter().Replace(sqlStr)
handleAfterInsertProcessorFunc := func(bean interface{}) { handleAfterInsertProcessorFunc := func(bean any) {
if session.isAutoCommit { if session.isAutoCommit {
for _, closure := range session.afterClosures { for _, closure := range session.afterClosures {
closure(bean) closure(bean)
} }
if processor, ok := interface{}(bean).(AfterInsertProcessor); ok { if processor, ok := any(bean).(AfterInsertProcessor); ok {
processor.AfterInsert() processor.AfterInsert()
} }
} else { } else {
@ -294,12 +294,12 @@ func (session *Session) insertStruct(bean interface{}) (int64, error) {
if value, has := session.afterInsertBeans[bean]; has && value != nil { if value, has := session.afterInsertBeans[bean]; has && value != nil {
*value = append(*value, session.afterClosures...) *value = append(*value, session.afterClosures...)
} else { } else {
afterClosures := make([]func(interface{}), lenAfterClosures) afterClosures := make([]func(any), lenAfterClosures)
copy(afterClosures, session.afterClosures) copy(afterClosures, session.afterClosures)
session.afterInsertBeans[bean] = &afterClosures session.afterInsertBeans[bean] = &afterClosures
} }
} else { } else {
if _, ok := interface{}(bean).(AfterInsertProcessor); ok { if _, ok := any(bean).(AfterInsertProcessor); ok {
session.afterInsertBeans[bean] = nil session.afterInsertBeans[bean] = nil
} }
} }
@ -310,7 +310,7 @@ func (session *Session) insertStruct(bean interface{}) (int64, error) {
// if there is auto increment column and driver don't support return it // if there is auto increment column and driver don't support return it
if len(table.AutoIncrement) > 0 && !session.engine.driver.Features().SupportReturnInsertedID { if len(table.AutoIncrement) > 0 && !session.engine.driver.Features().SupportReturnInsertedID {
var sql string var sql string
var newArgs []interface{} var newArgs []any
var needCommit bool var needCommit bool
var id int64 var id int64
if session.engine.dialect.URI().DBType == schemas.ORACLE || session.engine.dialect.URI().DBType == schemas.DAMENG { if session.engine.dialect.URI().DBType == schemas.ORACLE || session.engine.dialect.URI().DBType == schemas.DAMENG {
@ -422,7 +422,7 @@ func (session *Session) insertStruct(bean interface{}) (int64, error) {
// The in parameter bean must a struct or a point to struct. The return // The in parameter bean must a struct or a point to struct. The return
// parameter is inserted and error // parameter is inserted and error
// Deprecated: Please use Insert directly // Deprecated: Please use Insert directly
func (session *Session) InsertOne(bean interface{}) (int64, error) { func (session *Session) InsertOne(bean any) (int64, error) {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -431,10 +431,10 @@ func (session *Session) InsertOne(bean interface{}) (int64, error) {
} }
// genInsertColumns generates insert needed columns // 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 table := session.statement.RefTable
colNames := make([]string, 0, len(table.ColumnsSeq())) 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() { for _, col := range table.Columns() {
if col.MapType == schemas.ONLYFROMDB { if col.MapType == schemas.ONLYFROMDB {
@ -491,7 +491,7 @@ func (session *Session) genInsertColumns(bean interface{}) ([]string, []interfac
args = append(args, val) args = append(args, val)
colName := col.Name colName := col.Name
session.afterClosures = append(session.afterClosures, func(bean interface{}) { session.afterClosures = append(session.afterClosures, func(bean any) {
col := table.GetColumn(colName) col := table.GetColumn(colName)
setColumnTime(bean, col, t) setColumnTime(bean, col, t)
}) })
@ -510,7 +510,7 @@ func (session *Session) genInsertColumns(bean interface{}) ([]string, []interfac
return colNames, args, nil 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 { if len(m) == 0 {
return 0, ErrParamsType return 0, ErrParamsType
} }
@ -529,7 +529,7 @@ func (session *Session) insertMapInterface(m map[string]interface{}) (int64, err
} }
sort.Strings(columns) sort.Strings(columns)
args := make([]interface{}, 0, len(m)) args := make([]any, 0, len(m))
for _, colName := range columns { for _, colName := range columns {
args = append(args, m[colName]) args = append(args, m[colName])
} }
@ -537,7 +537,7 @@ func (session *Session) insertMapInterface(m map[string]interface{}) (int64, err
return session.insertMap(columns, args) return session.insertMap(columns, args)
} }
func (session *Session) insertMultipleMapInterface(maps []map[string]interface{}) (int64, error) { func (session *Session) insertMultipleMapInterface(maps []map[string]any) (int64, error) {
if len(maps) == 0 { if len(maps) == 0 {
return 0, ErrNoElementsOnSlice return 0, ErrNoElementsOnSlice
} }
@ -556,9 +556,9 @@ func (session *Session) insertMultipleMapInterface(maps []map[string]interface{}
} }
sort.Strings(columns) sort.Strings(columns)
argss := make([][]interface{}, 0, len(maps)) argss := make([][]any, 0, len(maps))
for _, m := range maps { for _, m := range maps {
args := make([]interface{}, 0, len(m)) args := make([]any, 0, len(m))
for _, colName := range columns { for _, colName := range columns {
args = append(args, m[colName]) args = append(args, m[colName])
} }
@ -588,7 +588,7 @@ func (session *Session) insertMapString(m map[string]string) (int64, error) {
sort.Strings(columns) sort.Strings(columns)
args := make([]interface{}, 0, len(m)) args := make([]any, 0, len(m))
for _, colName := range columns { for _, colName := range columns {
args = append(args, m[colName]) args = append(args, m[colName])
} }
@ -615,9 +615,9 @@ func (session *Session) insertMultipleMapString(maps []map[string]string) (int64
} }
sort.Strings(columns) sort.Strings(columns)
argss := make([][]interface{}, 0, len(maps)) argss := make([][]any, 0, len(maps))
for _, m := range maps { for _, m := range maps {
args := make([]interface{}, 0, len(m)) args := make([]any, 0, len(m))
for _, colName := range columns { for _, colName := range columns {
args = append(args, m[colName]) args = append(args, m[colName])
} }
@ -627,7 +627,7 @@ func (session *Session) insertMultipleMapString(maps []map[string]string) (int64
return session.insertMultipleMap(columns, argss) return session.insertMultipleMap(columns, argss)
} }
func (session *Session) insertMap(columns []string, args []interface{}) (int64, error) { func (session *Session) insertMap(columns []string, args []any) (int64, error) {
tableName := session.statement.TableName() tableName := session.statement.TableName()
if len(tableName) == 0 { if len(tableName) == 0 {
return 0, ErrTableNotFound return 0, ErrTableNotFound
@ -650,7 +650,7 @@ func (session *Session) insertMap(columns []string, args []interface{}) (int64,
return affected, nil return affected, nil
} }
func (session *Session) insertMultipleMap(columns []string, argss [][]interface{}) (int64, error) { func (session *Session) insertMultipleMap(columns []string, argss [][]any) (int64, error) {
tableName := session.statement.TableName() tableName := session.statement.TableName()
if len(tableName) == 0 { if len(tableName) == 0 {
return 0, ErrTableNotFound return 0, ErrTableNotFound

90
interface.go
View File

@ -24,69 +24,69 @@ type Interface interface {
Asc(colNames ...string) *Session Asc(colNames ...string) *Session
BufferSize(size int) *Session BufferSize(size int) *Session
Cols(columns ...string) *Session Cols(columns ...string) *Session
Count(...interface{}) (int64, error) Count(...any) (int64, error)
CreateIndexes(bean interface{}) error CreateIndexes(bean any) error
CreateUniques(bean interface{}) error CreateUniques(bean any) error
Decr(column string, arg ...interface{}) *Session Decr(column string, arg ...any) *Session
Desc(...string) *Session Desc(...string) *Session
Delete(...interface{}) (int64, error) Delete(...any) (int64, error)
Truncate(...interface{}) (int64, error) Truncate(...any) (int64, error)
Distinct(columns ...string) *Session Distinct(columns ...string) *Session
DropIndexes(bean interface{}) error DropIndexes(bean any) error
Exec(sqlOrArgs ...interface{}) (sql.Result, error) Exec(sqlOrArgs ...any) (sql.Result, error)
Exist(bean ...interface{}) (bool, error) Exist(bean ...any) (bool, error)
Find(interface{}, ...interface{}) error Find(any, ...any) error
FindAndCount(interface{}, ...interface{}) (int64, error) FindAndCount(any, ...any) (int64, error)
Get(...interface{}) (bool, error) Get(...any) (bool, error)
GroupBy(keys string) *Session GroupBy(keys string) *Session
ID(interface{}) *Session ID(any) *Session
In(string, ...interface{}) *Session In(string, ...any) *Session
Incr(column string, arg ...interface{}) *Session Incr(column string, arg ...any) *Session
Insert(...interface{}) (int64, error) Insert(...any) (int64, error)
InsertOne(interface{}) (int64, error) InsertOne(any) (int64, error)
IsTableEmpty(bean interface{}) (bool, error) IsTableEmpty(bean any) (bool, error)
IsTableExist(beanOrTableName interface{}) (bool, error) IsTableExist(beanOrTableName any) (bool, error)
Iterate(interface{}, IterFunc) error Iterate(any, IterFunc) error
Limit(int, ...int) *Session Limit(int, ...int) *Session
MustCols(columns ...string) *Session MustCols(columns ...string) *Session
NoAutoCondition(...bool) *Session NoAutoCondition(...bool) *Session
NotIn(string, ...interface{}) *Session NotIn(string, ...any) *Session
Nullable(...string) *Session Nullable(...string) *Session
Join(joinOperator string, tablename interface{}, condition interface{}, args ...interface{}) *Session Join(joinOperator string, tablename any, condition any, args ...any) *Session
Omit(columns ...string) *Session Omit(columns ...string) *Session
OrderBy(order interface{}, args ...interface{}) *Session OrderBy(order any, args ...any) *Session
Ping() error Ping() error
Query(sqlOrArgs ...interface{}) (resultsSlice []map[string][]byte, err error) Query(sqlOrArgs ...any) (resultsSlice []map[string][]byte, err error)
QueryInterface(sqlOrArgs ...interface{}) ([]map[string]interface{}, error) QueryInterface(sqlOrArgs ...any) ([]map[string]any, error)
QueryString(sqlOrArgs ...interface{}) ([]map[string]string, error) QueryString(sqlOrArgs ...any) ([]map[string]string, error)
Rows(bean interface{}) (*Rows, error) Rows(bean any) (*Rows, error)
SetExpr(string, interface{}) *Session SetExpr(string, any) *Session
Select(string) *Session Select(string) *Session
SQL(interface{}, ...interface{}) *Session SQL(any, ...any) *Session
Sum(bean interface{}, colName string) (float64, error) Sum(bean any, colName string) (float64, error)
SumInt(bean interface{}, colName string) (int64, error) SumInt(bean any, colName string) (int64, error)
Sums(bean interface{}, colNames ...string) ([]float64, error) Sums(bean any, colNames ...string) ([]float64, error)
SumsInt(bean interface{}, colNames ...string) ([]int64, error) SumsInt(bean any, colNames ...string) ([]int64, error)
Table(tableNameOrBean interface{}) *Session Table(tableNameOrBean any) *Session
Unscoped() *Session Unscoped() *Session
Update(bean interface{}, condiBeans ...interface{}) (int64, error) Update(bean any, condiBeans ...any) (int64, error)
UseBool(...string) *Session UseBool(...string) *Session
Where(interface{}, ...interface{}) *Session Where(any, ...any) *Session
} }
// EngineInterface defines the interface which Engine, EngineGroup will implementate. // EngineInterface defines the interface which Engine, EngineGroup will implementate.
type EngineInterface interface { type EngineInterface interface {
Interface Interface
Before(func(interface{})) *Session Before(func(any)) *Session
Charset(charset string) *Session Charset(charset string) *Session
Context(context.Context) *Session Context(context.Context) *Session
CreateTables(...interface{}) error CreateTables(...any) error
DBMetas() ([]*schemas.Table, error) DBMetas() ([]*schemas.Table, error)
DBVersion() (*schemas.Version, error) DBVersion() (*schemas.Version, error)
Dialect() dialects.Dialect Dialect() dialects.Dialect
DriverName() string DriverName() string
DropTables(...interface{}) error DropTables(...any) error
DumpAllToFile(fp string, tp ...schemas.DBType) error DumpAllToFile(fp string, tp ...schemas.DBType) error
GetColumnMapper() names.Mapper GetColumnMapper() names.Mapper
GetTableMapper() names.Mapper GetTableMapper() names.Mapper
@ -100,7 +100,7 @@ type EngineInterface interface {
SetConnMaxLifetime(time.Duration) SetConnMaxLifetime(time.Duration)
SetColumnMapper(names.Mapper) SetColumnMapper(names.Mapper)
SetTagIdentifier(string) SetTagIdentifier(string)
SetLogger(logger interface{}) SetLogger(logger any)
SetLogLevel(log.LogLevel) SetLogLevel(log.LogLevel)
SetMapper(names.Mapper) SetMapper(names.Mapper)
SetMaxOpenConns(int) SetMaxOpenConns(int)
@ -112,12 +112,12 @@ type EngineInterface interface {
SetTZLocation(tz *time.Location) SetTZLocation(tz *time.Location)
AddHook(hook contexts.Hook) AddHook(hook contexts.Hook)
ShowSQL(show ...bool) ShowSQL(show ...bool)
Sync(...interface{}) error Sync(...any) error
Sync2(...interface{}) error Sync2(...any) error
SyncWithOptions(SyncOptions, ...interface{}) (*SyncResult, error) SyncWithOptions(SyncOptions, ...any) (*SyncResult, error)
StoreEngine(storeEngine string) *Session StoreEngine(storeEngine string) *Session
TableInfo(bean interface{}) (*schemas.Table, error) TableInfo(bean any) (*schemas.Table, error)
TableName(interface{}, ...bool) string TableName(any, ...bool) string
UnMapType(reflect.Type) UnMapType(reflect.Type)
EnableSessionID(bool) EnableSessionID(bool)
} }

2
internal/convert/bool.go
View File

@ -11,7 +11,7 @@ import (
) )
// AsBool convert interface as bool // AsBool convert interface as bool
func AsBool(src interface{}) (bool, error) { func AsBool(src any) (bool, error) {
switch v := src.(type) { switch v := src.(type) {
case bool: case bool:
return v, nil return v, nil

16
internal/convert/conversion.go
View File

@ -55,10 +55,10 @@ func cloneBytes(b []byte) []byte {
// Assign copies to dest the value in src, converting it if possible. // Assign copies to dest the value in src, converting it if possible.
// An error is returned if the copy would result in loss of information. // An error is returned if the copy would result in loss of information.
// dest should be a pointer type. // dest should be a pointer type.
func Assign(dest, src interface{}, originalLocation *time.Location, convertedLocation *time.Location) error { func Assign(dest, src any, originalLocation *time.Location, convertedLocation *time.Location) error {
// Common cases, without reflect. // Common cases, without reflect.
switch s := src.(type) { switch s := src.(type) {
case *interface{}: case *any:
return Assign(dest, *s, originalLocation, convertedLocation) return Assign(dest, *s, originalLocation, convertedLocation)
case string: case string:
switch d := dest.(type) { switch d := dest.(type) {
@ -83,7 +83,7 @@ func Assign(dest, src interface{}, originalLocation *time.Location, convertedLoc
} }
*d = string(s) *d = string(s)
return nil return nil
case *interface{}: case *any:
if d == nil { if d == nil {
return ErrNilPtr return ErrNilPtr
} }
@ -110,7 +110,7 @@ func Assign(dest, src interface{}, originalLocation *time.Location, convertedLoc
} }
case nil: case nil:
switch d := dest.(type) { switch d := dest.(type) {
case *interface{}: case *any:
if d == nil { if d == nil {
return ErrNilPtr return ErrNilPtr
} }
@ -295,7 +295,7 @@ func Assign(dest, src interface{}, originalLocation *time.Location, convertedLoc
switch d := dest.(type) { switch d := dest.(type) {
case *string: case *string:
var sv = reflect.ValueOf(src) sv := reflect.ValueOf(src)
switch sv.Kind() { switch sv.Kind() {
case reflect.Bool, case reflect.Bool,
reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
@ -315,7 +315,7 @@ func Assign(dest, src interface{}, originalLocation *time.Location, convertedLoc
*d = bv.(bool) *d = bv.(bool)
} }
return err return err
case *interface{}: case *any:
*d = src *d = src
return nil return nil
} }
@ -329,11 +329,11 @@ var (
) )
// AssignValue assign src as dv // AssignValue assign src as dv
func AssignValue(dv reflect.Value, src interface{}) error { func AssignValue(dv reflect.Value, src any) error {
if src == nil { if src == nil {
return nil return nil
} }
if v, ok := src.(*interface{}); ok { if v, ok := src.(*any); ok {
return AssignValue(dv, *v) return AssignValue(dv, *v)
} }

4
internal/convert/float.go
View File

@ -13,7 +13,7 @@ import (
) )
// AsFloat64 convets interface as float64 // AsFloat64 convets interface as float64
func AsFloat64(src interface{}) (float64, error) { func AsFloat64(src any) (float64, error) {
switch v := src.(type) { switch v := src.(type) {
case int: case int:
return float64(v), nil return float64(v), nil
@ -64,7 +64,7 @@ func AsFloat64(src interface{}) (float64, error) {
} }
// AsBigFloat converts interface as big.Float // AsBigFloat converts interface as big.Float
func AsBigFloat(src interface{}) (*big.Float, error) { func AsBigFloat(src any) (*big.Float, error) {
res := big.NewFloat(0) res := big.NewFloat(0)
switch v := src.(type) { switch v := src.(type) {
case int: case int:

8
internal/convert/int.go
View File

@ -13,7 +13,7 @@ import (
) )
// AsInt64 converts interface as int64 // AsInt64 converts interface as int64
func AsInt64(src interface{}) (int64, error) { func AsInt64(src any) (int64, error) {
switch v := src.(type) { switch v := src.(type) {
case int: case int:
return int64(v), nil return int64(v), nil
@ -112,7 +112,7 @@ func AsInt64(src interface{}) (int64, error) {
} }
// AsUint64 converts interface as uint64 // AsUint64 converts interface as uint64
func AsUint64(src interface{}) (uint64, error) { func AsUint64(src any) (uint64, error) {
switch v := src.(type) { switch v := src.(type) {
case int: case int:
return uint64(v), nil return uint64(v), nil
@ -171,7 +171,7 @@ type NullUint64 struct {
} }
// Scan implements the Scanner interface. // Scan implements the Scanner interface.
func (n *NullUint64) Scan(value interface{}) error { func (n *NullUint64) Scan(value any) error {
if value == nil { if value == nil {
n.Uint64, n.Valid = 0, false n.Uint64, n.Valid = 0, false
return nil return nil
@ -201,7 +201,7 @@ type NullUint32 struct {
} }
// Scan implements the Scanner interface. // Scan implements the Scanner interface.
func (n *NullUint32) Scan(value interface{}) error { func (n *NullUint32) Scan(value any) error {
if value == nil { if value == nil {
n.Uint32, n.Valid = 0, false n.Uint32, n.Valid = 0, false
return nil return nil

2
internal/convert/interface.go
View File

@ -11,7 +11,7 @@ import (
) )
// Interface2Interface converts interface of pointer as interface of value // Interface2Interface converts interface of pointer as interface of value
func Interface2Interface(userLocation *time.Location, v interface{}) (interface{}, error) { func Interface2Interface(userLocation *time.Location, v any) (any, error) {
if v == nil { if v == nil {
return nil, nil return nil, nil
} }

2
internal/convert/kind.go
View File

@ -10,7 +10,7 @@ import (
"strconv" "strconv"
) )
func AsKind(vv reflect.Value, tp reflect.Type) (interface{}, error) { func AsKind(vv reflect.Value, tp reflect.Type) (any, error) {
switch tp.Kind() { switch tp.Kind() {
case reflect.Ptr: case reflect.Ptr:
return AsKind(vv.Elem(), tp.Elem()) return AsKind(vv.Elem(), tp.Elem())

6
internal/convert/scanner.go
View File

@ -6,14 +6,12 @@ package convert
import "database/sql" import "database/sql"
var ( var _ sql.Scanner = &EmptyScanner{}
_ sql.Scanner = &EmptyScanner{}
)
// EmptyScanner represents an empty scanner which will ignore the scan // EmptyScanner represents an empty scanner which will ignore the scan
type EmptyScanner struct{} type EmptyScanner struct{}
// Scan implements sql.Scanner // Scan implements sql.Scanner
func (EmptyScanner) Scan(value interface{}) error { func (EmptyScanner) Scan(value any) error {
return nil return nil
} }

4
internal/convert/string.go
View File

@ -12,7 +12,7 @@ import (
) )
// AsString converts interface as string // AsString converts interface as string
func AsString(src interface{}) string { func AsString(src any) string {
switch v := src.(type) { switch v := src.(type) {
case string: case string:
return v return v
@ -42,7 +42,7 @@ func AsString(src interface{}) string {
} }
// AsBytes converts interface as bytes // AsBytes converts interface as bytes
func AsBytes(src interface{}) ([]byte, bool) { func AsBytes(src any) ([]byte, bool) {
switch t := src.(type) { switch t := src.(type) {
case []byte: case []byte:
return t, true return t, true

2
internal/convert/time.go
View File

@ -90,7 +90,7 @@ func String2Time(s string, originalLocation *time.Location, convertedLocation *t
} }
// AsTime converts interface as time // AsTime converts interface as time
func AsTime(src interface{}, dbLoc *time.Location, uiLoc *time.Location) (*time.Time, error) { func AsTime(src any, dbLoc *time.Location, uiLoc *time.Location) (*time.Time, error) {
switch t := src.(type) { switch t := src.(type) {
case string: case string:
return String2Time(t, dbLoc, uiLoc) return String2Time(t, dbLoc, uiLoc)

48
internal/core/db.go
View File

@ -22,13 +22,13 @@ import (
var DefaultCacheSize = 200 var DefaultCacheSize = 200
// MapToSlice map query and struct as sql and args // MapToSlice map query and struct as sql and args
func MapToSlice(query string, mp interface{}) (string, []interface{}, error) { func MapToSlice(query string, mp any) (string, []any, error) {
vv := reflect.ValueOf(mp) vv := reflect.ValueOf(mp)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map { if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map {
return "", []interface{}{}, ErrNoMapPointer return "", []any{}, ErrNoMapPointer
} }
args := make([]interface{}, 0, len(vv.Elem().MapKeys())) args := make([]any, 0, len(vv.Elem().MapKeys()))
var err error var err error
query = re.ReplaceAllStringFunc(query, func(src string) string { query = re.ReplaceAllStringFunc(query, func(src string) string {
v := vv.Elem().MapIndex(reflect.ValueOf(src[1:])) v := vv.Elem().MapIndex(reflect.ValueOf(src[1:]))
@ -44,13 +44,13 @@ func MapToSlice(query string, mp interface{}) (string, []interface{}, error) {
} }
// StructToSlice converts a query and struct as sql and args // StructToSlice converts a query and struct as sql and args
func StructToSlice(query string, st interface{}) (string, []interface{}, error) { func StructToSlice(query string, st any) (string, []any, error) {
vv := reflect.ValueOf(st) vv := reflect.ValueOf(st)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct { if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct {
return "", []interface{}{}, ErrNoStructPointer return "", []any{}, ErrNoStructPointer
} }
args := make([]interface{}, 0) args := make([]any, 0)
var err error var err error
query = re.ReplaceAllStringFunc(query, func(src string) string { query = re.ReplaceAllStringFunc(query, func(src string) string {
fv := vv.Elem().FieldByName(src[1:]).Interface() fv := vv.Elem().FieldByName(src[1:]).Interface()
@ -67,7 +67,7 @@ func StructToSlice(query string, st interface{}) (string, []interface{}, error)
return "?" return "?"
}) })
if err != nil { if err != nil {
return "", []interface{}{}, err return "", []any{}, err
} }
return query, args, nil return query, args, nil
} }
@ -138,7 +138,7 @@ func (db *DB) reflectNew(typ reflect.Type) reflect.Value {
} }
// QueryContext overwrites sql.DB.QueryContext // QueryContext overwrites sql.DB.QueryContext
func (db *DB) QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error) { func (db *DB) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error) {
hookCtx := contexts.NewContextHook(ctx, query, args) hookCtx := contexts.NewContextHook(ctx, query, args)
ctx, err := db.beforeProcess(hookCtx) ctx, err := db.beforeProcess(hookCtx)
if err != nil { if err != nil {
@ -156,12 +156,12 @@ func (db *DB) QueryContext(ctx context.Context, query string, args ...interface{
} }
// Query overwrites sql.DB.Query // Query overwrites sql.DB.Query
func (db *DB) Query(query string, args ...interface{}) (*Rows, error) { func (db *DB) Query(query string, args ...any) (*Rows, error) {
return db.QueryContext(context.Background(), query, args...) return db.QueryContext(context.Background(), query, args...)
} }
// QueryMapContext executes query with parameters via map and context // QueryMapContext executes query with parameters via map and context
func (db *DB) QueryMapContext(ctx context.Context, query string, mp interface{}) (*Rows, error) { func (db *DB) QueryMapContext(ctx context.Context, query string, mp any) (*Rows, error) {
query, args, err := MapToSlice(query, mp) query, args, err := MapToSlice(query, mp)
if err != nil { if err != nil {
return nil, err return nil, err
@ -170,12 +170,12 @@ func (db *DB) QueryMapContext(ctx context.Context, query string, mp interface{})
} }
// QueryMap executes query with parameters via map // QueryMap executes query with parameters via map
func (db *DB) QueryMap(query string, mp interface{}) (*Rows, error) { func (db *DB) QueryMap(query string, mp any) (*Rows, error) {
return db.QueryMapContext(context.Background(), query, mp) return db.QueryMapContext(context.Background(), query, mp)
} }
// QueryStructContext query rows with struct // QueryStructContext query rows with struct
func (db *DB) QueryStructContext(ctx context.Context, query string, st interface{}) (*Rows, error) { func (db *DB) QueryStructContext(ctx context.Context, query string, st any) (*Rows, error) {
query, args, err := StructToSlice(query, st) query, args, err := StructToSlice(query, st)
if err != nil { if err != nil {
return nil, err return nil, err
@ -184,12 +184,12 @@ func (db *DB) QueryStructContext(ctx context.Context, query string, st interface
} }
// QueryStruct query rows with struct // QueryStruct query rows with struct
func (db *DB) QueryStruct(query string, st interface{}) (*Rows, error) { func (db *DB) QueryStruct(query string, st any) (*Rows, error) {
return db.QueryStructContext(context.Background(), query, st) return db.QueryStructContext(context.Background(), query, st)
} }
// QueryRowContext query row with args // QueryRowContext query row with args
func (db *DB) QueryRowContext(ctx context.Context, query string, args ...interface{}) *Row { func (db *DB) QueryRowContext(ctx context.Context, query string, args ...any) *Row {
rows, err := db.QueryContext(ctx, query, args...) rows, err := db.QueryContext(ctx, query, args...)
if err != nil { if err != nil {
return &Row{nil, err} return &Row{nil, err}
@ -198,12 +198,12 @@ func (db *DB) QueryRowContext(ctx context.Context, query string, args ...interfa
} }
// QueryRow query row with args // QueryRow query row with args
func (db *DB) QueryRow(query string, args ...interface{}) *Row { func (db *DB) QueryRow(query string, args ...any) *Row {
return db.QueryRowContext(context.Background(), query, args...) return db.QueryRowContext(context.Background(), query, args...)
} }
// QueryRowMapContext query row with map // QueryRowMapContext query row with map
func (db *DB) QueryRowMapContext(ctx context.Context, query string, mp interface{}) *Row { func (db *DB) QueryRowMapContext(ctx context.Context, query string, mp any) *Row {
query, args, err := MapToSlice(query, mp) query, args, err := MapToSlice(query, mp)
if err != nil { if err != nil {
return &Row{nil, err} return &Row{nil, err}
@ -212,12 +212,12 @@ func (db *DB) QueryRowMapContext(ctx context.Context, query string, mp interface
} }
// QueryRowMap query row with map // QueryRowMap query row with map
func (db *DB) QueryRowMap(query string, mp interface{}) *Row { func (db *DB) QueryRowMap(query string, mp any) *Row {
return db.QueryRowMapContext(context.Background(), query, mp) return db.QueryRowMapContext(context.Background(), query, mp)
} }
// QueryRowStructContext query row with struct // QueryRowStructContext query row with struct
func (db *DB) QueryRowStructContext(ctx context.Context, query string, st interface{}) *Row { func (db *DB) QueryRowStructContext(ctx context.Context, query string, st any) *Row {
query, args, err := StructToSlice(query, st) query, args, err := StructToSlice(query, st)
if err != nil { if err != nil {
return &Row{nil, err} return &Row{nil, err}
@ -226,7 +226,7 @@ func (db *DB) QueryRowStructContext(ctx context.Context, query string, st interf
} }
// QueryRowStruct query row with struct // QueryRowStruct query row with struct
func (db *DB) QueryRowStruct(query string, st interface{}) *Row { func (db *DB) QueryRowStruct(query string, st any) *Row {
return db.QueryRowStructContext(context.Background(), query, st) return db.QueryRowStructContext(context.Background(), query, st)
} }
@ -235,7 +235,7 @@ var re = regexp.MustCompile(`[?](\w+)`)
// ExecMapContext exec map with context.ContextHook // ExecMapContext exec map with context.ContextHook
// insert into (name) values (?) // insert into (name) values (?)
// insert into (name) values (?name) // insert into (name) values (?name)
func (db *DB) ExecMapContext(ctx context.Context, query string, mp interface{}) (sql.Result, error) { func (db *DB) ExecMapContext(ctx context.Context, query string, mp any) (sql.Result, error) {
query, args, err := MapToSlice(query, mp) query, args, err := MapToSlice(query, mp)
if err != nil { if err != nil {
return nil, err return nil, err
@ -244,12 +244,12 @@ func (db *DB) ExecMapContext(ctx context.Context, query string, mp interface{})
} }
// ExecMap exec query with map // ExecMap exec query with map
func (db *DB) ExecMap(query string, mp interface{}) (sql.Result, error) { func (db *DB) ExecMap(query string, mp any) (sql.Result, error) {
return db.ExecMapContext(context.Background(), query, mp) return db.ExecMapContext(context.Background(), query, mp)
} }
// ExecStructContext exec query with map // ExecStructContext exec query with map
func (db *DB) ExecStructContext(ctx context.Context, query string, st interface{}) (sql.Result, error) { func (db *DB) ExecStructContext(ctx context.Context, query string, st any) (sql.Result, error) {
query, args, err := StructToSlice(query, st) query, args, err := StructToSlice(query, st)
if err != nil { if err != nil {
return nil, err return nil, err
@ -258,7 +258,7 @@ func (db *DB) ExecStructContext(ctx context.Context, query string, st interface{
} }
// ExecContext exec query with args // ExecContext exec query with args
func (db *DB) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) { func (db *DB) ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) {
hookCtx := contexts.NewContextHook(ctx, query, args) hookCtx := contexts.NewContextHook(ctx, query, args)
ctx, err := db.beforeProcess(hookCtx) ctx, err := db.beforeProcess(hookCtx)
if err != nil { if err != nil {
@ -273,7 +273,7 @@ func (db *DB) ExecContext(ctx context.Context, query string, args ...interface{}
} }
// ExecStruct exec query with struct // ExecStruct exec query with struct
func (db *DB) ExecStruct(query string, st interface{}) (sql.Result, error) { func (db *DB) ExecStruct(query string, st any) (sql.Result, error) {
return db.ExecStructContext(context.Background(), query, st) return db.ExecStructContext(context.Background(), query, st)
} }

8
internal/core/db_test.go
View File

@ -239,7 +239,7 @@ func BenchmarkSliceInterfaceQuery(b *testing.B) {
} }
for rows.Next() { for rows.Next() {
slice := make([]interface{}, len(cols)) slice := make([]any, len(cols))
err = rows.ScanSlice(&slice) err = rows.ScanSlice(&slice)
if err != nil { if err != nil {
b.Error(err) b.Error(err)
@ -394,7 +394,7 @@ func BenchmarkMapInterfaceQuery(b *testing.B) {
} }
for rows.Next() { for rows.Next() {
m := make(map[string]interface{}) m := make(map[string]any)
err = rows.ScanMap(&m) err = rows.ScanMap(&m)
if err != nil { if err != nil {
b.Error(err) b.Error(err)
@ -551,7 +551,7 @@ func BenchmarkExecMap(b *testing.B) {
b.StartTimer() b.StartTimer()
mp := map[string]interface{}{ mp := map[string]any{
"name": "xlw", "name": "xlw",
"title": "tester", "title": "tester",
"age": 1.2, "age": 1.2,
@ -582,7 +582,7 @@ func TestExecMap(t *testing.T) {
t.Error(err) t.Error(err)
} }
mp := map[string]interface{}{ mp := map[string]any{
"name": "xlw", "name": "xlw",
"title": "tester", "title": "tester",
"age": 1.2, "age": 1.2,

4
internal/core/interface.go
View File

@ -7,12 +7,12 @@ import (
// Queryer represents an interface to query a SQL to get data from database // Queryer represents an interface to query a SQL to get data from database
type Queryer interface { type Queryer interface {
QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error)
} }
// Executer represents an interface to execute a SQL // Executer represents an interface to execute a SQL
type Executer interface { type Executer interface {
ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
} }
// QueryExecuter combines the Queryer and Executer // QueryExecuter combines the Queryer and Executer

34
internal/core/rows.go
View File

@ -24,9 +24,9 @@ func (rs *Rows) ToMapString() ([]map[string]string, error) {
return nil, err return nil, err
} }
var results = make([]map[string]string, 0, 10) results := make([]map[string]string, 0, 10)
for rs.Next() { for rs.Next() {
var record = make(map[string]string, len(cols)) record := make(map[string]string, len(cols))
err = rs.ScanMap(&record) err = rs.ScanMap(&record)
if err != nil { if err != nil {
return nil, err return nil, err
@ -37,7 +37,7 @@ func (rs *Rows) ToMapString() ([]map[string]string, error) {
} }
// ScanStructByIndex scan data to a struct's pointer according field index // ScanStructByIndex scan data to a struct's pointer according field index
func (rs *Rows) ScanStructByIndex(dest ...interface{}) error { func (rs *Rows) ScanStructByIndex(dest ...any) error {
if len(dest) == 0 { if len(dest) == 0 {
return errors.New("at least one struct") return errors.New("at least one struct")
} }
@ -56,9 +56,9 @@ func (rs *Rows) ScanStructByIndex(dest ...interface{}) error {
if err != nil { if err != nil {
return err return err
} }
newDest := make([]interface{}, len(cols)) newDest := make([]any, len(cols))
var i = 0 i := 0
for _, vvv := range vvvs { for _, vvv := range vvvs {
for j := 0; j < vvv.NumField(); j++ { for j := 0; j < vvv.NumField(); j++ {
newDest[i] = vvv.Field(j).Addr().Interface() newDest[i] = vvv.Field(j).Addr().Interface()
@ -97,7 +97,7 @@ func fieldByName(v reflect.Value, name string) reflect.Value {
} }
// ScanStructByName scan data to a struct's pointer according field name // ScanStructByName scan data to a struct's pointer according field name
func (rs *Rows) ScanStructByName(dest interface{}) error { func (rs *Rows) ScanStructByName(dest any) error {
vv := reflect.ValueOf(dest) vv := reflect.ValueOf(dest)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct { if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct {
return errors.New("dest should be a struct's pointer") return errors.New("dest should be a struct's pointer")
@ -108,7 +108,7 @@ func (rs *Rows) ScanStructByName(dest interface{}) error {
return err return err
} }
newDest := make([]interface{}, len(cols)) newDest := make([]any, len(cols))
var v EmptyScanner var v EmptyScanner
for j, name := range cols { for j, name := range cols {
f := fieldByName(vv.Elem(), rs.db.Mapper.Table2Obj(name)) f := fieldByName(vv.Elem(), rs.db.Mapper.Table2Obj(name))
@ -123,7 +123,7 @@ func (rs *Rows) ScanStructByName(dest interface{}) error {
} }
// ScanSlice scan data to a slice's pointer, slice's length should equal to columns' number // ScanSlice scan data to a slice's pointer, slice's length should equal to columns' number
func (rs *Rows) ScanSlice(dest interface{}) error { func (rs *Rows) ScanSlice(dest any) error {
vv := reflect.ValueOf(dest) vv := reflect.ValueOf(dest)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Slice { if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Slice {
return errors.New("dest should be a slice's pointer") return errors.New("dest should be a slice's pointer")
@ -135,7 +135,7 @@ func (rs *Rows) ScanSlice(dest interface{}) error {
return err return err
} }
newDest := make([]interface{}, len(cols)) newDest := make([]any, len(cols))
for j := 0; j < len(cols); j++ { for j := 0; j < len(cols); j++ {
if j >= vvv.Len() { if j >= vvv.Len() {
@ -158,7 +158,7 @@ func (rs *Rows) ScanSlice(dest interface{}) error {
} }
// ScanMap scan data to a map's pointer // ScanMap scan data to a map's pointer
func (rs *Rows) ScanMap(dest interface{}) error { func (rs *Rows) ScanMap(dest any) error {
vv := reflect.ValueOf(dest) vv := reflect.ValueOf(dest)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map { if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map {
return errors.New("dest should be a map's pointer") return errors.New("dest should be a map's pointer")
@ -169,7 +169,7 @@ func (rs *Rows) ScanMap(dest interface{}) error {
return err return err
} }
newDest := make([]interface{}, len(cols)) newDest := make([]any, len(cols))
vvv := vv.Elem() vvv := vv.Elem()
for i := range cols { for i := range cols {
@ -217,7 +217,7 @@ func (row *Row) Columns() ([]string, error) {
} }
// Scan retrieves all row column values // Scan retrieves all row column values
func (row *Row) Scan(dest ...interface{}) error { func (row *Row) Scan(dest ...any) error {
if row.err != nil { if row.err != nil {
return row.err return row.err
} }
@ -244,7 +244,7 @@ func (row *Row) Scan(dest ...interface{}) error {
} }
// ScanStructByName retrieves all row column values into a struct // ScanStructByName retrieves all row column values into a struct
func (row *Row) ScanStructByName(dest interface{}) error { func (row *Row) ScanStructByName(dest any) error {
if row.err != nil { if row.err != nil {
return row.err return row.err
} }
@ -265,7 +265,7 @@ func (row *Row) ScanStructByName(dest interface{}) error {
} }
// ScanStructByIndex retrieves all row column values into a struct // ScanStructByIndex retrieves all row column values into a struct
func (row *Row) ScanStructByIndex(dest interface{}) error { func (row *Row) ScanStructByIndex(dest any) error {
if row.err != nil { if row.err != nil {
return row.err return row.err
} }
@ -286,7 +286,7 @@ func (row *Row) ScanStructByIndex(dest interface{}) error {
} }
// ScanSlice scan data to a slice's pointer, slice's length should equal to columns' number // ScanSlice scan data to a slice's pointer, slice's length should equal to columns' number
func (row *Row) ScanSlice(dest interface{}) error { func (row *Row) ScanSlice(dest any) error {
if row.err != nil { if row.err != nil {
return row.err return row.err
} }
@ -308,7 +308,7 @@ func (row *Row) ScanSlice(dest interface{}) error {
} }
// ScanMap scan data to a map's pointer // ScanMap scan data to a map's pointer
func (row *Row) ScanMap(dest interface{}) error { func (row *Row) ScanMap(dest any) error {
if row.err != nil { if row.err != nil {
return row.err return row.err
} }
@ -336,7 +336,7 @@ func (row *Row) ToMapString() (map[string]string, error) {
return nil, err return nil, err
} }
var record = make(map[string]string, len(cols)) record := make(map[string]string, len(cols))
err = row.ScanMap(&record) err = row.ScanMap(&record)
if err != nil { if err != nil {
return nil, err return nil, err

13
internal/core/scan.go
View File

@ -13,12 +13,10 @@ import (
// NullTime defines a customize type NullTime // NullTime defines a customize type NullTime
type NullTime time.Time type NullTime time.Time
var ( var _ driver.Valuer = NullTime{}
_ driver.Valuer = NullTime{}
)
// Scan implements driver.Valuer // Scan implements driver.Valuer
func (ns *NullTime) Scan(value interface{}) error { func (ns *NullTime) Scan(value any) error {
if value == nil { if value == nil {
return nil return nil
} }
@ -33,7 +31,7 @@ func (ns NullTime) Value() (driver.Value, error) {
return (time.Time)(ns).Format("2006-01-02 15:04:05"), nil return (time.Time)(ns).Format("2006-01-02 15:04:05"), nil
} }
func convertTime(dest *NullTime, src interface{}) error { func convertTime(dest *NullTime, src any) error {
// Common cases, without reflect. // Common cases, without reflect.
switch s := src.(type) { switch s := src.(type) {
case string: case string:
@ -61,10 +59,9 @@ func convertTime(dest *NullTime, src interface{}) error {
} }
// EmptyScanner represents an empty scanner // EmptyScanner represents an empty scanner
type EmptyScanner struct { type EmptyScanner struct{}
}
// Scan implements // Scan implements
func (EmptyScanner) Scan(src interface{}) error { func (EmptyScanner) Scan(src any) error {
return nil return nil
} }

46
internal/core/stmt.go
View File

@ -49,13 +49,13 @@ func (db *DB) Prepare(query string) (*Stmt, error) {
} }
// ExecMapContext execute with map // ExecMapContext execute with map
func (s *Stmt) ExecMapContext(ctx context.Context, mp interface{}) (sql.Result, error) { func (s *Stmt) ExecMapContext(ctx context.Context, mp any) (sql.Result, error) {
vv := reflect.ValueOf(mp) vv := reflect.ValueOf(mp)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map { if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map {
return nil, errors.New("mp should be a map's pointer") return nil, errors.New("mp should be a map's pointer")
} }
args := make([]interface{}, len(s.names)) args := make([]any, len(s.names))
for k, i := range s.names { for k, i := range s.names {
args[i] = vv.Elem().MapIndex(reflect.ValueOf(k)).Interface() args[i] = vv.Elem().MapIndex(reflect.ValueOf(k)).Interface()
} }
@ -63,18 +63,18 @@ func (s *Stmt) ExecMapContext(ctx context.Context, mp interface{}) (sql.Result,
} }
// ExecMap executes with map // ExecMap executes with map
func (s *Stmt) ExecMap(mp interface{}) (sql.Result, error) { func (s *Stmt) ExecMap(mp any) (sql.Result, error) {
return s.ExecMapContext(context.Background(), mp) return s.ExecMapContext(context.Background(), mp)
} }
// ExecStructContext executes with struct // ExecStructContext executes with struct
func (s *Stmt) ExecStructContext(ctx context.Context, st interface{}) (sql.Result, error) { func (s *Stmt) ExecStructContext(ctx context.Context, st any) (sql.Result, error) {
vv := reflect.ValueOf(st) vv := reflect.ValueOf(st)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct { if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct {
return nil, errors.New("mp should be a map's pointer") return nil, errors.New("mp should be a map's pointer")
} }
args := make([]interface{}, len(s.names)) args := make([]any, len(s.names))
for k, i := range s.names { for k, i := range s.names {
args[i] = vv.Elem().FieldByName(k).Interface() args[i] = vv.Elem().FieldByName(k).Interface()
} }
@ -82,12 +82,12 @@ func (s *Stmt) ExecStructContext(ctx context.Context, st interface{}) (sql.Resul
} }
// ExecStruct executes with struct // ExecStruct executes with struct
func (s *Stmt) ExecStruct(st interface{}) (sql.Result, error) { func (s *Stmt) ExecStruct(st any) (sql.Result, error) {
return s.ExecStructContext(context.Background(), st) return s.ExecStructContext(context.Background(), st)
} }
// ExecContext with args // ExecContext with args
func (s *Stmt) ExecContext(ctx context.Context, args ...interface{}) (sql.Result, error) { func (s *Stmt) ExecContext(ctx context.Context, args ...any) (sql.Result, error) {
hookCtx := contexts.NewContextHook(ctx, s.query, args) hookCtx := contexts.NewContextHook(ctx, s.query, args)
ctx, err := s.db.beforeProcess(hookCtx) ctx, err := s.db.beforeProcess(hookCtx)
if err != nil { if err != nil {
@ -102,7 +102,7 @@ func (s *Stmt) ExecContext(ctx context.Context, args ...interface{}) (sql.Result
} }
// QueryContext query with args // QueryContext query with args
func (s *Stmt) QueryContext(ctx context.Context, args ...interface{}) (*Rows, error) { func (s *Stmt) QueryContext(ctx context.Context, args ...any) (*Rows, error) {
hookCtx := contexts.NewContextHook(ctx, s.query, args) hookCtx := contexts.NewContextHook(ctx, s.query, args)
ctx, err := s.db.beforeProcess(hookCtx) ctx, err := s.db.beforeProcess(hookCtx)
if err != nil { if err != nil {
@ -117,18 +117,18 @@ func (s *Stmt) QueryContext(ctx context.Context, args ...interface{}) (*Rows, er
} }
// Query query with args // Query query with args
func (s *Stmt) Query(args ...interface{}) (*Rows, error) { func (s *Stmt) Query(args ...any) (*Rows, error) {
return s.QueryContext(context.Background(), args...) return s.QueryContext(context.Background(), args...)
} }
// QueryMapContext query with map // QueryMapContext query with map
func (s *Stmt) QueryMapContext(ctx context.Context, mp interface{}) (*Rows, error) { func (s *Stmt) QueryMapContext(ctx context.Context, mp any) (*Rows, error) {
vv := reflect.ValueOf(mp) vv := reflect.ValueOf(mp)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map { if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map {
return nil, errors.New("mp should be a map's pointer") return nil, errors.New("mp should be a map's pointer")
} }
args := make([]interface{}, len(s.names)) args := make([]any, len(s.names))
for k, i := range s.names { for k, i := range s.names {
args[i] = vv.Elem().MapIndex(reflect.ValueOf(k)).Interface() args[i] = vv.Elem().MapIndex(reflect.ValueOf(k)).Interface()
} }
@ -137,18 +137,18 @@ func (s *Stmt) QueryMapContext(ctx context.Context, mp interface{}) (*Rows, erro
} }
// QueryMap query with map // QueryMap query with map
func (s *Stmt) QueryMap(mp interface{}) (*Rows, error) { func (s *Stmt) QueryMap(mp any) (*Rows, error) {
return s.QueryMapContext(context.Background(), mp) return s.QueryMapContext(context.Background(), mp)
} }
// QueryStructContext query with struct // QueryStructContext query with struct
func (s *Stmt) QueryStructContext(ctx context.Context, st interface{}) (*Rows, error) { func (s *Stmt) QueryStructContext(ctx context.Context, st any) (*Rows, error) {
vv := reflect.ValueOf(st) vv := reflect.ValueOf(st)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct { if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct {
return nil, errors.New("mp should be a map's pointer") return nil, errors.New("mp should be a map's pointer")
} }
args := make([]interface{}, len(s.names)) args := make([]any, len(s.names))
for k, i := range s.names { for k, i := range s.names {
args[i] = vv.Elem().FieldByName(k).Interface() args[i] = vv.Elem().FieldByName(k).Interface()
} }
@ -157,29 +157,29 @@ func (s *Stmt) QueryStructContext(ctx context.Context, st interface{}) (*Rows, e
} }
// QueryStruct query with struct // QueryStruct query with struct
func (s *Stmt) QueryStruct(st interface{}) (*Rows, error) { func (s *Stmt) QueryStruct(st any) (*Rows, error) {
return s.QueryStructContext(context.Background(), st) return s.QueryStructContext(context.Background(), st)
} }
// QueryRowContext query row with args // QueryRowContext query row with args
func (s *Stmt) QueryRowContext(ctx context.Context, args ...interface{}) *Row { func (s *Stmt) QueryRowContext(ctx context.Context, args ...any) *Row {
rows, err := s.QueryContext(ctx, args...) rows, err := s.QueryContext(ctx, args...)
return &Row{rows, err} return &Row{rows, err}
} }
// QueryRow query row with args // QueryRow query row with args
func (s *Stmt) QueryRow(args ...interface{}) *Row { func (s *Stmt) QueryRow(args ...any) *Row {
return s.QueryRowContext(context.Background(), args...) return s.QueryRowContext(context.Background(), args...)
} }
// QueryRowMapContext query row with map // QueryRowMapContext query row with map
func (s *Stmt) QueryRowMapContext(ctx context.Context, mp interface{}) *Row { func (s *Stmt) QueryRowMapContext(ctx context.Context, mp any) *Row {
vv := reflect.ValueOf(mp) vv := reflect.ValueOf(mp)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map { if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map {
return &Row{nil, errors.New("mp should be a map's pointer")} return &Row{nil, errors.New("mp should be a map's pointer")}
} }
args := make([]interface{}, len(s.names)) args := make([]any, len(s.names))
for k, i := range s.names { for k, i := range s.names {
args[i] = vv.Elem().MapIndex(reflect.ValueOf(k)).Interface() args[i] = vv.Elem().MapIndex(reflect.ValueOf(k)).Interface()
} }
@ -188,18 +188,18 @@ func (s *Stmt) QueryRowMapContext(ctx context.Context, mp interface{}) *Row {
} }
// QueryRowMap query row with map // QueryRowMap query row with map
func (s *Stmt) QueryRowMap(mp interface{}) *Row { func (s *Stmt) QueryRowMap(mp any) *Row {
return s.QueryRowMapContext(context.Background(), mp) return s.QueryRowMapContext(context.Background(), mp)
} }
// QueryRowStructContext query row with struct // QueryRowStructContext query row with struct
func (s *Stmt) QueryRowStructContext(ctx context.Context, st interface{}) *Row { func (s *Stmt) QueryRowStructContext(ctx context.Context, st any) *Row {
vv := reflect.ValueOf(st) vv := reflect.ValueOf(st)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct { if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct {
return &Row{nil, errors.New("st should be a struct's pointer")} return &Row{nil, errors.New("st should be a struct's pointer")}
} }
args := make([]interface{}, len(s.names)) args := make([]any, len(s.names))
for k, i := range s.names { for k, i := range s.names {
args[i] = vv.Elem().FieldByName(k).Interface() args[i] = vv.Elem().FieldByName(k).Interface()
} }
@ -208,6 +208,6 @@ func (s *Stmt) QueryRowStructContext(ctx context.Context, st interface{}) *Row {
} }
// QueryRowStruct query row with struct // QueryRowStruct query row with struct
func (s *Stmt) QueryRowStruct(st interface{}) *Row { func (s *Stmt) QueryRowStruct(st any) *Row {
return s.QueryRowStructContext(context.Background(), st) return s.QueryRowStructContext(context.Background(), st)
} }

34
internal/core/tx.go
View File

@ -103,7 +103,7 @@ func (tx *Tx) Stmt(stmt *Stmt) *Stmt {
} }
// ExecMapContext executes query with args in a map // ExecMapContext executes query with args in a map
func (tx *Tx) ExecMapContext(ctx context.Context, query string, mp interface{}) (sql.Result, error) { func (tx *Tx) ExecMapContext(ctx context.Context, query string, mp any) (sql.Result, error) {
query, args, err := MapToSlice(query, mp) query, args, err := MapToSlice(query, mp)
if err != nil { if err != nil {
return nil, err return nil, err
@ -112,12 +112,12 @@ func (tx *Tx) ExecMapContext(ctx context.Context, query string, mp interface{})
} }
// ExecMap executes query with args in a map // ExecMap executes query with args in a map
func (tx *Tx) ExecMap(query string, mp interface{}) (sql.Result, error) { func (tx *Tx) ExecMap(query string, mp any) (sql.Result, error) {
return tx.ExecMapContext(context.Background(), query, mp) return tx.ExecMapContext(context.Background(), query, mp)
} }
// ExecStructContext executes query with args in a struct // ExecStructContext executes query with args in a struct
func (tx *Tx) ExecStructContext(ctx context.Context, query string, st interface{}) (sql.Result, error) { func (tx *Tx) ExecStructContext(ctx context.Context, query string, st any) (sql.Result, error) {
query, args, err := StructToSlice(query, st) query, args, err := StructToSlice(query, st)
if err != nil { if err != nil {
return nil, err return nil, err
@ -126,7 +126,7 @@ func (tx *Tx) ExecStructContext(ctx context.Context, query string, st interface{
} }
// ExecContext executes a query with args // ExecContext executes a query with args
func (tx *Tx) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) { func (tx *Tx) ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) {
hookCtx := contexts.NewContextHook(ctx, query, args) hookCtx := contexts.NewContextHook(ctx, query, args)
ctx, err := tx.db.beforeProcess(hookCtx) ctx, err := tx.db.beforeProcess(hookCtx)
if err != nil { if err != nil {
@ -141,12 +141,12 @@ func (tx *Tx) ExecContext(ctx context.Context, query string, args ...interface{}
} }
// ExecStruct executes query with args in a struct // ExecStruct executes query with args in a struct
func (tx *Tx) ExecStruct(query string, st interface{}) (sql.Result, error) { func (tx *Tx) ExecStruct(query string, st any) (sql.Result, error) {
return tx.ExecStructContext(context.Background(), query, st) return tx.ExecStructContext(context.Background(), query, st)
} }
// QueryContext query with args // QueryContext query with args
func (tx *Tx) QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error) { func (tx *Tx) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error) {
hookCtx := contexts.NewContextHook(ctx, query, args) hookCtx := contexts.NewContextHook(ctx, query, args)
ctx, err := tx.db.beforeProcess(hookCtx) ctx, err := tx.db.beforeProcess(hookCtx)
if err != nil { if err != nil {
@ -164,12 +164,12 @@ func (tx *Tx) QueryContext(ctx context.Context, query string, args ...interface{
} }
// Query query with args // Query query with args
func (tx *Tx) Query(query string, args ...interface{}) (*Rows, error) { func (tx *Tx) Query(query string, args ...any) (*Rows, error) {
return tx.QueryContext(context.Background(), query, args...) return tx.QueryContext(context.Background(), query, args...)
} }
// QueryMapContext query with args in a map // QueryMapContext query with args in a map
func (tx *Tx) QueryMapContext(ctx context.Context, query string, mp interface{}) (*Rows, error) { func (tx *Tx) QueryMapContext(ctx context.Context, query string, mp any) (*Rows, error) {
query, args, err := MapToSlice(query, mp) query, args, err := MapToSlice(query, mp)
if err != nil { if err != nil {
return nil, err return nil, err
@ -178,12 +178,12 @@ func (tx *Tx) QueryMapContext(ctx context.Context, query string, mp interface{})
} }
// QueryMap query with args in a map // QueryMap query with args in a map
func (tx *Tx) QueryMap(query string, mp interface{}) (*Rows, error) { func (tx *Tx) QueryMap(query string, mp any) (*Rows, error) {
return tx.QueryMapContext(context.Background(), query, mp) return tx.QueryMapContext(context.Background(), query, mp)
} }
// QueryStructContext query with args in struct // QueryStructContext query with args in struct
func (tx *Tx) QueryStructContext(ctx context.Context, query string, st interface{}) (*Rows, error) { func (tx *Tx) QueryStructContext(ctx context.Context, query string, st any) (*Rows, error) {
query, args, err := StructToSlice(query, st) query, args, err := StructToSlice(query, st)
if err != nil { if err != nil {
return nil, err return nil, err
@ -192,23 +192,23 @@ func (tx *Tx) QueryStructContext(ctx context.Context, query string, st interface
} }
// QueryStruct query with args in struct // QueryStruct query with args in struct
func (tx *Tx) QueryStruct(query string, st interface{}) (*Rows, error) { func (tx *Tx) QueryStruct(query string, st any) (*Rows, error) {
return tx.QueryStructContext(context.Background(), query, st) return tx.QueryStructContext(context.Background(), query, st)
} }
// QueryRowContext query one row with args // QueryRowContext query one row with args
func (tx *Tx) QueryRowContext(ctx context.Context, query string, args ...interface{}) *Row { func (tx *Tx) QueryRowContext(ctx context.Context, query string, args ...any) *Row {
rows, err := tx.QueryContext(ctx, query, args...) rows, err := tx.QueryContext(ctx, query, args...)
return &Row{rows, err} return &Row{rows, err}
} }
// QueryRow query one row with args // QueryRow query one row with args
func (tx *Tx) QueryRow(query string, args ...interface{}) *Row { func (tx *Tx) QueryRow(query string, args ...any) *Row {
return tx.QueryRowContext(context.Background(), query, args...) return tx.QueryRowContext(context.Background(), query, args...)
} }
// QueryRowMapContext query one row with args in a map // QueryRowMapContext query one row with args in a map
func (tx *Tx) QueryRowMapContext(ctx context.Context, query string, mp interface{}) *Row { func (tx *Tx) QueryRowMapContext(ctx context.Context, query string, mp any) *Row {
query, args, err := MapToSlice(query, mp) query, args, err := MapToSlice(query, mp)
if err != nil { if err != nil {
return &Row{nil, err} return &Row{nil, err}
@ -217,12 +217,12 @@ func (tx *Tx) QueryRowMapContext(ctx context.Context, query string, mp interface
} }
// QueryRowMap query one row with args in a map // QueryRowMap query one row with args in a map
func (tx *Tx) QueryRowMap(query string, mp interface{}) *Row { func (tx *Tx) QueryRowMap(query string, mp any) *Row {
return tx.QueryRowMapContext(context.Background(), query, mp) return tx.QueryRowMapContext(context.Background(), query, mp)
} }
// QueryRowStructContext query one row with args in struct // QueryRowStructContext query one row with args in struct
func (tx *Tx) QueryRowStructContext(ctx context.Context, query string, st interface{}) *Row { func (tx *Tx) QueryRowStructContext(ctx context.Context, query string, st any) *Row {
query, args, err := StructToSlice(query, st) query, args, err := StructToSlice(query, st)
if err != nil { if err != nil {
return &Row{nil, err} return &Row{nil, err}
@ -231,6 +231,6 @@ func (tx *Tx) QueryRowStructContext(ctx context.Context, query string, st interf
} }
// QueryRowStruct query one row with args in struct // QueryRowStruct query one row with args in struct
func (tx *Tx) QueryRowStruct(query string, st interface{}) *Row { func (tx *Tx) QueryRowStruct(query string, st any) *Row {
return tx.QueryRowStructContext(context.Background(), query, st) return tx.QueryRowStructContext(context.Background(), query, st)
} }

4
internal/json/gojson.go
View File

@ -19,11 +19,11 @@ func init() {
type GOjson struct{} type GOjson struct{}
// Marshal implements JSONInterface // Marshal implements JSONInterface
func (GOjson) Marshal(v interface{}) ([]byte, error) { func (GOjson) Marshal(v any) ([]byte, error) {
return gojson.Marshal(v) return gojson.Marshal(v)
} }
// Unmarshal implements JSONInterface // Unmarshal implements JSONInterface
func (GOjson) Unmarshal(data []byte, v interface{}) error { func (GOjson) Unmarshal(data []byte, v any) error {
return gojson.Unmarshal(data, v) return gojson.Unmarshal(data, v)
} }

14
internal/json/json.go
View File

@ -8,24 +8,22 @@ import "encoding/json"
// Interface represents an interface to handle json data // Interface represents an interface to handle json data
type Interface interface { type Interface interface {
Marshal(v interface{}) ([]byte, error) Marshal(v any) ([]byte, error)
Unmarshal(data []byte, v interface{}) error Unmarshal(data []byte, v any) error
} }
var ( // DefaultJSONHandler default json handler
// DefaultJSONHandler default json handler var DefaultJSONHandler Interface = StdJSON{}
DefaultJSONHandler Interface = StdJSON{}
)
// StdJSON implements JSONInterface via encoding/json // StdJSON implements JSONInterface via encoding/json
type StdJSON struct{} type StdJSON struct{}
// Marshal implements JSONInterface // Marshal implements JSONInterface
func (StdJSON) Marshal(v interface{}) ([]byte, error) { func (StdJSON) Marshal(v any) ([]byte, error) {
return json.Marshal(v) return json.Marshal(v)
} }
// Unmarshal implements JSONInterface // Unmarshal implements JSONInterface
func (StdJSON) Unmarshal(data []byte, v interface{}) error { func (StdJSON) Unmarshal(data []byte, v any) error {
return json.Unmarshal(data, v) return json.Unmarshal(data, v)
} }

4
internal/json/jsoniter.go
View File

@ -19,11 +19,11 @@ func init() {
type JSONiter struct{} type JSONiter struct{}
// Marshal implements JSONInterface // Marshal implements JSONInterface
func (JSONiter) Marshal(v interface{}) ([]byte, error) { func (JSONiter) Marshal(v any) ([]byte, error) {
return jsoniter.Marshal(v) return jsoniter.Marshal(v)
} }
// Unmarshal implements JSONInterface // Unmarshal implements JSONInterface
func (JSONiter) Unmarshal(data []byte, v interface{}) error { func (JSONiter) Unmarshal(data []byte, v any) error {
return jsoniter.Unmarshal(data, v) return jsoniter.Unmarshal(data, v)
} }

4
internal/statements/args.go
View File

@ -10,7 +10,7 @@ import (
) )
// WriteArg writes an arg // WriteArg writes an arg
func (statement *Statement) WriteArg(w *builder.BytesWriter, arg interface{}) error { func (statement *Statement) WriteArg(w *builder.BytesWriter, arg any) error {
switch argv := arg.(type) { switch argv := arg.(type) {
case *builder.Builder: case *builder.Builder:
if _, err := w.WriteString("("); err != nil { if _, err := w.WriteString("("); err != nil {
@ -40,7 +40,7 @@ func (statement *Statement) WriteArg(w *builder.BytesWriter, arg interface{}) er
} }
// WriteArgs writes args // WriteArgs writes args
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 { for i, arg := range args {
if err := statement.WriteArg(w, arg); err != nil { if err := statement.WriteArg(w, arg); err != nil {
return err return err

14
internal/statements/cond.go
View File

@ -27,17 +27,17 @@ func (statement *Statement) QuoteReplacer(w *builder.BytesWriter) *QuoteReplacer
} }
// Where add Where statement // 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...) return statement.And(query, args...)
} }
// And add Where & and statement // And add Where & and statement
func (statement *Statement) And(query interface{}, args ...interface{}) *Statement { func (statement *Statement) And(query any, args ...any) *Statement {
switch qr := query.(type) { switch qr := query.(type) {
case string: case string:
cond := builder.Expr(qr, args...) cond := builder.Expr(qr, args...)
statement.cond = statement.cond.And(cond) statement.cond = statement.cond.And(cond)
case map[string]interface{}: case map[string]any:
cond := make(builder.Eq) cond := make(builder.Eq)
for k, v := range qr { for k, v := range qr {
cond[statement.quote(k)] = v cond[statement.quote(k)] = v
@ -58,12 +58,12 @@ func (statement *Statement) And(query interface{}, args ...interface{}) *Stateme
} }
// Or add Where & Or statement // Or add Where & Or statement
func (statement *Statement) Or(query interface{}, args ...interface{}) *Statement { func (statement *Statement) Or(query any, args ...any) *Statement {
switch qr := query.(type) { switch qr := query.(type) {
case string: case string:
cond := builder.Expr(qr, args...) cond := builder.Expr(qr, args...)
statement.cond = statement.cond.Or(cond) statement.cond = statement.cond.Or(cond)
case map[string]interface{}: case map[string]any:
cond := make(builder.Eq) cond := make(builder.Eq)
for k, v := range qr { for k, v := range qr {
cond[statement.quote(k)] = v cond[statement.quote(k)] = v
@ -83,14 +83,14 @@ func (statement *Statement) Or(query interface{}, args ...interface{}) *Statemen
} }
// In generate "Where column IN (?) " statement // 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.quote(column), args...) in := builder.In(statement.quote(column), args...)
statement.cond = statement.cond.And(in) statement.cond = statement.cond.And(in)
return statement return statement
} }
// NotIn generate "Where column NOT IN (?) " 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.quote(column), args...) notIn := builder.NotIn(statement.quote(column), args...)
statement.cond = statement.cond.And(notIn) statement.cond = statement.cond.And(notIn)
return statement return statement

2
internal/statements/delete.go
View File

@ -84,7 +84,7 @@ func (statement *Statement) writeOrderCond(orderCondWriter *builder.BytesWriter,
} }
} }
func (statement *Statement) WriteDelete(realSQLWriter, deleteSQLWriter *builder.BytesWriter, nowTime func(*schemas.Column) (interface{}, time.Time, error)) error { func (statement *Statement) WriteDelete(realSQLWriter, deleteSQLWriter *builder.BytesWriter, nowTime func(*schemas.Column) (any, time.Time, error)) error {
tableNameNoQuote := statement.TableName() tableNameNoQuote := statement.TableName()
tableName := statement.dialect.Quoter().Quote(tableNameNoQuote) tableName := statement.dialect.Quoter().Quote(tableNameNoQuote)
table := statement.RefTable table := statement.RefTable

4
internal/statements/expr.go
View File

@ -24,7 +24,7 @@ func (err ErrUnsupportedExprType) Error() string {
// Expr represents an SQL express // Expr represents an SQL express
type Expr struct { type Expr struct {
ColName string ColName string
Arg interface{} Arg any
} }
// WriteArgs writes args to the writer // WriteArgs writes args to the writer
@ -66,7 +66,7 @@ func (exprs exprParams) ColNames() []string {
return cols return cols
} }
func (exprs *exprParams) Add(name string, arg interface{}) { func (exprs *exprParams) Add(name string, arg any) {
*exprs = append(*exprs, Expr{name, arg}) *exprs = append(*exprs, Expr{name, arg})
} }

6
internal/statements/insert.go
View File

@ -27,7 +27,7 @@ func (statement *Statement) writeInsertOutput(buf *strings.Builder, table *schem
} }
// GenInsertSQL generates insert beans SQL // GenInsertSQL generates insert beans SQL
func (statement *Statement) GenInsertSQL(colNames []string, args []interface{}) (string, []interface{}, error) { func (statement *Statement) GenInsertSQL(colNames []string, args []any) (string, []any, error) {
var ( var (
buf = builder.NewWriter() buf = builder.NewWriter()
exprs = statement.ExprColumns exprs = statement.ExprColumns
@ -177,7 +177,7 @@ func (statement *Statement) GenInsertSQL(colNames []string, args []interface{})
} }
// GenInsertMapSQL generates insert map SQL // GenInsertMapSQL generates insert map SQL
func (statement *Statement) GenInsertMapSQL(columns []string, args []interface{}) (string, []interface{}, error) { func (statement *Statement) GenInsertMapSQL(columns []string, args []any) (string, []any, error) {
var ( var (
buf = builder.NewWriter() buf = builder.NewWriter()
exprs = statement.ExprColumns exprs = statement.ExprColumns
@ -242,7 +242,7 @@ func (statement *Statement) GenInsertMapSQL(columns []string, args []interface{}
return buf.String(), buf.Args(), nil return buf.String(), buf.Args(), nil
} }
func (statement *Statement) GenInsertMultipleMapSQL(columns []string, argss [][]interface{}) (string, []interface{}, error) { func (statement *Statement) GenInsertMultipleMapSQL(columns []string, argss [][]any) (string, []any, error) {
var ( var (
buf = builder.NewWriter() buf = builder.NewWriter()
exprs = statement.ExprColumns exprs = statement.ExprColumns

2
internal/statements/join.go
View File

@ -15,7 +15,7 @@ import (
) )
// Join The joinOP should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN // Join The joinOP should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN
func (statement *Statement) Join(joinOP string, joinTable interface{}, condition interface{}, args ...interface{}) *Statement { func (statement *Statement) Join(joinOP string, joinTable any, condition any, args ...any) *Statement {
statement.joins = append(statement.joins, join{ statement.joins = append(statement.joins, join{
op: joinOP, op: joinOP,
table: joinTable, table: joinTable,

6
internal/statements/order_by.go
View File

@ -12,8 +12,8 @@ import (
) )
type orderBy struct { type orderBy struct {
orderStr interface{} orderStr any
orderArgs []interface{} orderArgs []any
direction string // ASC, DESC or "", "" means raw orderStr direction string // ASC, DESC or "", "" means raw orderStr
} }
@ -97,7 +97,7 @@ func (statement *Statement) writeOrderBys(w *builder.BytesWriter) error {
} }
// OrderBy generate "Order By order" statement // OrderBy generate "Order By order" statement
func (statement *Statement) OrderBy(order interface{}, args ...interface{}) *Statement { func (statement *Statement) OrderBy(order any, args ...any) *Statement {
ob := orderBy{order, args, ""} ob := orderBy{order, args, ""}
if err := ob.CheckValid(); err != nil { if err := ob.CheckValid(); err != nil {
statement.LastError = err statement.LastError = err

2
internal/statements/pk.go
View File

@ -36,7 +36,7 @@ func IsIDConditionWithNoTableErr(err error) bool {
} }
// ID generate "where id = ? " statement or for composite key "where key1 = ? and key2 = ?" // 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 {
switch t := id.(type) { switch t := id.(type) {
case *schemas.PK: case *schemas.PK:
statement.idParam = *t statement.idParam = *t

14
internal/statements/query.go
View File

@ -15,7 +15,7 @@ import (
) )
// GenQuerySQL generate query SQL // GenQuerySQL generate query SQL
func (statement *Statement) GenQuerySQL(sqlOrArgs ...interface{}) (string, []interface{}, error) { func (statement *Statement) GenQuerySQL(sqlOrArgs ...any) (string, []any, error) {
if len(sqlOrArgs) > 0 { if len(sqlOrArgs) > 0 {
return statement.ConvertSQLOrArgs(sqlOrArgs...) return statement.ConvertSQLOrArgs(sqlOrArgs...)
} }
@ -40,7 +40,7 @@ func (statement *Statement) GenQuerySQL(sqlOrArgs ...interface{}) (string, []int
} }
// GenSumSQL generates sum SQL // GenSumSQL generates sum SQL
func (statement *Statement) GenSumSQL(bean interface{}, columns ...string) (string, []interface{}, error) { func (statement *Statement) GenSumSQL(bean any, columns ...string) (string, []any, error) {
if statement.RawSQL != "" { if statement.RawSQL != "" {
return statement.GenRawSQL(), statement.RawParams, nil return statement.GenRawSQL(), statement.RawParams, nil
} }
@ -71,7 +71,7 @@ func (statement *Statement) GenSumSQL(bean interface{}, columns ...string) (stri
} }
// GenGetSQL generates Get SQL // GenGetSQL generates Get SQL
func (statement *Statement) GenGetSQL(bean interface{}) (string, []interface{}, error) { func (statement *Statement) GenGetSQL(bean any) (string, []any, error) {
var isStruct bool var isStruct bool
if bean != nil { if bean != nil {
v := rValue(bean) v := rValue(bean)
@ -127,7 +127,7 @@ func (statement *Statement) GenGetSQL(bean interface{}) (string, []interface{},
} }
// GenCountSQL generates the SQL for counting // GenCountSQL generates the SQL for counting
func (statement *Statement) GenCountSQL(beans ...interface{}) (string, []interface{}, error) { func (statement *Statement) GenCountSQL(beans ...any) (string, []any, error) {
if statement.RawSQL != "" { if statement.RawSQL != "" {
return statement.GenRawSQL(), statement.RawParams, nil return statement.GenRawSQL(), statement.RawParams, nil
} }
@ -286,12 +286,12 @@ func (statement *Statement) writeSelect(buf *builder.BytesWriter, columnStr stri
} }
// GenExistSQL generates Exist SQL // GenExistSQL generates Exist SQL
func (statement *Statement) GenExistSQL(bean ...interface{}) (string, []interface{}, error) { func (statement *Statement) GenExistSQL(bean ...any) (string, []any, error) {
if statement.RawSQL != "" { if statement.RawSQL != "" {
return statement.GenRawSQL(), statement.RawParams, nil return statement.GenRawSQL(), statement.RawParams, nil
} }
var b interface{} var b any
if len(bean) > 0 { if len(bean) > 0 {
b = bean[0] b = bean[0]
beanValue := reflect.ValueOf(bean[0]) beanValue := reflect.ValueOf(bean[0])
@ -393,7 +393,7 @@ func (statement *Statement) genSelectColumnStr() string {
} }
// GenFindSQL generates Find SQL // GenFindSQL generates Find SQL
func (statement *Statement) GenFindSQL(autoCond builder.Cond) (string, []interface{}, error) { func (statement *Statement) GenFindSQL(autoCond builder.Cond) (string, []any, error) {
if statement.RawSQL != "" { if statement.RawSQL != "" {
return statement.GenRawSQL(), statement.RawParams, nil return statement.GenRawSQL(), statement.RawParams, nil
} }

38
internal/statements/statement.go
View File

@ -36,9 +36,9 @@ var (
type join struct { type join struct {
op string op string
table interface{} table any
condition interface{} condition any
args []interface{} args []any
} }
// Statement save all the sql info for executing SQL // Statement save all the sql info for executing SQL
@ -59,7 +59,7 @@ type Statement struct {
AltTableName string AltTableName string
tableName string tableName string
RawSQL string RawSQL string
RawParams []interface{} RawParams []any
UseCascade bool UseCascade bool
UseAutoJoin bool UseAutoJoin bool
StoreEngine string StoreEngine string
@ -136,7 +136,7 @@ func (statement *Statement) Reset() {
statement.tableName = "" statement.tableName = ""
statement.idParam = nil statement.idParam = nil
statement.RawSQL = "" statement.RawSQL = ""
statement.RawParams = make([]interface{}, 0) statement.RawParams = make([]any, 0)
statement.UseAutoTime = true statement.UseAutoTime = true
statement.NoAutoCondition = false statement.NoAutoCondition = false
statement.IsDistinct = false statement.IsDistinct = false
@ -159,7 +159,7 @@ func (statement *Statement) Reset() {
} }
// SQL adds raw sql 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 t := query.(type) { switch t := query.(type) {
case (*builder.Builder): case (*builder.Builder):
var err error var err error
@ -192,12 +192,12 @@ func (statement *Statement) SetRefValue(v reflect.Value) error {
return nil return nil
} }
func rValue(bean interface{}) reflect.Value { func rValue(bean any) reflect.Value {
return reflect.Indirect(reflect.ValueOf(bean)) return reflect.Indirect(reflect.ValueOf(bean))
} }
// SetRefBean set ref bean // SetRefBean set ref bean
func (statement *Statement) SetRefBean(bean interface{}) error { func (statement *Statement) SetRefBean(bean any) error {
var err error var err error
statement.RefTable, err = statement.tagParser.ParseWithCache(rValue(bean)) statement.RefTable, err = statement.tagParser.ParseWithCache(rValue(bean))
if err != nil { if err != nil {
@ -212,7 +212,7 @@ func (statement *Statement) NeedTableName() bool {
} }
// Incr Generate "Update ... Set column = column + arg" 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 { if len(arg) > 0 {
statement.IncrColumns.Add(column, arg[0]) statement.IncrColumns.Add(column, arg[0])
} else { } else {
@ -222,7 +222,7 @@ func (statement *Statement) Incr(column string, arg ...interface{}) *Statement {
} }
// Decr Generate "Update ... Set column = column - arg" 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 { if len(arg) > 0 {
statement.DecrColumns.Add(column, arg[0]) statement.DecrColumns.Add(column, arg[0])
} else { } else {
@ -232,7 +232,7 @@ func (statement *Statement) Decr(column string, arg ...interface{}) *Statement {
} }
// SetExpr Generate "Update ... Set column = {expression}" 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 {
if e, ok := expression.(string); ok { if e, ok := expression.(string); ok {
statement.ExprColumns.Add(column, statement.dialect.Quoter().Replace(e)) statement.ExprColumns.Add(column, statement.dialect.Quoter().Replace(e))
} else { } else {
@ -271,7 +271,7 @@ func (statement *Statement) Limit(limit int, start ...int) *Statement {
} }
// SetTable tempororily set table name, the parameter could be a string or a pointer of struct // SetTable tempororily set table name, the parameter could be a string or a pointer of struct
func (statement *Statement) SetTable(tableNameOrBean interface{}) error { func (statement *Statement) SetTable(tableNameOrBean any) error {
v := rValue(tableNameOrBean) v := rValue(tableNameOrBean)
t := v.Type() t := v.Type()
if t.Kind() == reflect.Struct { if t.Kind() == reflect.Struct {
@ -365,7 +365,7 @@ func (statement *Statement) GenDelIndexSQL() []string {
return sqls return sqls
} }
func (statement *Statement) asDBCond(fieldValue reflect.Value, fieldType reflect.Type, col *schemas.Column, allUseBool, requiredField bool) (interface{}, bool, error) { func (statement *Statement) asDBCond(fieldValue reflect.Value, fieldType reflect.Type, col *schemas.Column, allUseBool, requiredField bool) (any, bool, error) {
switch fieldType.Kind() { switch fieldType.Kind() {
case reflect.Ptr: case reflect.Ptr:
if fieldValue.IsNil() { if fieldValue.IsNil() {
@ -501,7 +501,7 @@ func (statement *Statement) asDBCond(fieldValue reflect.Value, fieldType reflect
return fieldValue.Interface(), true, nil return fieldValue.Interface(), true, nil
} }
func (statement *Statement) buildConds2(table *schemas.Table, bean interface{}, func (statement *Statement) buildConds2(table *schemas.Table, bean any,
includeVersion bool, includeUpdated bool, includeNil bool, includeVersion bool, includeUpdated bool, includeNil bool,
includeAutoIncr bool, allUseBool bool, useAllCols bool, unscoped bool, includeAutoIncr bool, allUseBool bool, useAllCols bool, unscoped bool,
mustColumnMap map[string]bool, tableName, aliasName string, addedTableName bool, mustColumnMap map[string]bool, tableName, aliasName string, addedTableName bool,
@ -599,13 +599,13 @@ func (statement *Statement) buildConds2(table *schemas.Table, bean interface{},
} }
// BuildConds builds condition // BuildConds builds condition
func (statement *Statement) BuildConds(table *schemas.Table, bean interface{}, includeVersion bool, includeUpdated bool, includeNil bool, includeAutoIncr bool, addedTableName bool) (builder.Cond, error) { func (statement *Statement) BuildConds(table *schemas.Table, bean any, includeVersion bool, includeUpdated bool, includeNil bool, includeAutoIncr bool, addedTableName bool) (builder.Cond, error) {
return statement.buildConds2(table, bean, includeVersion, includeUpdated, includeNil, includeAutoIncr, statement.allUseBool, statement.useAllCols, return statement.buildConds2(table, bean, includeVersion, includeUpdated, includeNil, includeAutoIncr, statement.allUseBool, statement.useAllCols,
statement.unscoped, statement.MustColumnMap, statement.TableName(), statement.TableAlias, addedTableName) statement.unscoped, statement.MustColumnMap, statement.TableName(), statement.TableAlias, addedTableName)
} }
// MergeConds merge conditions from bean and id // MergeConds merge conditions from bean and id
func (statement *Statement) MergeConds(bean interface{}) error { func (statement *Statement) MergeConds(bean any) error {
if !statement.NoAutoCondition && statement.RefTable != nil { if !statement.NoAutoCondition && statement.RefTable != nil {
addedTableName := (len(statement.joins) > 0) addedTableName := (len(statement.joins) > 0)
autoCond, err := statement.BuildConds(statement.RefTable, bean, true, true, false, true, addedTableName) autoCond, err := statement.BuildConds(statement.RefTable, bean, true, true, false, true, addedTableName)
@ -624,7 +624,7 @@ func (statement *Statement) quoteColumnStr(columnStr string) string {
} }
// ConvertSQLOrArgs converts sql or args // ConvertSQLOrArgs converts sql or args
func (statement *Statement) ConvertSQLOrArgs(sqlOrArgs ...interface{}) (string, []interface{}, error) { func (statement *Statement) ConvertSQLOrArgs(sqlOrArgs ...any) (string, []any, error) {
sql, args, err := statement.convertSQLOrArgs(sqlOrArgs...) sql, args, err := statement.convertSQLOrArgs(sqlOrArgs...)
if err != nil { if err != nil {
return "", nil, err return "", nil, err
@ -632,11 +632,11 @@ func (statement *Statement) ConvertSQLOrArgs(sqlOrArgs ...interface{}) (string,
return statement.ReplaceQuote(sql), args, nil return statement.ReplaceQuote(sql), args, nil
} }
func (statement *Statement) convertSQLOrArgs(sqlOrArgs ...interface{}) (string, []interface{}, error) { func (statement *Statement) convertSQLOrArgs(sqlOrArgs ...any) (string, []any, error) {
switch sqlOrArgs[0].(type) { switch sqlOrArgs[0].(type) {
case string: case string:
if len(sqlOrArgs) > 1 { if len(sqlOrArgs) > 1 {
newArgs := make([]interface{}, 0, len(sqlOrArgs)-1) newArgs := make([]any, 0, len(sqlOrArgs)-1)
for _, arg := range sqlOrArgs[1:] { for _, arg := range sqlOrArgs[1:] {
if v, ok := arg.(time.Time); ok { if v, ok := arg.(time.Time); ok {
newArgs = append(newArgs, v.In(statement.defaultTimeZone).Format("2006-01-02 15:04:05")) newArgs = append(newArgs, v.In(statement.defaultTimeZone).Format("2006-01-02 15:04:05"))

2
internal/statements/statement_test.go
View File

@ -88,7 +88,7 @@ func TestConvertSQLOrArgs(t *testing.T) {
// ID int // ID int
// del *time.Time `xorm:"deleted"` // del *time.Time `xorm:"deleted"`
// } // }
args := []interface{}{ args := []any{
"INSERT `table` (`id`, `del`) VALUES (?, ?)", 1, (*time.Time)(nil), "INSERT `table` (`id`, `del`) VALUES (?, ?)", 1, (*time.Time)(nil),
} }
// before fix, here will panic // before fix, here will panic

16
internal/statements/update.go
View File

@ -67,7 +67,7 @@ func (statement *Statement) ifAddColUpdate(col *schemas.Column, includeVersion,
func (statement *Statement) BuildUpdates(tableValue reflect.Value, func (statement *Statement) BuildUpdates(tableValue reflect.Value,
includeVersion, includeUpdated, includeNil, includeVersion, includeUpdated, includeNil,
includeAutoIncr, update bool, includeAutoIncr, update bool,
) ([]string, []interface{}, error) { ) ([]string, []any, error) {
table := statement.RefTable table := statement.RefTable
allUseBool := statement.allUseBool allUseBool := statement.allUseBool
useAllCols := statement.useAllCols useAllCols := statement.useAllCols
@ -75,7 +75,7 @@ func (statement *Statement) BuildUpdates(tableValue reflect.Value,
nullableMap := statement.NullableMap nullableMap := statement.NullableMap
colNames := make([]string, 0) colNames := make([]string, 0)
args := make([]interface{}, 0) args := make([]any, 0)
for _, col := range table.Columns() { for _, col := range table.Columns() {
ok, err := statement.ifAddColUpdate(col, includeVersion, includeUpdated, includeNil, ok, err := statement.ifAddColUpdate(col, includeVersion, includeUpdated, includeNil,
@ -122,7 +122,7 @@ func (statement *Statement) BuildUpdates(tableValue reflect.Value,
} }
} }
var val interface{} var val any
if fieldValue.CanAddr() { if fieldValue.CanAddr() {
if structConvert, ok := fieldValue.Addr().Interface().(convert.Conversion); ok { if structConvert, ok := fieldValue.Addr().Interface().(convert.Conversion); ok {
@ -424,9 +424,9 @@ func (statement *Statement) writeUpdateLimit(updateWriter *builder.BytesWriter,
} }
} }
func (statement *Statement) GenConditionsFromMap(m interface{}) ([]builder.Cond, error) { func (statement *Statement) GenConditionsFromMap(m any) ([]builder.Cond, error) {
switch t := m.(type) { switch t := m.(type) {
case map[string]interface{}: case map[string]any:
conds := []builder.Cond{} conds := []builder.Cond{}
for k, v := range t { for k, v := range t {
conds = append(conds, builder.Eq{k: v}) conds = append(conds, builder.Eq{k: v})
@ -541,7 +541,7 @@ func (statement *Statement) writeExprSets(w *builder.BytesWriter, hasPreviousSet
return nil return nil
} }
func (statement *Statement) writeSetColumns(colNames []string, args []interface{}) func(w *builder.BytesWriter) error { func (statement *Statement) writeSetColumns(colNames []string, args []any) func(w *builder.BytesWriter) error {
return func(w *builder.BytesWriter) error { return func(w *builder.BytesWriter) error {
if len(colNames) == 0 { if len(colNames) == 0 {
return nil return nil
@ -564,7 +564,7 @@ func (statement *Statement) writeSetColumns(colNames []string, args []interface{
} }
} }
func (statement *Statement) writeUpdateSets(w *builder.BytesWriter, v reflect.Value, colNames []string, args []interface{}) error { func (statement *Statement) writeUpdateSets(w *builder.BytesWriter, v reflect.Value, colNames []string, args []any) error {
if err := statement.writeSetColumns(colNames, args)(w); err != nil { if err := statement.writeSetColumns(colNames, args)(w); err != nil {
return err return err
} }
@ -593,7 +593,7 @@ func (statement *Statement) writeUpdateSets(w *builder.BytesWriter, v reflect.Va
var ErrNoColumnsTobeUpdated = errors.New("no columns found to be updated") var ErrNoColumnsTobeUpdated = errors.New("no columns found to be updated")
func (statement *Statement) WriteUpdate(updateWriter *builder.BytesWriter, cond builder.Cond, v reflect.Value, colNames []string, args []interface{}) error { func (statement *Statement) WriteUpdate(updateWriter *builder.BytesWriter, cond builder.Cond, v reflect.Value, colNames []string, args []any) error {
if _, err := fmt.Fprintf(updateWriter, "UPDATE"); err != nil { if _, err := fmt.Fprintf(updateWriter, "UPDATE"); err != nil {
return err return err
} }

2
internal/statements/values.go
View File

@ -24,7 +24,7 @@ var (
) )
// Value2Interface convert a field value of a struct to interface for putting into database // Value2Interface convert a field value of a struct to interface for putting into database
func (statement *Statement) Value2Interface(col *schemas.Column, fieldValue reflect.Value) (interface{}, error) { func (statement *Statement) Value2Interface(col *schemas.Column, fieldValue reflect.Value) (any, error) {
if fieldValue.CanAddr() { if fieldValue.CanAddr() {
if fieldConvert, ok := fieldValue.Addr().Interface().(convert.Conversion); ok { if fieldConvert, ok := fieldValue.Addr().Interface().(convert.Conversion); ok {
data, err := fieldConvert.ToDB() data, err := fieldConvert.ToDB()

2
internal/utils/builder.go
View File

@ -12,7 +12,7 @@ import (
type BuildReader interface { type BuildReader interface {
String() string String() string
Args() []interface{} Args() []any
} }
// WriteBuilder writes writers to one // WriteBuilder writes writers to one

2
internal/utils/reflect.go
View File

@ -9,6 +9,6 @@ import (
) )
// ReflectValue returns value of a bean // ReflectValue returns value of a bean
func ReflectValue(bean interface{}) reflect.Value { func ReflectValue(bean any) reflect.Value {
return reflect.Indirect(reflect.ValueOf(bean)) return reflect.Indirect(reflect.ValueOf(bean))
} }

2
internal/utils/zero.go
View File

@ -17,7 +17,7 @@ type Zeroable interface {
var nilTime *time.Time var nilTime *time.Time
// IsZero returns false if k is nil or has a zero value // IsZero returns false if k is nil or has a zero value
func IsZero(k interface{}) bool { func IsZero(k any) bool {
if k == nil { if k == nil {
return true return true
} }

10
internal/utils/zero_test.go
View File

@ -13,11 +13,13 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
type MyInt int type (
type ZeroStruct struct{} MyInt int
ZeroStruct struct{}
)
func TestZero(t *testing.T) { func TestZero(t *testing.T) {
var zeroValues = []interface{}{ zeroValues := []any{
int8(0), int8(0),
int16(0), int16(0),
int(0), int(0),
@ -46,7 +48,7 @@ func TestZero(t *testing.T) {
} }
func TestIsValueZero(t *testing.T) { func TestIsValueZero(t *testing.T) {
var zeroReflectValues = []reflect.Value{ zeroReflectValues := []reflect.Value{
reflect.ValueOf(int8(0)), reflect.ValueOf(int8(0)),
reflect.ValueOf(int16(0)), reflect.ValueOf(int16(0)),
reflect.ValueOf(int(0)), reflect.ValueOf(int(0)),

8
iterate.go
View File

@ -11,18 +11,18 @@ import (
) )
// IterFunc only use by Iterate // IterFunc only use by Iterate
type IterFunc func(idx int, bean interface{}) error type IterFunc func(idx int, bean any) error
// Rows return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields // Rows return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields
// are conditions. // are conditions.
func (session *Session) Rows(bean interface{}) (*Rows, error) { func (session *Session) Rows(bean any) (*Rows, error) {
return newRows(session, bean) return newRows(session, bean)
} }
// Iterate record by record handle records from table, condiBeans's non-empty fields // Iterate record by record handle records from table, condiBeans's non-empty fields
// are conditions. beans could be []Struct, []*Struct, map[int64]Struct // are conditions. beans could be []Struct, []*Struct, map[int64]Struct
// map[int64]*Struct // map[int64]*Struct
func (session *Session) Iterate(bean interface{}, fun IterFunc) error { func (session *Session) Iterate(bean any, fun IterFunc) error {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -63,7 +63,7 @@ func (session *Session) BufferSize(size int) *Session {
return session return session
} }
func (session *Session) bufferIterate(bean interface{}, fun IterFunc) error { func (session *Session) bufferIterate(bean any, fun IterFunc) error {
bufferSize := session.statement.BufferSize bufferSize := session.statement.BufferSize
pLimitN := session.statement.LimitN pLimitN := session.statement.LimitN
if pLimitN != nil && bufferSize > *pLimitN { if pLimitN != nil && bufferSize > *pLimitN {

48
log/logger.go
View File

@ -33,14 +33,14 @@ const (
// Logger is a logger interface // Logger is a logger interface
type Logger interface { type Logger interface {
Debug(v ...interface{}) Debug(v ...any)
Debugf(format string, v ...interface{}) Debugf(format string, v ...any)
Error(v ...interface{}) Error(v ...any)
Errorf(format string, v ...interface{}) Errorf(format string, v ...any)
Info(v ...interface{}) Info(v ...any)
Infof(format string, v ...interface{}) Infof(format string, v ...any)
Warn(v ...interface{}) Warn(v ...any)
Warnf(format string, v ...interface{}) Warnf(format string, v ...any)
Level() LogLevel Level() LogLevel
SetLevel(l LogLevel) SetLevel(l LogLevel)
@ -55,28 +55,28 @@ var _ Logger = DiscardLogger{}
type DiscardLogger struct{} type DiscardLogger struct{}
// Debug empty implementation // Debug empty implementation
func (DiscardLogger) Debug(v ...interface{}) {} func (DiscardLogger) Debug(v ...any) {}
// Debugf empty implementation // Debugf empty implementation
func (DiscardLogger) Debugf(format string, v ...interface{}) {} func (DiscardLogger) Debugf(format string, v ...any) {}
// Error empty implementation // Error empty implementation
func (DiscardLogger) Error(v ...interface{}) {} func (DiscardLogger) Error(v ...any) {}
// Errorf empty implementation // Errorf empty implementation
func (DiscardLogger) Errorf(format string, v ...interface{}) {} func (DiscardLogger) Errorf(format string, v ...any) {}
// Info empty implementation // Info empty implementation
func (DiscardLogger) Info(v ...interface{}) {} func (DiscardLogger) Info(v ...any) {}
// Infof empty implementation // Infof empty implementation
func (DiscardLogger) Infof(format string, v ...interface{}) {} func (DiscardLogger) Infof(format string, v ...any) {}
// Warn empty implementation // Warn empty implementation
func (DiscardLogger) Warn(v ...interface{}) {} func (DiscardLogger) Warn(v ...any) {}
// Warnf empty implementation // Warnf empty implementation
func (DiscardLogger) Warnf(format string, v ...interface{}) {} func (DiscardLogger) Warnf(format string, v ...any) {}
// Level empty implementation // Level empty implementation
func (DiscardLogger) Level() LogLevel { func (DiscardLogger) Level() LogLevel {
@ -128,56 +128,56 @@ func NewSimpleLogger3(out io.Writer, prefix string, flag int, l LogLevel) *Simpl
} }
// Error implement ILogger // Error implement ILogger
func (s *SimpleLogger) Error(v ...interface{}) { func (s *SimpleLogger) Error(v ...any) {
if s.level <= LOG_ERR { if s.level <= LOG_ERR {
_ = s.ERR.Output(2, fmt.Sprintln(v...)) _ = s.ERR.Output(2, fmt.Sprintln(v...))
} }
} }
// Errorf implement ILogger // Errorf implement ILogger
func (s *SimpleLogger) Errorf(format string, v ...interface{}) { func (s *SimpleLogger) Errorf(format string, v ...any) {
if s.level <= LOG_ERR { if s.level <= LOG_ERR {
_ = s.ERR.Output(2, fmt.Sprintf(format, v...)) _ = s.ERR.Output(2, fmt.Sprintf(format, v...))
} }
} }
// Debug implement ILogger // Debug implement ILogger
func (s *SimpleLogger) Debug(v ...interface{}) { func (s *SimpleLogger) Debug(v ...any) {
if s.level <= LOG_DEBUG { if s.level <= LOG_DEBUG {
_ = s.DEBUG.Output(2, fmt.Sprintln(v...)) _ = s.DEBUG.Output(2, fmt.Sprintln(v...))
} }
} }
// Debugf implement ILogger // Debugf implement ILogger
func (s *SimpleLogger) Debugf(format string, v ...interface{}) { func (s *SimpleLogger) Debugf(format string, v ...any) {
if s.level <= LOG_DEBUG { if s.level <= LOG_DEBUG {
_ = s.DEBUG.Output(2, fmt.Sprintf(format, v...)) _ = s.DEBUG.Output(2, fmt.Sprintf(format, v...))
} }
} }
// Info implement ILogger // Info implement ILogger
func (s *SimpleLogger) Info(v ...interface{}) { func (s *SimpleLogger) Info(v ...any) {
if s.level <= LOG_INFO { if s.level <= LOG_INFO {
_ = s.INFO.Output(2, fmt.Sprintln(v...)) _ = s.INFO.Output(2, fmt.Sprintln(v...))
} }
} }
// Infof implement ILogger // Infof implement ILogger
func (s *SimpleLogger) Infof(format string, v ...interface{}) { func (s *SimpleLogger) Infof(format string, v ...any) {
if s.level <= LOG_INFO { if s.level <= LOG_INFO {
_ = s.INFO.Output(2, fmt.Sprintf(format, v...)) _ = s.INFO.Output(2, fmt.Sprintf(format, v...))
} }
} }
// Warn implement ILogger // Warn implement ILogger
func (s *SimpleLogger) Warn(v ...interface{}) { func (s *SimpleLogger) Warn(v ...any) {
if s.level <= LOG_WARNING { if s.level <= LOG_WARNING {
_ = s.WARN.Output(2, fmt.Sprintln(v...)) _ = s.WARN.Output(2, fmt.Sprintln(v...))
} }
} }
// Warnf implement ILogger // Warnf implement ILogger
func (s *SimpleLogger) Warnf(format string, v ...interface{}) { func (s *SimpleLogger) Warnf(format string, v ...any) {
if s.level <= LOG_WARNING { if s.level <= LOG_WARNING {
_ = s.WARN.Output(2, fmt.Sprintf(format, v...)) _ = s.WARN.Output(2, fmt.Sprintf(format, v...))
} }

16
log/logger_context.go
View File

@ -23,10 +23,10 @@ type SQLLogger interface {
type ContextLogger interface { type ContextLogger interface {
SQLLogger SQLLogger
Debugf(format string, v ...interface{}) Debugf(format string, v ...any)
Errorf(format string, v ...interface{}) Errorf(format string, v ...any)
Infof(format string, v ...interface{}) Infof(format string, v ...any)
Warnf(format string, v ...interface{}) Warnf(format string, v ...any)
Level() LogLevel Level() LogLevel
SetLevel(l LogLevel) SetLevel(l LogLevel)
@ -74,22 +74,22 @@ func (l *LoggerAdapter) AfterSQL(ctx LogContext) {
} }
// Debugf implements ContextLogger // Debugf implements ContextLogger
func (l *LoggerAdapter) Debugf(format string, v ...interface{}) { func (l *LoggerAdapter) Debugf(format string, v ...any) {
l.logger.Debugf(format, v...) l.logger.Debugf(format, v...)
} }
// Errorf implements ContextLogger // Errorf implements ContextLogger
func (l *LoggerAdapter) Errorf(format string, v ...interface{}) { func (l *LoggerAdapter) Errorf(format string, v ...any) {
l.logger.Errorf(format, v...) l.logger.Errorf(format, v...)
} }
// Infof implements ContextLogger // Infof implements ContextLogger
func (l *LoggerAdapter) Infof(format string, v ...interface{}) { func (l *LoggerAdapter) Infof(format string, v ...any) {
l.logger.Infof(format, v...) l.logger.Infof(format, v...)
} }
// Warnf implements ContextLogger // Warnf implements ContextLogger
func (l *LoggerAdapter) Warnf(format string, v ...interface{}) { func (l *LoggerAdapter) Warnf(format string, v ...any) {
l.logger.Warnf(format, v...) l.logger.Warnf(format, v...)
} }

16
log/syslogger.go
View File

@ -26,42 +26,42 @@ func NewSyslogLogger(w *syslog.Writer) *SyslogLogger {
} }
// Debug log content as Debug // Debug log content as Debug
func (s *SyslogLogger) Debug(v ...interface{}) { func (s *SyslogLogger) Debug(v ...any) {
_ = s.w.Debug(fmt.Sprint(v...)) _ = s.w.Debug(fmt.Sprint(v...))
} }
// Debugf log content as Debug and format // 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...)) _ = s.w.Debug(fmt.Sprintf(format, v...))
} }
// Error log content as Error // Error log content as Error
func (s *SyslogLogger) Error(v ...interface{}) { func (s *SyslogLogger) Error(v ...any) {
_ = s.w.Err(fmt.Sprint(v...)) _ = s.w.Err(fmt.Sprint(v...))
} }
// Errorf log content as Errorf and format // 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...)) _ = s.w.Err(fmt.Sprintf(format, v...))
} }
// Info log content as Info // Info log content as Info
func (s *SyslogLogger) Info(v ...interface{}) { func (s *SyslogLogger) Info(v ...any) {
_ = s.w.Info(fmt.Sprint(v...)) _ = s.w.Info(fmt.Sprint(v...))
} }
// Infof log content as Infof and format // 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...)) _ = s.w.Info(fmt.Sprintf(format, v...))
} }
// Warn log content as Warn // Warn log content as Warn
func (s *SyslogLogger) Warn(v ...interface{}) { func (s *SyslogLogger) Warn(v ...any) {
_ = s.w.Warning(fmt.Sprint(v...)) _ = s.w.Warning(fmt.Sprint(v...))
} }
// Warnf log content as Warnf and format // 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...)) _ = s.w.Warning(fmt.Sprintf(format, v...))
} }

26
processors.go
View File

@ -54,12 +54,12 @@ type AfterLoadSessionProcessor interface {
AfterLoad(*Session) AfterLoad(*Session)
} }
type executedProcessorFunc func(*Session, interface{}) error type executedProcessorFunc func(*Session, any) error
type executedProcessor struct { type executedProcessor struct {
fun executedProcessorFunc fun executedProcessorFunc
session *Session session *Session
bean interface{} bean any
} }
func (executor *executedProcessor) execute() error { func (executor *executedProcessor) execute() error {
@ -77,13 +77,13 @@ func (session *Session) executeProcessors() error {
return nil return nil
} }
func cleanupProcessorsClosures(slices *[]func(interface{})) { func cleanupProcessorsClosures(slices *[]func(any)) {
if len(*slices) > 0 { if len(*slices) > 0 {
*slices = make([]func(interface{}), 0) *slices = make([]func(any), 0)
} }
} }
func executeBeforeClosures(session *Session, bean interface{}) { func executeBeforeClosures(session *Session, bean any) {
// handle before delete processors // handle before delete processors
for _, closure := range session.beforeClosures { for _, closure := range session.beforeClosures {
closure(bean) closure(bean)
@ -91,27 +91,27 @@ func executeBeforeClosures(session *Session, bean interface{}) {
cleanupProcessorsClosures(&session.beforeClosures) cleanupProcessorsClosures(&session.beforeClosures)
} }
func executeBeforeSet(bean interface{}, fields []string, scanResults []interface{}) { func executeBeforeSet(bean any, fields []string, scanResults []any) {
if b, hasBeforeSet := bean.(BeforeSetProcessor); hasBeforeSet { if b, hasBeforeSet := bean.(BeforeSetProcessor); hasBeforeSet {
for ii, key := range fields { for ii, key := range fields {
b.BeforeSet(key, Cell(scanResults[ii].(*interface{}))) b.BeforeSet(key, Cell(scanResults[ii].(*any)))
} }
} }
} }
func executeAfterSet(bean interface{}, fields []string, scanResults []interface{}) { func executeAfterSet(bean any, fields []string, scanResults []any) {
if b, hasAfterSet := bean.(AfterSetProcessor); hasAfterSet { if b, hasAfterSet := bean.(AfterSetProcessor); hasAfterSet {
for ii, key := range fields { for ii, key := range fields {
b.AfterSet(key, Cell(scanResults[ii].(*interface{}))) b.AfterSet(key, Cell(scanResults[ii].(*any)))
} }
} }
} }
func buildAfterProcessors(session *Session, bean interface{}) { func buildAfterProcessors(session *Session, bean any) {
// handle afterClosures // handle afterClosures
for _, closure := range session.afterClosures { for _, closure := range session.afterClosures {
session.afterProcessors = append(session.afterProcessors, executedProcessor{ session.afterProcessors = append(session.afterProcessors, executedProcessor{
fun: func(sess *Session, bean interface{}) error { fun: func(sess *Session, bean any) error {
closure(bean) closure(bean)
return nil return nil
}, },
@ -122,7 +122,7 @@ func buildAfterProcessors(session *Session, bean interface{}) {
if a, has := bean.(AfterLoadProcessor); has { if a, has := bean.(AfterLoadProcessor); has {
session.afterProcessors = append(session.afterProcessors, executedProcessor{ session.afterProcessors = append(session.afterProcessors, executedProcessor{
fun: func(sess *Session, bean interface{}) error { fun: func(sess *Session, bean any) error {
a.AfterLoad() a.AfterLoad()
return nil return nil
}, },
@ -133,7 +133,7 @@ func buildAfterProcessors(session *Session, bean interface{}) {
if a, has := bean.(AfterLoadSessionProcessor); has { if a, has := bean.(AfterLoadSessionProcessor); has {
session.afterProcessors = append(session.afterProcessors, executedProcessor{ session.afterProcessors = append(session.afterProcessors, executedProcessor{
fun: func(sess *Session, bean interface{}) error { fun: func(sess *Session, bean any) error {
a.AfterLoad(sess) a.AfterLoad(sess)
return nil return nil
}, },

20
raw.go
View File

@ -11,7 +11,7 @@ import (
"xorm.io/xorm/v2/internal/core" "xorm.io/xorm/v2/internal/core"
) )
func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{}) { func (session *Session) queryPreprocess(sqlStr *string, paramStr ...any) {
for _, filter := range session.engine.dialect.Filters() { for _, filter := range session.engine.dialect.Filters() {
*sqlStr = filter.Do(session.ctx, *sqlStr) *sqlStr = filter.Do(session.ctx, *sqlStr)
} }
@ -20,7 +20,7 @@ func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{})
session.lastSQLArgs = paramStr 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() defer session.resetStatement()
if session.statement.LastError != nil { if session.statement.LastError != nil {
return nil, session.statement.LastError return nil, session.statement.LastError
@ -64,12 +64,12 @@ func (session *Session) queryRows(sqlStr string, args ...interface{}) (*core.Row
return session.tx.QueryContext(session.ctx, sqlStr, args...) return session.tx.QueryContext(session.ctx, sqlStr, args...)
} }
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...)) return core.NewRow(session.queryRows(sqlStr, args...))
} }
// Query runs a raw sql and return records as []map[string][]byte // Query runs a raw sql and return records as []map[string][]byte
func (session *Session) Query(sqlOrArgs ...interface{}) ([]map[string][]byte, error) { func (session *Session) Query(sqlOrArgs ...any) ([]map[string][]byte, error) {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -89,7 +89,7 @@ func (session *Session) Query(sqlOrArgs ...interface{}) ([]map[string][]byte, er
} }
// QueryString runs a raw sql and return records as []map[string]string // QueryString runs a raw sql and return records as []map[string]string
func (session *Session) QueryString(sqlOrArgs ...interface{}) ([]map[string]string, error) { func (session *Session) QueryString(sqlOrArgs ...any) ([]map[string]string, error) {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -109,7 +109,7 @@ func (session *Session) QueryString(sqlOrArgs ...interface{}) ([]map[string]stri
} }
// QuerySliceString runs a raw sql and return records as [][]string // QuerySliceString runs a raw sql and return records as [][]string
func (session *Session) QuerySliceString(sqlOrArgs ...interface{}) ([][]string, error) { func (session *Session) QuerySliceString(sqlOrArgs ...any) ([][]string, error) {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -128,8 +128,8 @@ func (session *Session) QuerySliceString(sqlOrArgs ...interface{}) ([][]string,
return session.engine.ScanStringSlices(rows) return session.engine.ScanStringSlices(rows)
} }
// QueryInterface runs a raw sql and return records as []map[string]interface{} // QueryInterface runs a raw sql and return records as []map[string]any
func (session *Session) QueryInterface(sqlOrArgs ...interface{}) ([]map[string]interface{}, error) { func (session *Session) QueryInterface(sqlOrArgs ...any) ([]map[string]any, error) {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -148,7 +148,7 @@ func (session *Session) QueryInterface(sqlOrArgs ...interface{}) ([]map[string]i
return session.engine.ScanInterfaceMaps(rows) return session.engine.ScanInterfaceMaps(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() defer session.resetStatement()
session.queryPreprocess(&sqlStr, args...) session.queryPreprocess(&sqlStr, args...)
@ -179,7 +179,7 @@ func (session *Session) exec(sqlStr string, args ...interface{}) (sql.Result, er
} }
// Exec raw sql // Exec raw sql
func (session *Session) Exec(sqlOrArgs ...interface{}) (sql.Result, error) { func (session *Session) Exec(sqlOrArgs ...any) (sql.Result, error) {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }

6
rows.go
View File

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

36
scan.go
View File

@ -18,9 +18,9 @@ import (
) )
// genScanResultsByBeanNullabale generates scan result // genScanResultsByBeanNullabale generates scan result
func genScanResultsByBeanNullable(bean interface{}) (interface{}, bool, error) { func genScanResultsByBeanNullable(bean any) (any, bool, error) {
switch t := bean.(type) { switch t := bean.(type) {
case *interface{}: case *any:
return t, false, nil return t, false, nil
case *sql.NullInt64, *sql.NullBool, *sql.NullFloat64, *sql.NullString, *sql.RawBytes, *[]byte: case *sql.NullInt64, *sql.NullBool, *sql.NullFloat64, *sql.NullString, *sql.RawBytes, *[]byte:
return t, false, nil return t, false, nil
@ -71,9 +71,9 @@ func genScanResultsByBeanNullable(bean interface{}) (interface{}, bool, error) {
} }
} }
func genScanResultsByBean(bean interface{}) (interface{}, bool, error) { func genScanResultsByBean(bean any) (any, bool, error) {
switch t := bean.(type) { switch t := bean.(type) {
case *interface{}: case *any:
return t, false, nil return t, false, nil
case *sql.NullInt64, *sql.NullBool, *sql.NullFloat64, *sql.NullString, case *sql.NullInt64, *sql.NullBool, *sql.NullFloat64, *sql.NullString,
*sql.RawBytes, *sql.RawBytes,
@ -129,8 +129,8 @@ func genScanResultsByBean(bean interface{}) (interface{}, bool, error) {
} }
} }
func (engine *Engine) scanStringInterface(rows *core.Rows, fields []string, types []*sql.ColumnType) ([]interface{}, error) { func (engine *Engine) scanStringInterface(rows *core.Rows, fields []string, types []*sql.ColumnType) ([]any, error) {
scanResults := make([]interface{}, len(types)) scanResults := make([]any, len(types))
for i := 0; i < len(types); i++ { for i := 0; i < len(types); i++ {
var s sql.NullString var s sql.NullString
scanResults[i] = &s scanResults[i] = &s
@ -143,13 +143,13 @@ func (engine *Engine) scanStringInterface(rows *core.Rows, fields []string, type
} }
// scan is a wrap of driver.Scan but will automatically change the input values according requirements // scan is a wrap of driver.Scan but will automatically change the input values according requirements
func (engine *Engine) scan(rows *core.Rows, fields []string, types []*sql.ColumnType, vv ...interface{}) error { func (engine *Engine) scan(rows *core.Rows, fields []string, types []*sql.ColumnType, vv ...any) error {
scanResults := make([]interface{}, 0, len(types)) scanResults := make([]any, 0, len(types))
replaces := make([]bool, 0, len(types)) replaces := make([]bool, 0, len(types))
var err error var err error
for _, v := range vv { for _, v := range vv {
var replaced bool var replaced bool
var scanResult interface{} var scanResult any
switch t := v.(type) { switch t := v.(type) {
case *big.Float, *time.Time, *sql.NullTime: case *big.Float, *time.Time, *sql.NullTime:
scanResult = &sql.NullString{} scanResult = &sql.NullString{}
@ -193,8 +193,8 @@ func (engine *Engine) scan(rows *core.Rows, fields []string, types []*sql.Column
return nil return nil
} }
func (engine *Engine) scanInterfaces(rows *core.Rows, fields []string, types []*sql.ColumnType) ([]interface{}, error) { func (engine *Engine) scanInterfaces(rows *core.Rows, fields []string, types []*sql.ColumnType) ([]any, error) {
scanResultContainers := make([]interface{}, len(types)) scanResultContainers := make([]any, len(types))
for i := 0; i < len(types); i++ { for i := 0; i < len(types); i++ {
scanResult, err := engine.driver.GenScanResult(types[i].DatabaseTypeName()) scanResult, err := engine.driver.GenScanResult(types[i].DatabaseTypeName())
if err != nil { if err != nil {
@ -209,11 +209,11 @@ func (engine *Engine) scanInterfaces(rows *core.Rows, fields []string, types []*
} }
//////////////////// ////////////////////
// row -> map[string]interface{} // row -> map[string]any
func (engine *Engine) row2mapInterface(rows *core.Rows, types []*sql.ColumnType, fields []string) (map[string]interface{}, error) { func (engine *Engine) row2mapInterface(rows *core.Rows, types []*sql.ColumnType, fields []string) (map[string]any, error) {
resultsMap := make(map[string]interface{}, len(fields)) resultsMap := make(map[string]any, len(fields))
scanResultContainers := make([]interface{}, len(fields)) scanResultContainers := make([]any, len(fields))
for i := 0; i < len(fields); i++ { for i := 0; i < len(fields); i++ {
scanResult, err := engine.driver.GenScanResult(types[i].DatabaseTypeName()) scanResult, err := engine.driver.GenScanResult(types[i].DatabaseTypeName())
if err != nil { if err != nil {
@ -236,7 +236,7 @@ func (engine *Engine) row2mapInterface(rows *core.Rows, types []*sql.ColumnType,
} }
// ScanInterfaceMap scan result from *core.Rows and return a map // ScanInterfaceMap scan result from *core.Rows and return a map
func (engine *Engine) ScanInterfaceMap(rows *core.Rows) (map[string]interface{}, error) { func (engine *Engine) ScanInterfaceMap(rows *core.Rows) (map[string]any, error) {
fields, err := rows.Columns() fields, err := rows.Columns()
if err != nil { if err != nil {
return nil, err return nil, err
@ -250,7 +250,7 @@ func (engine *Engine) ScanInterfaceMap(rows *core.Rows) (map[string]interface{},
} }
// ScanInterfaceMaps scan results from *core.Rows and return a slice of map // ScanInterfaceMaps scan results from *core.Rows and return a slice of map
func (engine *Engine) ScanInterfaceMaps(rows *core.Rows) (resultsSlice []map[string]interface{}, err error) { func (engine *Engine) ScanInterfaceMaps(rows *core.Rows) (resultsSlice []map[string]any, err error) {
fields, err := rows.Columns() fields, err := rows.Columns()
if err != nil { if err != nil {
return nil, err return nil, err
@ -277,7 +277,7 @@ func (engine *Engine) ScanInterfaceMaps(rows *core.Rows) (resultsSlice []map[str
// row -> map[string]string // row -> map[string]string
func (engine *Engine) row2mapStr(rows *core.Rows, types []*sql.ColumnType, fields []string) (map[string]string, error) { func (engine *Engine) row2mapStr(rows *core.Rows, types []*sql.ColumnType, fields []string) (map[string]string, error) {
scanResults := make([]interface{}, len(fields)) scanResults := make([]any, len(fields))
for i := 0; i < len(fields); i++ { for i := 0; i < len(fields); i++ {
var s sql.NullString var s sql.NullString
scanResults[i] = &s scanResults[i] = &s

24
schema.go
View File

@ -28,7 +28,7 @@ func (session *Session) Ping() error {
} }
// CreateTable create a table according a bean // CreateTable create a table according a bean
func (session *Session) CreateTable(bean interface{}) error { func (session *Session) CreateTable(bean any) error {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -36,7 +36,7 @@ func (session *Session) CreateTable(bean interface{}) error {
return session.createTable(bean) 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 { if err := session.statement.SetRefBean(bean); err != nil {
return err return err
} }
@ -67,7 +67,7 @@ func (session *Session) createTable(bean interface{}) error {
} }
// CreateIndexes create indexes // CreateIndexes create indexes
func (session *Session) CreateIndexes(bean interface{}) error { func (session *Session) CreateIndexes(bean any) error {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -75,7 +75,7 @@ func (session *Session) CreateIndexes(bean interface{}) error {
return session.createIndexes(bean) 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 { if err := session.statement.SetRefBean(bean); err != nil {
return err return err
} }
@ -91,14 +91,14 @@ func (session *Session) createIndexes(bean interface{}) error {
} }
// CreateUniques create uniques // CreateUniques create uniques
func (session *Session) CreateUniques(bean interface{}) error { func (session *Session) CreateUniques(bean any) error {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
return session.createUniques(bean) 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 { if err := session.statement.SetRefBean(bean); err != nil {
return err return err
} }
@ -114,7 +114,7 @@ func (session *Session) createUniques(bean interface{}) error {
} }
// DropIndexes drop indexes // DropIndexes drop indexes
func (session *Session) DropIndexes(bean interface{}) error { func (session *Session) DropIndexes(bean any) error {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -122,7 +122,7 @@ func (session *Session) DropIndexes(bean interface{}) error {
return session.dropIndexes(bean) 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 { if err := session.statement.SetRefBean(bean); err != nil {
return err return err
} }
@ -138,7 +138,7 @@ func (session *Session) dropIndexes(bean interface{}) error {
} }
// DropTable drop table will drop table if exist, if drop failed, it will return 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 { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -146,7 +146,7 @@ func (session *Session) DropTable(beanOrTableName interface{}) error {
return session.dropTable(beanOrTableName) return session.dropTable(beanOrTableName)
} }
func (session *Session) dropTable(beanOrTableName interface{}) error { func (session *Session) dropTable(beanOrTableName any) error {
tableName := session.engine.TableName(beanOrTableName) tableName := session.engine.TableName(beanOrTableName)
sqlStr, checkIfExist := session.engine.dialect.DropTableSQL(session.engine.TableName(tableName, true)) sqlStr, checkIfExist := session.engine.dialect.DropTableSQL(session.engine.TableName(tableName, true))
if !checkIfExist { if !checkIfExist {
@ -186,7 +186,7 @@ func (session *Session) dropTable(beanOrTableName interface{}) error {
} }
// IsTableExist if a table is exist // 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 { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -201,7 +201,7 @@ func (session *Session) isTableExist(tableName string) (bool, error) {
} }
// IsTableEmpty if table have any records // 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 { if session.isAutoClose {
defer session.Close() defer session.Close()
} }

4
schemas/column.go
View File

@ -76,7 +76,7 @@ func NewColumn(name, fieldName string, sqlType SQLType, len1, len2 int64, nullab
} }
// ValueOf returns column's filed of struct's value // ValueOf returns column's filed of struct's value
func (col *Column) ValueOf(bean interface{}) (*reflect.Value, error) { func (col *Column) ValueOf(bean any) (*reflect.Value, error) {
dataStruct := reflect.Indirect(reflect.ValueOf(bean)) dataStruct := reflect.Indirect(reflect.ValueOf(bean))
return col.ValueOfV(&dataStruct) return col.ValueOfV(&dataStruct)
} }
@ -99,7 +99,7 @@ func (col *Column) ValueOfV(dataStruct *reflect.Value) (*reflect.Value, error) {
} }
// ConvertID converts id content to suitable type according column type // ConvertID converts id content to suitable type according column type
func (col *Column) ConvertID(sid string) (interface{}, error) { func (col *Column) ConvertID(sid string) (any, error) {
if col.SQLType.IsNumeric() { if col.SQLType.IsNumeric() {
n, err := strconv.ParseInt(sid, 10, 64) n, err := strconv.ParseInt(sid, 10, 64)
if err != nil { if err != nil {

4
schemas/pk.go
View File

@ -12,10 +12,10 @@ import (
) )
// PK represents primary key values // PK represents primary key values
type PK []interface{} type PK []any
// NewPK creates primay keys // NewPK creates primay keys
func NewPK(pks ...interface{}) *PK { func NewPK(pks ...any) *PK {
p := PK(pks) p := PK(pks)
return &p return &p
} }

2
schemas/table.go
View File

@ -156,7 +156,7 @@ func (table *Table) AddIndex(index *Index) {
// IDOfV get id from one value of struct // IDOfV get id from one value of struct
func (table *Table) IDOfV(rv reflect.Value) (PK, error) { func (table *Table) IDOfV(rv reflect.Value) (PK, error) {
v := reflect.Indirect(rv) v := reflect.Indirect(rv)
pk := make([]interface{}, len(table.PrimaryKeys)) pk := make([]any, len(table.PrimaryKeys))
for i, col := range table.PKColumns() { for i, col := range table.PKColumns() {
var err error var err error

56
session.go
View File

@ -68,20 +68,20 @@ type Session struct {
autoResetStatement bool autoResetStatement bool
// !nashtsai! storing these beans due to yet committed tx // !nashtsai! storing these beans due to yet committed tx
afterInsertBeans map[interface{}]*[]func(interface{}) afterInsertBeans map[any]*[]func(any)
afterUpdateBeans map[interface{}]*[]func(interface{}) afterUpdateBeans map[any]*[]func(any)
afterDeleteBeans map[interface{}]*[]func(interface{}) afterDeleteBeans map[any]*[]func(any)
// -- // --
beforeClosures []func(interface{}) beforeClosures []func(any)
afterClosures []func(interface{}) afterClosures []func(any)
afterProcessors []executedProcessor afterProcessors []executedProcessor
stmtCache map[uint32]*core.Stmt // key: hash.Hash32 of (queryStr, len(queryStr)) stmtCache map[uint32]*core.Stmt // key: hash.Hash32 of (queryStr, len(queryStr))
txStmtCache map[uint32]*core.Stmt // for tx statement txStmtCache map[uint32]*core.Stmt // for tx statement
lastSQL string lastSQL string
lastSQLArgs []interface{} lastSQLArgs []any
ctx context.Context ctx context.Context
sessionType sessionType sessionType sessionType
@ -122,17 +122,17 @@ func newSession(engine *Engine) *Session {
autoResetStatement: true, autoResetStatement: true,
prepareStmt: false, prepareStmt: false,
afterInsertBeans: make(map[interface{}]*[]func(interface{})), afterInsertBeans: make(map[any]*[]func(any)),
afterUpdateBeans: make(map[interface{}]*[]func(interface{})), afterUpdateBeans: make(map[any]*[]func(any)),
afterDeleteBeans: make(map[interface{}]*[]func(interface{})), afterDeleteBeans: make(map[any]*[]func(any)),
beforeClosures: make([]func(interface{}), 0), beforeClosures: make([]func(any), 0),
afterClosures: make([]func(interface{}), 0), afterClosures: make([]func(any), 0),
afterProcessors: make([]executedProcessor, 0), afterProcessors: make([]executedProcessor, 0),
stmtCache: make(map[uint32]*core.Stmt), stmtCache: make(map[uint32]*core.Stmt),
txStmtCache: make(map[uint32]*core.Stmt), txStmtCache: make(map[uint32]*core.Stmt),
lastSQL: "", lastSQL: "",
lastSQLArgs: make([]interface{}, 0), lastSQLArgs: make([]any, 0),
sessionType: engineSession, sessionType: engineSession,
} }
@ -218,7 +218,7 @@ func (session *Session) Prepare() *Session {
} }
// Before Apply before Processor, affected bean is passed to closure arg // 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 { if closures != nil {
session.beforeClosures = append(session.beforeClosures, closures) session.beforeClosures = append(session.beforeClosures, closures)
} }
@ -226,7 +226,7 @@ func (session *Session) Before(closures func(interface{})) *Session {
} }
// After Apply after Processor, affected bean is passed to closure arg // 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 { if closures != nil {
session.afterClosures = append(session.afterClosures, closures) session.afterClosures = append(session.afterClosures, closures)
} }
@ -234,7 +234,7 @@ func (session *Session) After(closures func(interface{})) *Session {
} }
// Table can input a string or pointer to struct for special a table to operate. // 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 {
if err := session.statement.SetTable(tableNameOrBean); err != nil { if err := session.statement.SetTable(tableNameOrBean); err != nil {
session.statement.LastError = err session.statement.LastError = err
} }
@ -273,7 +273,7 @@ func (session *Session) Limit(limit int, start ...int) *Session {
// OrderBy provide order by query condition, the input parameter is the content // OrderBy provide order by query condition, the input parameter is the content
// after order by on a sql statement. // after order by on a sql statement.
func (session *Session) OrderBy(order interface{}, args ...interface{}) *Session { func (session *Session) OrderBy(order any, args ...any) *Session {
session.statement.OrderBy(order, args...) session.statement.OrderBy(order, args...)
return session return session
} }
@ -321,7 +321,7 @@ func (session *Session) MustLogSQL(logs ...bool) *Session {
} }
// Join join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN // 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 interface{}, args ...interface{}) *Session { func (session *Session) Join(joinOperator string, tablename any, condition any, args ...any) *Session {
session.statement.Join(joinOperator, tablename, condition, args...) session.statement.Join(joinOperator, tablename, condition, args...)
return session return session
} }
@ -374,7 +374,7 @@ func getField(dataStruct *reflect.Value, table *schemas.Table, field *QueryedFie
} }
// Cell cell is a result of one column field // Cell cell is a result of one column field
type Cell *interface{} type Cell *any
func (session *Session) rows2Beans(rows *core.Rows, columnsSchema *ColumnsSchema, fields []string, types []*sql.ColumnType, func (session *Session) rows2Beans(rows *core.Rows, columnsSchema *ColumnsSchema, fields []string, types []*sql.ColumnType,
table *schemas.Table, newElemFunc func([]string) reflect.Value, table *schemas.Table, newElemFunc func([]string) reflect.Value,
@ -395,7 +395,7 @@ func (session *Session) rows2Beans(rows *core.Rows, columnsSchema *ColumnsSchema
return err return err
} }
session.afterProcessors = append(session.afterProcessors, executedProcessor{ session.afterProcessors = append(session.afterProcessors, executedProcessor{
fun: func(*Session, interface{}) error { fun: func(*Session, any) error {
return sliceValueSetFunc(&newValue, pk) return sliceValueSetFunc(&newValue, pk)
}, },
session: session, session: session,
@ -405,14 +405,14 @@ func (session *Session) rows2Beans(rows *core.Rows, columnsSchema *ColumnsSchema
return rows.Err() return rows.Err()
} }
func (session *Session) row2Slice(rows *core.Rows, fields []string, types []*sql.ColumnType, bean interface{}) ([]interface{}, error) { func (session *Session) row2Slice(rows *core.Rows, fields []string, types []*sql.ColumnType, bean any) ([]any, error) {
for _, closure := range session.beforeClosures { for _, closure := range session.beforeClosures {
closure(bean) closure(bean)
} }
scanResults := make([]interface{}, len(fields)) scanResults := make([]any, len(fields))
for i := 0; i < len(fields); i++ { for i := 0; i < len(fields); i++ {
var cell interface{} var cell any
scanResults[i] = &cell scanResults[i] = &cell
} }
if err := session.engine.scan(rows, fields, types, scanResults...); err != nil { if err := session.engine.scan(rows, fields, types, scanResults...); err != nil {
@ -424,7 +424,7 @@ func (session *Session) row2Slice(rows *core.Rows, fields []string, types []*sql
return scanResults, nil return scanResults, nil
} }
func setJSON(fieldValue *reflect.Value, fieldType reflect.Type, scanResult interface{}) error { func setJSON(fieldValue *reflect.Value, fieldType reflect.Type, scanResult any) error {
bs, ok := convert.AsBytes(scanResult) bs, ok := convert.AsBytes(scanResult)
if !ok { if !ok {
return fmt.Errorf("unsupported database data type: %#v", scanResult) return fmt.Errorf("unsupported database data type: %#v", scanResult)
@ -457,9 +457,9 @@ func setJSON(fieldValue *reflect.Value, fieldType reflect.Type, scanResult inter
var uint8ZeroValue = reflect.ValueOf(uint8(0)) var uint8ZeroValue = reflect.ValueOf(uint8(0))
func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflect.Value, func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflect.Value,
scanResult interface{}, table *schemas.Table, scanResult any, table *schemas.Table,
) error { ) error {
v, ok := scanResult.(*interface{}) v, ok := scanResult.(*any)
if ok { if ok {
scanResult = *v scanResult = *v
} }
@ -625,7 +625,7 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec
return convert.AssignValue(fieldValue.Addr(), scanResult) return convert.AssignValue(fieldValue.Addr(), scanResult)
} }
func (session *Session) slice2Bean(scanResults []interface{}, columnsSchema *ColumnsSchema, fields []string, bean interface{}, dataStruct *reflect.Value, table *schemas.Table) (schemas.PK, error) { func (session *Session) slice2Bean(scanResults []any, columnsSchema *ColumnsSchema, fields []string, bean any, dataStruct *reflect.Value, table *schemas.Table) (schemas.PK, error) {
defer func() { defer func() {
executeAfterSet(bean, fields, scanResults) executeAfterSet(bean, fields, scanResults)
}() }()
@ -656,13 +656,13 @@ func (session *Session) slice2Bean(scanResults []interface{}, columnsSchema *Col
} }
// saveLastSQL stores executed query information // 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.lastSQL = sql
session.lastSQLArgs = args session.lastSQLArgs = args
} }
// LastSQL returns last query information // LastSQL returns last query information
func (session *Session) LastSQL() (string, []interface{}) { func (session *Session) LastSQL() (string, []any) {
return session.lastSQL, session.lastSQLArgs return session.lastSQL, session.lastSQLArgs
} }

12
stats.go
View File

@ -12,7 +12,7 @@ import (
// Count counts the records. bean's non-empty fields // Count counts the records. bean's non-empty fields
// are conditions. // are conditions.
func (session *Session) Count(bean ...interface{}) (int64, error) { func (session *Session) Count(bean ...any) (int64, error) {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -32,7 +32,7 @@ func (session *Session) Count(bean ...interface{}) (int64, error) {
} }
// sum call sum some column. bean's non-empty fields are conditions. // sum call sum some column. bean's non-empty fields are conditions.
func (session *Session) sum(res interface{}, bean interface{}, columnNames ...string) error { func (session *Session) sum(res any, bean any, columnNames ...string) error {
if session.isAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -59,23 +59,23 @@ func (session *Session) sum(res interface{}, bean interface{}, columnNames ...st
} }
// Sum call sum some column. bean's non-empty fields are conditions. // Sum call sum some column. bean's non-empty fields are conditions.
func (session *Session) Sum(bean interface{}, columnName string) (res float64, err error) { func (session *Session) Sum(bean any, columnName string) (res float64, err error) {
return res, session.sum(&res, bean, columnName) return res, session.sum(&res, bean, columnName)
} }
// SumInt call sum some column. bean's non-empty fields are conditions. // SumInt call sum some column. bean's non-empty fields are conditions.
func (session *Session) SumInt(bean interface{}, columnName string) (res int64, err error) { func (session *Session) SumInt(bean any, columnName string) (res int64, err error) {
return res, session.sum(&res, bean, columnName) return res, session.sum(&res, bean, columnName)
} }
// Sums call sum some columns. bean's non-empty fields are conditions. // Sums call sum some columns. bean's non-empty fields are conditions.
func (session *Session) Sums(bean interface{}, columnNames ...string) ([]float64, error) { func (session *Session) Sums(bean any, columnNames ...string) ([]float64, error) {
res := make([]float64, len(columnNames)) res := make([]float64, len(columnNames))
return res, session.sum(&res, bean, columnNames...) return res, session.sum(&res, bean, columnNames...)
} }
// SumsInt sum specify columns and return as []int64 instead of []float64 // SumsInt sum specify columns and return as []int64 instead of []float64
func (session *Session) SumsInt(bean interface{}, columnNames ...string) ([]int64, error) { func (session *Session) SumsInt(bean any, columnNames ...string) ([]int64, error) {
res := make([]int64, len(columnNames)) res := make([]int64, len(columnNames))
return res, session.sum(&res, bean, columnNames...) return res, session.sum(&res, bean, columnNames...)
} }

12
sync.go
View File

@ -24,14 +24,14 @@ type SyncResult struct{}
// Sync the new struct changes to database, this method will automatically add // Sync the new struct changes to database, this method will automatically add
// table, column, index, unique. but will not delete or change anything. // table, column, index, unique. but will not delete or change anything.
// If you change some field, you should change the database manually. // 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() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.Sync(beans...) return session.Sync(beans...)
} }
// SyncWithOptions sync the database schemas according options and table structs // SyncWithOptions sync the database schemas according options and table structs
func (engine *Engine) SyncWithOptions(opts SyncOptions, beans ...interface{}) (*SyncResult, error) { func (engine *Engine) SyncWithOptions(opts SyncOptions, beans ...any) (*SyncResult, error) {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
return session.SyncWithOptions(opts, beans...) return session.SyncWithOptions(opts, beans...)
@ -39,18 +39,18 @@ func (engine *Engine) SyncWithOptions(opts SyncOptions, beans ...interface{}) (*
// Sync2 synchronize structs to database tables // Sync2 synchronize structs to database tables
// Depricated // Depricated
func (engine *Engine) Sync2(beans ...interface{}) error { func (engine *Engine) Sync2(beans ...any) error {
return engine.Sync(beans...) return engine.Sync(beans...)
} }
// Sync2 synchronize structs to database tables // Sync2 synchronize structs to database tables
// Depricated // Depricated
func (session *Session) Sync2(beans ...interface{}) error { func (session *Session) Sync2(beans ...any) error {
return session.Sync(beans...) return session.Sync(beans...)
} }
// Sync synchronize structs to database tables // Sync synchronize structs to database tables
func (session *Session) Sync(beans ...interface{}) error { func (session *Session) Sync(beans ...any) error {
_, err := session.SyncWithOptions(SyncOptions{ _, err := session.SyncWithOptions(SyncOptions{
WarnIfDatabaseColumnMissed: false, WarnIfDatabaseColumnMissed: false,
IgnoreConstrains: false, IgnoreConstrains: false,
@ -59,7 +59,7 @@ func (session *Session) Sync(beans ...interface{}) error {
return err return err
} }
func (session *Session) SyncWithOptions(opts SyncOptions, beans ...interface{}) (*SyncResult, error) { func (session *Session) SyncWithOptions(opts SyncOptions, beans ...any) (*SyncResult, error) {
engine := session.engine engine := session.engine
if session.isAutoClose { if session.isAutoClose {

6
tests/engine_test.go
View File

@ -57,7 +57,7 @@ func TestAutoTransaction(t *testing.T) {
engine := testEngine.(*xorm.Engine) engine := testEngine.(*xorm.Engine)
// will success // will success
_, err := engine.Transaction(func(session *xorm.Session) (interface{}, error) { _, err := engine.Transaction(func(session *xorm.Session) (any, error) {
_, err := session.Insert(TestTx{Msg: "hi"}) _, err := session.Insert(TestTx{Msg: "hi"})
assert.NoError(t, err) assert.NoError(t, err)
@ -70,7 +70,7 @@ func TestAutoTransaction(t *testing.T) {
assert.EqualValues(t, true, has) assert.EqualValues(t, true, has)
// will rollback // will rollback
_, err = engine.Transaction(func(session *xorm.Session) (interface{}, error) { _, err = engine.Transaction(func(session *xorm.Session) (any, error) {
_, err := session.Insert(TestTx{Msg: "hello"}) _, err := session.Insert(TestTx{Msg: "hello"})
assert.NoError(t, err) assert.NoError(t, err)
@ -83,7 +83,7 @@ func TestAutoTransaction(t *testing.T) {
assert.EqualValues(t, false, has) assert.EqualValues(t, false, has)
} }
func assertSync(t *testing.T, beans ...interface{}) { func assertSync(t *testing.T, beans ...any) {
for _, bean := range beans { for _, bean := range beans {
t.Run(testEngine.TableName(bean, true), func(t *testing.T) { t.Run(testEngine.TableName(bean, true), func(t *testing.T) {
assert.NoError(t, testEngine.DropTables(bean)) assert.NoError(t, testEngine.DropTables(bean))

28
tests/processors_test.go
View File

@ -32,7 +32,7 @@ func TestBefore_Get(t *testing.T) {
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
var be BeforeTable var be BeforeTable
has, err := testEngine.Before(func(bean interface{}) { has, err := testEngine.Before(func(bean any) {
bean.(*BeforeTable).Val = "val" bean.(*BeforeTable).Val = "val"
}).Get(&be) }).Get(&be)
assert.NoError(t, err) assert.NoError(t, err)
@ -60,7 +60,7 @@ func TestBefore_Find(t *testing.T) {
assert.EqualValues(t, 2, cnt) assert.EqualValues(t, 2, cnt)
var be []BeforeTable2 var be []BeforeTable2
err = testEngine.Before(func(bean interface{}) { err = testEngine.Before(func(bean any) {
bean.(*BeforeTable2).Val = "val" bean.(*BeforeTable2).Val = "val"
}).Find(&be) }).Find(&be)
assert.NoError(t, err) assert.NoError(t, err)
@ -133,7 +133,7 @@ func TestProcessors(t *testing.T) {
err = testEngine.CreateTables(&ProcessorsStruct{}) err = testEngine.CreateTables(&ProcessorsStruct{})
assert.NoError(t, err) assert.NoError(t, err)
b4InsertFunc := func(bean interface{}) { b4InsertFunc := func(bean any) {
if v, ok := (bean).(*ProcessorsStruct); ok { if v, ok := (bean).(*ProcessorsStruct); ok {
v.B4InsertViaExt = 1 v.B4InsertViaExt = 1
} else { } else {
@ -141,7 +141,7 @@ func TestProcessors(t *testing.T) {
} }
} }
afterInsertFunc := func(bean interface{}) { afterInsertFunc := func(bean any) {
if v, ok := (bean).(*ProcessorsStruct); ok { if v, ok := (bean).(*ProcessorsStruct); ok {
v.AfterInsertedViaExt = 1 v.AfterInsertedViaExt = 1
} else { } else {
@ -234,7 +234,7 @@ func TestProcessors(t *testing.T) {
// -- // --
// test update processors // test update processors
b4UpdateFunc := func(bean interface{}) { b4UpdateFunc := func(bean any) {
if v, ok := (bean).(*ProcessorsStruct); ok { if v, ok := (bean).(*ProcessorsStruct); ok {
v.B4UpdateViaExt = 1 v.B4UpdateViaExt = 1
} else { } else {
@ -242,7 +242,7 @@ func TestProcessors(t *testing.T) {
} }
} }
afterUpdateFunc := func(bean interface{}) { afterUpdateFunc := func(bean any) {
if v, ok := (bean).(*ProcessorsStruct); ok { if v, ok := (bean).(*ProcessorsStruct); ok {
v.AfterUpdatedViaExt = 1 v.AfterUpdatedViaExt = 1
} else { } else {
@ -274,7 +274,7 @@ func TestProcessors(t *testing.T) {
// -- // --
// test delete processors // test delete processors
b4DeleteFunc := func(bean interface{}) { b4DeleteFunc := func(bean any) {
if v, ok := (bean).(*ProcessorsStruct); ok { if v, ok := (bean).(*ProcessorsStruct); ok {
v.B4DeleteViaExt = 1 v.B4DeleteViaExt = 1
} else { } else {
@ -282,7 +282,7 @@ func TestProcessors(t *testing.T) {
} }
} }
afterDeleteFunc := func(bean interface{}) { afterDeleteFunc := func(bean any) {
if v, ok := (bean).(*ProcessorsStruct); ok { if v, ok := (bean).(*ProcessorsStruct); ok {
v.AfterDeletedViaExt = 1 v.AfterDeletedViaExt = 1
} else { } else {
@ -374,7 +374,7 @@ func TestProcessorsTx(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
p := &ProcessorsStruct{} p := &ProcessorsStruct{}
b4InsertFunc := func(bean interface{}) { b4InsertFunc := func(bean any) {
if v, ok := (bean).(*ProcessorsStruct); ok { if v, ok := (bean).(*ProcessorsStruct); ok {
v.B4InsertViaExt = 1 v.B4InsertViaExt = 1
} else { } else {
@ -382,7 +382,7 @@ func TestProcessorsTx(t *testing.T) {
} }
} }
afterInsertFunc := func(bean interface{}) { afterInsertFunc := func(bean any) {
if v, ok := (bean).(*ProcessorsStruct); ok { if v, ok := (bean).(*ProcessorsStruct); ok {
v.AfterInsertedViaExt = 1 v.AfterInsertedViaExt = 1
} else { } else {
@ -497,7 +497,7 @@ func TestProcessorsTx(t *testing.T) {
err = session.Begin() err = session.Begin()
assert.NoError(t, err) assert.NoError(t, err)
b4UpdateFunc := func(bean interface{}) { b4UpdateFunc := func(bean any) {
if v, ok := (bean).(*ProcessorsStruct); ok { if v, ok := (bean).(*ProcessorsStruct); ok {
v.B4UpdateViaExt = 1 v.B4UpdateViaExt = 1
} else { } else {
@ -505,7 +505,7 @@ func TestProcessorsTx(t *testing.T) {
} }
} }
afterUpdateFunc := func(bean interface{}) { afterUpdateFunc := func(bean any) {
if v, ok := (bean).(*ProcessorsStruct); ok { if v, ok := (bean).(*ProcessorsStruct); ok {
v.AfterUpdatedViaExt = 1 v.AfterUpdatedViaExt = 1
} else { } else {
@ -671,7 +671,7 @@ func TestProcessorsTx(t *testing.T) {
err = session.Begin() err = session.Begin()
assert.NoError(t, err) assert.NoError(t, err)
b4DeleteFunc := func(bean interface{}) { b4DeleteFunc := func(bean any) {
if v, ok := (bean).(*ProcessorsStruct); ok { if v, ok := (bean).(*ProcessorsStruct); ok {
v.B4DeleteViaExt = 1 v.B4DeleteViaExt = 1
} else { } else {
@ -679,7 +679,7 @@ func TestProcessorsTx(t *testing.T) {
} }
} }
afterDeleteFunc := func(bean interface{}) { afterDeleteFunc := func(bean any) {
if v, ok := (bean).(*ProcessorsStruct); ok { if v, ok := (bean).(*ProcessorsStruct); ok {
v.AfterDeletedViaExt = 1 v.AfterDeletedViaExt = 1
} else { } else {

2
tests/schema_test.go
View File

@ -719,7 +719,7 @@ func TestSyncWithOptions(t *testing.T) {
assert.ElementsMatch(t, getKeysFromMap(tableInfoFromStruct.Indexes), getKeysFromMap(getIndicesOfBeanFromDB(t, &SyncWithOpts1{}))) assert.ElementsMatch(t, getKeysFromMap(tableInfoFromStruct.Indexes), getKeysFromMap(getIndicesOfBeanFromDB(t, &SyncWithOpts1{})))
} }
func getIndicesOfBeanFromDB(t *testing.T, bean interface{}) map[string]*schemas.Index { func getIndicesOfBeanFromDB(t *testing.T, bean any) map[string]*schemas.Index {
dbm, err := testEngine.DBMetas() dbm, err := testEngine.DBMetas()
assert.NoError(t, err) assert.NoError(t, err)

2
tests/session_cond_test.go
View File

@ -155,7 +155,7 @@ func TestIn(t *testing.T) {
} }
users = make([]Userinfo, 0) users = make([]Userinfo, 0)
var idsInterface []interface{} var idsInterface []any
for _, id := range ids { for _, id := range ids {
idsInterface = append(idsInterface, id) idsInterface = append(idsInterface, id)
} }

8
tests/session_find_test.go
View File

@ -146,7 +146,7 @@ func TestFind3(t *testing.T) {
err = testEngine.Cols("`team`.`id`"). err = testEngine.Cols("`team`.`id`").
Where("`team_user`.`org_id`=?", 1). Where("`team_user`.`org_id`=?", 1).
And("`team_user`.`uid`=?", 2). And("`team_user`.`uid`=?", 2).
Join("INNER", []interface{}{teamUser}, "`team_user`.`team_id`=`team`.`id`"). Join("INNER", []any{teamUser}, "`team_user`.`team_id`=`team`.`id`").
Find(&teams) Find(&teams)
assert.NoError(t, err) assert.NoError(t, err)
@ -162,7 +162,7 @@ func TestFind3(t *testing.T) {
err = testEngine.Cols("`team`.`id`"). err = testEngine.Cols("`team`.`id`").
Where("`tu`.`org_id`=?", 1). Where("`tu`.`org_id`=?", 1).
And("`tu`.`uid`=?", 2). And("`tu`.`uid`=?", 2).
Join("INNER", []interface{}{"team_user", "tu"}, "`tu`.`team_id`=`team`.`id`"). Join("INNER", []any{"team_user", "tu"}, "`tu`.`team_id`=`team`.`id`").
Find(&teams) Find(&teams)
assert.NoError(t, err) assert.NoError(t, err)
@ -170,7 +170,7 @@ func TestFind3(t *testing.T) {
err = testEngine.Cols("`team`.`id`"). err = testEngine.Cols("`team`.`id`").
Where("`tu`.`org_id`=?", 1). Where("`tu`.`org_id`=?", 1).
And("`tu`.`uid`=?", 2). And("`tu`.`uid`=?", 2).
Join("INNER", []interface{}{teamUser, "tu"}, "`tu`.`team_id`=`team`.`id`"). Join("INNER", []any{teamUser, "tu"}, "`tu`.`team_id`=`team`.`id`").
Find(&teams) Find(&teams)
assert.NoError(t, err) assert.NoError(t, err)
} }
@ -367,7 +367,7 @@ func TestFindInterface(t *testing.T) {
userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo") userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
username := testEngine.GetColumnMapper().Obj2Table("Username") username := testEngine.GetColumnMapper().Obj2Table("Username")
var idsInterface []interface{} var idsInterface []any
err := testEngine.Table(userinfo).Cols(username).Desc("id").Find(&idsInterface) err := testEngine.Table(userinfo).Cols(username).Desc("id").Find(&idsInterface)
assert.NoError(t, err) assert.NoError(t, err)
} }

6
tests/session_get_test.go
View File

@ -186,7 +186,7 @@ func TestGetVar(t *testing.T) {
assert.Equal(t, "1.5", valuesString["money"]) assert.Equal(t, "1.5", valuesString["money"])
{ {
valuesInter := make(map[string]interface{}) valuesInter := make(map[string]any)
has, err = testEngine.Table("get_var").Where("`id` = ?", 1).Select("*").Get(&valuesInter) has, err = testEngine.Table("get_var").Where("`id` = ?", 1).Select("*").Get(&valuesInter)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, true, has) assert.Equal(t, true, has)
@ -206,7 +206,7 @@ func TestGetVar(t *testing.T) {
assert.Equal(t, "28", valuesSliceString[2]) assert.Equal(t, "28", valuesSliceString[2])
assert.Equal(t, "1.5", valuesSliceString[3]) assert.Equal(t, "1.5", valuesSliceString[3])
valuesSliceInter := make([]interface{}, 5) valuesSliceInter := make([]any, 5)
has, err = testEngine.Table("get_var").Get(&valuesSliceInter) has, err = testEngine.Table("get_var").Get(&valuesSliceInter)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, true, has) assert.Equal(t, true, has)
@ -727,7 +727,7 @@ func TestGetViaMapCond(t *testing.T) {
r GetViaMapCond r GetViaMapCond
platformStr = colMapper.Obj2Table("Platform") platformStr = colMapper.Obj2Table("Platform")
indexStr = colMapper.Obj2Table("Index") indexStr = colMapper.Obj2Table("Index")
query = map[string]interface{}{ query = map[string]any{
platformStr: 1, platformStr: 1,
indexStr: 1, indexStr: 1,
} }

32
tests/session_insert_test.go
View File

@ -47,7 +47,7 @@ func TestInsertMulti(t *testing.T) {
assert.EqualValues(t, 3, num) assert.EqualValues(t, 3, num)
} }
func insertMultiDatas(step int, datas interface{}) (num int64, err error) { func insertMultiDatas(step int, datas any) (num int64, err error) {
sliceValue := reflect.Indirect(reflect.ValueOf(datas)) sliceValue := reflect.Indirect(reflect.ValueOf(datas))
var iLen int64 var iLen int64
if sliceValue.Kind() != reflect.Slice { if sliceValue.Kind() != reflect.Slice {
@ -62,7 +62,7 @@ func insertMultiDatas(step int, datas interface{}) (num int64, err error) {
defer session.Close() defer session.Close()
if err = callbackLooper(datas, step, if err = callbackLooper(datas, step,
func(innerDatas interface{}) error { func(innerDatas any) error {
n, e := session.InsertMulti(innerDatas) n, e := session.InsertMulti(innerDatas)
if e != nil { if e != nil {
return e return e
@ -77,7 +77,7 @@ func insertMultiDatas(step int, datas interface{}) (num int64, err error) {
return return
} }
func callbackLooper(datas interface{}, step int, actionFunc func(interface{}) error) (err error) { func callbackLooper(datas any, step int, actionFunc func(any) error) (err error) {
sliceValue := reflect.Indirect(reflect.ValueOf(datas)) sliceValue := reflect.Indirect(reflect.ValueOf(datas))
if sliceValue.Kind() != reflect.Slice { if sliceValue.Kind() != reflect.Slice {
return fmt.Errorf("not slice") return fmt.Errorf("not slice")
@ -94,7 +94,7 @@ func callbackLooper(datas interface{}, step int, actionFunc func(interface{}) er
} else { } else {
tempLen = sliceValue.Len() tempLen = sliceValue.Len()
} }
var tempInterface []interface{} var tempInterface []any
for j := i; j < tempLen; j++ { for j := i; j < tempLen; j++ {
tempInterface = append(tempInterface, sliceValue.Index(j).Interface()) tempInterface = append(tempInterface, sliceValue.Index(j).Interface())
} }
@ -482,7 +482,7 @@ func TestInsertMulti2Interface(t *testing.T) {
assertSync(t, new(Userinfo)) assertSync(t, new(Userinfo))
users := []interface{}{ users := []any{
Userinfo{Username: "xlw", Departname: "dev", Alias: "lunny2", Created: time.Now()}, Userinfo{Username: "xlw", Departname: "dev", Alias: "lunny2", Created: time.Now()},
Userinfo{Username: "xlw2", Departname: "dev", Alias: "lunny3", Created: time.Now()}, Userinfo{Username: "xlw2", Departname: "dev", Alias: "lunny3", Created: time.Now()},
Userinfo{Username: "xlw11", Departname: "dev", Alias: "lunny2", Created: time.Now()}, Userinfo{Username: "xlw11", Departname: "dev", Alias: "lunny2", Created: time.Now()},
@ -496,7 +496,7 @@ func TestInsertMulti2Interface(t *testing.T) {
} }
assert.EqualValues(t, len(users), cnt) assert.EqualValues(t, len(users), cnt)
users2 := []interface{}{ users2 := []any{
&Userinfo{Username: "1xlw", Departname: "dev", Alias: "lunny2", Created: time.Now()}, &Userinfo{Username: "1xlw", Departname: "dev", Alias: "lunny2", Created: time.Now()},
&Userinfo{Username: "1xlw2", Departname: "dev", Alias: "lunny3", Created: time.Now()}, &Userinfo{Username: "1xlw2", Departname: "dev", Alias: "lunny3", Created: time.Now()},
&Userinfo{Username: "1xlw11", Departname: "dev", Alias: "lunny2", Created: time.Now()}, &Userinfo{Username: "1xlw11", Departname: "dev", Alias: "lunny2", Created: time.Now()},
@ -683,7 +683,7 @@ func TestInsertMap(t *testing.T) {
assert.NoError(t, PrepareEngine()) assert.NoError(t, PrepareEngine())
assertSync(t, new(InsertMap)) assertSync(t, new(InsertMap))
cnt, err := testEngine.Table(new(InsertMap)).Insert(map[string]interface{}{ cnt, err := testEngine.Table(new(InsertMap)).Insert(map[string]any{
"width": 20, "width": 20,
"height": 10, "height": 10,
"name": "lunny", "name": "lunny",
@ -699,7 +699,7 @@ func TestInsertMap(t *testing.T) {
assert.EqualValues(t, 10, im.Height) assert.EqualValues(t, 10, im.Height)
assert.EqualValues(t, "lunny", im.Name) assert.EqualValues(t, "lunny", im.Name)
cnt, err = testEngine.Table("insert_map").Insert(map[string]interface{}{ cnt, err = testEngine.Table("insert_map").Insert(map[string]any{
"width": 30, "width": 30,
"height": 10, "height": 10,
"name": "lunny", "name": "lunny",
@ -718,7 +718,7 @@ func TestInsertMap(t *testing.T) {
assert.EqualValues(t, 10, ims[1].Height) assert.EqualValues(t, 10, ims[1].Height)
assert.EqualValues(t, "lunny", ims[1].Name) assert.EqualValues(t, "lunny", ims[1].Name)
cnt, err = testEngine.Table("insert_map").Insert([]map[string]interface{}{ cnt, err = testEngine.Table("insert_map").Insert([]map[string]any{
{ {
"width": 40, "width": 40,
"height": 10, "height": 10,
@ -797,7 +797,7 @@ func TestInsertWhere(t *testing.T) {
inserted, err = testEngine.Table(new(InsertWhere)).Where("`repo_id`=?", 1). inserted, err = testEngine.Table(new(InsertWhere)).Where("`repo_id`=?", 1).
SetExpr("`index`", "coalesce(MAX(`index`),0)+1"). SetExpr("`index`", "coalesce(MAX(`index`),0)+1").
Insert(map[string]interface{}{ Insert(map[string]any{
"repo_id": 1, "repo_id": 1,
"width": 20, "width": 20,
"height": 40, "height": 40,
@ -834,7 +834,7 @@ func TestInsertWhere(t *testing.T) {
inserted, err = testEngine.Table(new(InsertWhere)).Where("`repo_id`=?", 1). inserted, err = testEngine.Table(new(InsertWhere)).Where("`repo_id`=?", 1).
SetExpr("`index`", "coalesce(MAX(`index`),0)+1"). SetExpr("`index`", "coalesce(MAX(`index`),0)+1").
Insert(map[string]interface{}{ Insert(map[string]any{
"repo_id": 1, "repo_id": 1,
"name": "10';delete * from insert_where; --", "name": "10';delete * from insert_where; --",
}) })
@ -850,7 +850,7 @@ func TestInsertWhere(t *testing.T) {
inserted, err = testEngine.Table(new(InsertWhere)).Where("`repo_id`=?", 1). inserted, err = testEngine.Table(new(InsertWhere)).Where("`repo_id`=?", 1).
SetExpr("`index`", "coalesce(MAX(`index`),0)+1"). SetExpr("`index`", "coalesce(MAX(`index`),0)+1").
Insert(map[string]interface{}{ Insert(map[string]any{
"repo_id": 1, "repo_id": 1,
"name": "10\\';delete * from insert_where; --", "name": "10\\';delete * from insert_where; --",
}) })
@ -910,7 +910,7 @@ func TestInsertExpr2(t *testing.T) {
SetExpr("is_draft", true). SetExpr("is_draft", true).
SetExpr("num_commits", 0). SetExpr("num_commits", 0).
SetExpr("sha1", ""). SetExpr("sha1", "").
Insert(map[string]interface{}{ Insert(map[string]any{
"repo_id": 1, "repo_id": 1,
"is_tag": true, "is_tag": true,
}) })
@ -947,7 +947,7 @@ func TestMultipleInsertTableName(t *testing.T) {
err := trans.Begin() err := trans.Begin()
assert.NoError(t, err) assert.NoError(t, err)
rtArr := []interface{}{ rtArr := []any{
[]*NightlyRate{ []*NightlyRate{
{ID: 1}, {ID: 1},
{ID: 2}, {ID: 2},
@ -978,7 +978,7 @@ func TestInsertMultiWithOmit(t *testing.T) {
assert.NoError(t, testEngine.Sync(new(TestMultiOmit))) assert.NoError(t, testEngine.Sync(new(TestMultiOmit)))
l := []interface{}{ l := []any{
TestMultiOmit{Id: 1, Name: "1", Omitted: "1"}, TestMultiOmit{Id: 1, Name: "1", Omitted: "1"},
TestMultiOmit{Id: 2, Name: "1", Omitted: "2"}, TestMultiOmit{Id: 2, Name: "1", Omitted: "2"},
TestMultiOmit{Id: 3, Name: "1", Omitted: "3"}, TestMultiOmit{Id: 3, Name: "1", Omitted: "3"},
@ -1142,7 +1142,7 @@ func TestInsertMultipleMap(t *testing.T) {
assert.NoError(t, PrepareEngine()) assert.NoError(t, PrepareEngine())
assertSync(t, new(InsertMultipleMap)) assertSync(t, new(InsertMultipleMap))
cnt, err := testEngine.Table(new(InsertMultipleMap)).Insert([]map[string]interface{}{ cnt, err := testEngine.Table(new(InsertMultipleMap)).Insert([]map[string]any{
{ {
"width": 20, "width": 20,
"height": 10, "height": 10,

10
tests/session_iterate_test.go
View File

@ -33,7 +33,7 @@ func TestIterate(t *testing.T) {
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
cnt = 0 cnt = 0
err = testEngine.Iterate(new(UserIterate), func(i int, bean interface{}) error { err = testEngine.Iterate(new(UserIterate), func(i int, bean any) error {
user := bean.(*UserIterate) user := bean.(*UserIterate)
if cnt == 0 { if cnt == 0 {
assert.EqualValues(t, 1, user.Id) assert.EqualValues(t, 1, user.Id)
@ -69,7 +69,7 @@ func TestBufferIterate(t *testing.T) {
} }
cnt := 0 cnt := 0
err := testEngine.BufferSize(9).Iterate(new(UserBufferIterate), func(i int, bean interface{}) error { err := testEngine.BufferSize(9).Iterate(new(UserBufferIterate), func(i int, bean any) error {
user := bean.(*UserBufferIterate) user := bean.(*UserBufferIterate)
assert.EqualValues(t, cnt+1, user.Id) assert.EqualValues(t, cnt+1, user.Id)
assert.EqualValues(t, true, user.IsMan) assert.EqualValues(t, true, user.IsMan)
@ -80,7 +80,7 @@ func TestBufferIterate(t *testing.T) {
assert.EqualValues(t, size, cnt) assert.EqualValues(t, size, cnt)
cnt = 0 cnt = 0
err = testEngine.Limit(20).BufferSize(9).Iterate(new(UserBufferIterate), func(i int, bean interface{}) error { err = testEngine.Limit(20).BufferSize(9).Iterate(new(UserBufferIterate), func(i int, bean any) error {
user := bean.(*UserBufferIterate) user := bean.(*UserBufferIterate)
assert.EqualValues(t, cnt+1, user.Id) assert.EqualValues(t, cnt+1, user.Id)
assert.EqualValues(t, true, user.IsMan) assert.EqualValues(t, true, user.IsMan)
@ -91,7 +91,7 @@ func TestBufferIterate(t *testing.T) {
assert.EqualValues(t, size, cnt) assert.EqualValues(t, size, cnt)
cnt = 0 cnt = 0
err = testEngine.Limit(7).BufferSize(9).Iterate(new(UserBufferIterate), func(i int, bean interface{}) error { err = testEngine.Limit(7).BufferSize(9).Iterate(new(UserBufferIterate), func(i int, bean any) error {
user := bean.(*UserBufferIterate) user := bean.(*UserBufferIterate)
assert.EqualValues(t, cnt+1, user.Id) assert.EqualValues(t, cnt+1, user.Id)
assert.EqualValues(t, true, user.IsMan) assert.EqualValues(t, true, user.IsMan)
@ -102,7 +102,7 @@ func TestBufferIterate(t *testing.T) {
assert.EqualValues(t, 7, cnt) assert.EqualValues(t, 7, cnt)
cnt = 0 cnt = 0
err = testEngine.Where("`id` <= 10").BufferSize(2).Iterate(new(UserBufferIterate), func(i int, bean interface{}) error { err = testEngine.Where("`id` <= 10").BufferSize(2).Iterate(new(UserBufferIterate), func(i int, bean any) error {
user := bean.(*UserBufferIterate) user := bean.(*UserBufferIterate)
assert.EqualValues(t, cnt+1, user.Id) assert.EqualValues(t, cnt+1, user.Id)
assert.EqualValues(t, true, user.IsMan) assert.EqualValues(t, true, user.IsMan)

6
tests/session_query_test.go
View File

@ -72,7 +72,7 @@ func TestQueryString2(t *testing.T) {
assert.True(t, "0" == records[0]["msg"] || "false" == records[0]["msg"]) assert.True(t, "0" == records[0]["msg"] || "false" == records[0]["msg"])
} }
func toBool(i interface{}) bool { func toBool(i any) bool {
switch t := i.(type) { switch t := i.(type) {
case int32: case int32:
return t > 0 return t > 0
@ -422,7 +422,7 @@ func TestQueryBLOBInMySQL(t *testing.T) {
} }
{ {
arr := make([][]interface{}, 0) arr := make([][]any, 0)
err = testEngine.Table(testEngine.Quote(testEngine.TableName("avatar", true))).Cols("avatar").Find(&arr) err = testEngine.Table(testEngine.Quote(testEngine.TableName("avatar", true))).Cols("avatar").Find(&arr)
assert.NoError(t, err) assert.NoError(t, err)
for i, record := range arr { for i, record := range arr {
@ -433,7 +433,7 @@ func TestQueryBLOBInMySQL(t *testing.T) {
} }
{ {
arr := make([]map[string]interface{}, 0) arr := make([]map[string]any, 0)
err = testEngine.Table(testEngine.Quote(testEngine.TableName("avatar", true))).Cols("avatar").Find(&arr) err = testEngine.Table(testEngine.Quote(testEngine.TableName("avatar", true))).Cols("avatar").Find(&arr)
assert.NoError(t, err) assert.NoError(t, err)
for i, record := range arr { for i, record := range arr {

2
tests/session_tx_test.go
View File

@ -201,7 +201,7 @@ func TestInsertMulti2InterfaceTransaction(t *testing.T) {
err := session.Begin() err := session.Begin()
assert.NoError(t, err) assert.NoError(t, err)
users := []interface{}{ users := []any{
&Multi2InterfaceTransaction{Name: "a", Alias: "A"}, &Multi2InterfaceTransaction{Name: "a", Alias: "A"},
&Multi2InterfaceTransaction{Name: "b", Alias: "B"}, &Multi2InterfaceTransaction{Name: "b", Alias: "B"},
&Multi2InterfaceTransaction{Name: "c", Alias: "C"}, &Multi2InterfaceTransaction{Name: "c", Alias: "C"},

32
tests/session_update_test.go
View File

@ -36,14 +36,14 @@ func TestUpdateMap(t *testing.T) {
_, err := testEngine.Insert(&tb) _, err := testEngine.Insert(&tb)
assert.NoError(t, err) assert.NoError(t, err)
cnt, err := testEngine.Table("update_table").Where("`id` = ?", tb.Id).Update(map[string]interface{}{ cnt, err := testEngine.Table("update_table").Where("`id` = ?", tb.Id).Update(map[string]any{
"name": "test2", "name": "test2",
"age": 36, "age": 36,
}) })
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
cnt, err = testEngine.Table("update_table").ID(tb.Id).Update(map[string]interface{}{ cnt, err = testEngine.Table("update_table").ID(tb.Id).Update(map[string]any{
"name": "test2", "name": "test2",
"age": 36, "age": 36,
}) })
@ -51,7 +51,7 @@ func TestUpdateMap(t *testing.T) {
assert.True(t, statements.IsIDConditionWithNoTableErr(err)) assert.True(t, statements.IsIDConditionWithNoTableErr(err))
assert.EqualValues(t, 0, cnt) assert.EqualValues(t, 0, cnt)
cnt, err = testEngine.Table("update_table").Update(map[string]interface{}{ cnt, err = testEngine.Table("update_table").Update(map[string]any{
"name": "test2", "name": "test2",
"age": 36, "age": 36,
}, &UpdateTable{ }, &UpdateTable{
@ -270,7 +270,7 @@ func TestWithIn(t *testing.T) {
assert.EqualValues(t, 3, cnt) assert.EqualValues(t, 3, cnt)
} }
type Condi map[string]interface{} type Condi map[string]any
type UpdateAllCols struct { type UpdateAllCols struct {
Id int64 Id int64
@ -305,7 +305,7 @@ func TestUpdateMap2(t *testing.T) {
assert.NoError(t, PrepareEngine()) assert.NoError(t, PrepareEngine())
assertSync(t, new(UpdateMustCols)) assertSync(t, new(UpdateMustCols))
_, err := testEngine.Table("update_must_cols").Where("`id` =?", 1).Update(map[string]interface{}{ _, err := testEngine.Table("update_must_cols").Where("`id` =?", 1).Update(map[string]any{
"bool": true, "bool": true,
}) })
assert.NoError(t, err) assert.NoError(t, err)
@ -817,7 +817,7 @@ func TestNewUpdate(t *testing.T) {
Pw string `xorm:"VARCHAR(100)" json:"pw"` Pw string `xorm:"VARCHAR(100)" json:"pw"`
Token string `xorm:"TEXT" json:"token"` Token string `xorm:"TEXT" json:"token"`
Avatar string `xorm:"TEXT" json:"avatar"` Avatar string `xorm:"TEXT" json:"avatar"`
Extras interface{} `xorm:"JSON" json:"extras"` Extras any `xorm:"JSON" json:"extras"`
Created time.Time `xorm:"DATETIME created"` Created time.Time `xorm:"DATETIME created"`
Updated time.Time `xorm:"DATETIME updated"` Updated time.Time `xorm:"DATETIME updated"`
Deleted time.Time `xorm:"DATETIME deleted"` Deleted time.Time `xorm:"DATETIME deleted"`
@ -965,7 +965,7 @@ func TestUpdateMapCondition(t *testing.T) {
cnt, err := testEngine.Update(&UpdateMapCondition{ cnt, err := testEngine.Update(&UpdateMapCondition{
String: "string1", String: "string1",
}, map[string]interface{}{ }, map[string]any{
"id": c.Id, "id": c.Id,
}) })
assert.NoError(t, err) assert.NoError(t, err)
@ -1001,7 +1001,7 @@ func TestUpdateMapContent(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 18, c.Age) assert.EqualValues(t, 18, c.Age)
cnt, err := testEngine.Table(new(UpdateMapContent)).ID(c.Id).Update(map[string]interface{}{"age": 0}) cnt, err := testEngine.Table(new(UpdateMapContent)).ID(c.Id).Update(map[string]any{"age": 0})
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, cnt) assert.EqualValues(t, 1, cnt)
@ -1011,7 +1011,7 @@ func TestUpdateMapContent(t *testing.T) {
assert.True(t, has) assert.True(t, has)
assert.EqualValues(t, 0, c1.Age) assert.EqualValues(t, 0, c1.Age)
cnt, err = testEngine.Table(new(UpdateMapContent)).ID(c.Id).Update(map[string]interface{}{ cnt, err = testEngine.Table(new(UpdateMapContent)).ID(c.Id).Update(map[string]any{
"age": 16, "age": 16,
"is_man": false, "is_man": false,
"gender": 2, "gender": 2,
@ -1027,7 +1027,7 @@ func TestUpdateMapContent(t *testing.T) {
assert.EqualValues(t, false, c2.IsMan) assert.EqualValues(t, false, c2.IsMan)
assert.EqualValues(t, 2, c2.Gender) assert.EqualValues(t, 2, c2.Gender)
cnt, err = testEngine.Table(new(UpdateMapContent)).ID(c.Id).Update(map[string]interface{}{ cnt, err = testEngine.Table(new(UpdateMapContent)).ID(c.Id).Update(map[string]any{
"age": 15, "age": 15,
"is_man": true, "is_man": true,
"gender": 1, "gender": 1,
@ -1144,7 +1144,7 @@ func TestUpdateDeleted(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 0, cnt) assert.EqualValues(t, 0, cnt)
cnt, err = testEngine.Table(&UpdateDeletedStruct{}).ID(s.Id).Update(map[string]interface{}{ cnt, err = testEngine.Table(&UpdateDeletedStruct{}).ID(s.Id).Update(map[string]any{
"name": "test1", "name": "test1",
}) })
assert.NoError(t, err) assert.NoError(t, err)
@ -1288,13 +1288,13 @@ func TestUpdateMap3(t *testing.T) {
assertSync(t, new(UpdateMapUser)) assertSync(t, new(UpdateMapUser))
_, err := testEngine.Table(new(UpdateMapUser)).Insert(map[string]interface{}{ _, err := testEngine.Table(new(UpdateMapUser)).Insert(map[string]any{
"Fname": "first user name", "Fname": "first user name",
"Fver": 1, "Fver": 1,
}) })
assert.NoError(t, err) assert.NoError(t, err)
update := map[string]interface{}{ update := map[string]any{
"Fname": "user name", "Fname": "user name",
"Fver": 1, "Fver": 1,
} }
@ -1302,7 +1302,7 @@ func TestUpdateMap3(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, 1, rows) assert.EqualValues(t, 1, rows)
update = map[string]interface{}{ update = map[string]any{
"Name": "user name", "Name": "user name",
"Ver": 1, "Ver": 1,
} }
@ -1376,10 +1376,10 @@ func TestUpdateMultiplePK(t *testing.T) {
assert.EqualValues(t, 1, num) assert.EqualValues(t, 1, num)
test.Value = "4" test.Value = "4"
_, err = testEngine.ID([]interface{}{test.Id, test.Name}).Update(test) _, err = testEngine.ID([]any{test.Id, test.Name}).Update(test)
assert.NoError(t, err) assert.NoError(t, err)
type MySlice []interface{} type MySlice []any
test.Value = "5" test.Value = "5"
_, err = testEngine.ID(&MySlice{test.Id, test.Name}).Update(test) _, err = testEngine.ID(&MySlice{test.Id, test.Name}).Update(test)
assert.NoError(t, err) assert.NoError(t, err)

2
tests/tests.go
View File

@ -157,7 +157,7 @@ func createEngine(dbType, connStr string) error {
if err != nil { if err != nil {
return err return err
} }
tableNames := make([]interface{}, 0, len(tables)) tableNames := make([]any, 0, len(tables))
for _, table := range tables { for _, table := range tables {
tableNames = append(tableNames, table.Name) tableNames = append(tableNames, table.Name)
} }

4
tests/types_null_test.go
View File

@ -35,7 +35,7 @@ func (CustomStruct) String() string {
return "CustomStruct" return "CustomStruct"
} }
func (m *CustomStruct) Scan(value interface{}) error { func (m *CustomStruct) Scan(value any) error {
if value == nil { if value == nil {
m.Year, m.Month, m.Day = 0, 0, 0 m.Year, m.Month, m.Day = 0, 0, 0
return nil return nil
@ -261,7 +261,7 @@ func TestNullStructIterate(t *testing.T) {
if true { if true {
err := testEngine.Where("`age` IS NOT NULL").OrderBy("age").Iterate(new(NullStruct), err := testEngine.Where("`age` IS NOT NULL").OrderBy("age").Iterate(new(NullStruct),
func(i int, bean interface{}) error { func(i int, bean any) error {
nultype := bean.(*NullStruct) nultype := bean.(*NullStruct)
fmt.Println(i, nultype) fmt.Println(i, nultype)
return nil return nil

12
tx.go
View File

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

26
update.go
View File

@ -18,12 +18,12 @@ var (
ErrNoColumnsTobeUpdated = statements.ErrNoColumnsTobeUpdated ErrNoColumnsTobeUpdated = statements.ErrNoColumnsTobeUpdated
) )
func (session *Session) genAutoCond(condiBean interface{}) (builder.Cond, error) { func (session *Session) genAutoCond(condiBean any) (builder.Cond, error) {
if session.statement.NoAutoCondition { if session.statement.NoAutoCondition {
return builder.NewCond(), nil return builder.NewCond(), nil
} }
if c, ok := condiBean.(map[string]interface{}); ok { if c, ok := condiBean.(map[string]any); ok {
eq := make(builder.Eq) eq := make(builder.Eq)
for k, v := range c { for k, v := range c {
eq[session.engine.Quote(k)] = v eq[session.engine.Quote(k)] = v
@ -60,7 +60,7 @@ func (session *Session) genAutoCond(condiBean interface{}) (builder.Cond, error)
// 1.bool will defaultly be updated content nor conditions // 1.bool will defaultly be updated content nor conditions
// You should call UseBool if you have bool to use. // You should call UseBool if you have bool to use.
// 2.float32 & float64 may be not inexact as conditions // 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 { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -79,13 +79,13 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
closure(bean) closure(bean)
} }
cleanupProcessorsClosures(&session.beforeClosures) // cleanup after used cleanupProcessorsClosures(&session.beforeClosures) // cleanup after used
if processor, ok := interface{}(bean).(BeforeUpdateProcessor); ok { if processor, ok := any(bean).(BeforeUpdateProcessor); ok {
processor.BeforeUpdate() processor.BeforeUpdate()
} }
// -- // --
var colNames []string var colNames []string
var args []interface{} var args []any
var err error var err error
isMap := t.Kind() == reflect.Map isMap := t.Kind() == reflect.Map
isStruct := t.Kind() == reflect.Struct isStruct := t.Kind() == reflect.Struct
@ -109,7 +109,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
} }
} else if isMap { } else if isMap {
colNames = make([]string, 0) colNames = make([]string, 0)
args = make([]interface{}, 0) args = make([]any, 0)
bValue := reflect.Indirect(reflect.ValueOf(bean)) bValue := reflect.Indirect(reflect.ValueOf(bean))
for _, v := range bValue.MapKeys() { for _, v := range bValue.MapKeys() {
@ -139,7 +139,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
colName := col.Name colName := col.Name
if isStruct { if isStruct {
session.afterClosures = append(session.afterClosures, func(bean interface{}) { session.afterClosures = append(session.afterClosures, func(bean any) {
col := table.GetColumn(colName) col := table.GetColumn(colName)
setColumnTime(bean, col, t) setColumnTime(bean, col, t)
}) })
@ -206,7 +206,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
for _, closure := range session.afterClosures { for _, closure := range session.afterClosures {
closure(bean) closure(bean)
} }
if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok { if processor, ok := any(bean).(AfterUpdateProcessor); ok {
session.engine.logger.Debugf("[event] %v has after update processor", tableName) session.engine.logger.Debugf("[event] %v has after update processor", tableName)
processor.AfterUpdate() processor.AfterUpdate()
} }
@ -216,13 +216,13 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
if value, has := session.afterUpdateBeans[bean]; has && value != nil { if value, has := session.afterUpdateBeans[bean]; has && value != nil {
*value = append(*value, session.afterClosures...) *value = append(*value, session.afterClosures...)
} else { } else {
afterClosures := make([]func(interface{}), lenAfterClosures) afterClosures := make([]func(any), lenAfterClosures)
copy(afterClosures, session.afterClosures) copy(afterClosures, session.afterClosures)
// FIXME: if bean is a map type, it will panic because map cannot be as map key // FIXME: if bean is a map type, it will panic because map cannot be as map key
session.afterUpdateBeans[bean] = &afterClosures session.afterUpdateBeans[bean] = &afterClosures
} }
} else { } else {
if _, ok := interface{}(bean).(AfterUpdateProcessor); ok { if _, ok := any(bean).(AfterUpdateProcessor); ok {
session.afterUpdateBeans[bean] = nil session.afterUpdateBeans[bean] = nil
} }
} }
@ -233,10 +233,10 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
return res.RowsAffected() 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 table := session.statement.RefTable
colNames := make([]string, 0, len(table.ColumnsSeq())) 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() { for _, col := range table.Columns() {
if !col.IsVersion && !col.IsCreated && !col.IsUpdated { if !col.IsVersion && !col.IsCreated && !col.IsUpdated {
@ -292,7 +292,7 @@ func (session *Session) genUpdateColumns(bean interface{}) ([]string, []interfac
args = append(args, val) args = append(args, val)
colName := col.Name colName := col.Name
session.afterClosures = append(session.afterClosures, func(bean interface{}) { session.afterClosures = append(session.afterClosures, func(bean any) {
col := table.GetColumn(colName) col := table.GetColumn(colName)
setColumnTime(bean, col, t) setColumnTime(bean, col, t)
}) })