improve package gjson; replace fmt.Errorf to gerror; improve examples for package gdb

.example/database/gdb/mysql/config.toml

@@ -4,7 +4,7 @@
     [database.logger]
         Level   = "all"
         Stdout  = true
-        CtxKeys = ["Trace-Id"]
+        CtxKeys = ["RequestId"]
     [database.default]
         link   = "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
         debug  = true

.example/database/gdb/mysql/config/gdb.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"github.com/gogf/gf/database/gdb"
+	"github.com/gogf/gf/os/gctx"
 	"sync"
 	"time"
 )
@@ -24,13 +25,16 @@ func init() {
 }
 
 func main() {
-	wg := sync.WaitGroup{}
+	var (
+		wg  = sync.WaitGroup{}
+		ctx = gctx.New()
+	)
 	for i := 0; i < 100000; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			time.Sleep(10 * time.Second)
-			db.Table("user").Where("id=1").All()
+			db.Ctx(ctx).Model("user").Where("id=1").All()
 		}()
 	}
 	wg.Wait()

.example/database/gdb/mysql/gdb_all.go

@@ -3,26 +3,22 @@ package main
 import (
 	"fmt"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gctx"
 )
 
 func main() {
-	db := g.DB()
+	var (
+		db  = g.DB()
+		ctx = gctx.New()
+	)
 	// 开启调试模式，以便于记录所有执行的SQL
 	db.SetDebug(true)
 
-	r, e := db.GetAll("SELECT * from `user` where id in(?)", g.Slice{})
+	r, e := db.Ctx(ctx).GetAll("SELECT * from `user` where id in(?)", g.Slice{})
 	if e != nil {
 		fmt.Println(e)
 	}
 	if r != nil {
 		fmt.Println(r)
 	}
-	return
-	//r, e := db.Table("user").Where("id in(?)", g.Slice{}).All()
-	//if e != nil {
-	//	fmt.Println(e)
-	//}
-	//if r != nil {
-	//	fmt.Println(r.List())
-	//}
 }

.example/database/gdb/mysql/gdb_args_slice.go

@@ -2,12 +2,18 @@ package main
 
 import (
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gctx"
 )
 
 func main() {
-	db := g.DB()
+	var (
+		db  = g.DB()
+		ctx = gctx.New()
+	)
 
-	db.Table("user").Where("nickname like ? and passport like ?", g.Slice{"T3", "t3"}).OrderBy("id asc").All()
+	db.Ctx(ctx).Model("user").
+		Where("nickname like ? and passport like ?", g.Slice{"T3", "t3"}).
+		OrderAsc("id").All()
 
 	conditions := g.Map{
 		"nickname like ?":    "%T%",
@@ -16,8 +22,8 @@ func main() {
 		"create_time > ?":    0,
 		"id in(?)":           g.Slice{1, 2, 3},
 	}
-	db.Table("user").Where(conditions).OrderBy("id asc").All()
+	db.Ctx(ctx).Model("user").Where(conditions).OrderAsc("id").All()
 
 	var params []interface{}
-	db.Table("user").Where("1=1", params).OrderBy("id asc").All()
+	db.Ctx(ctx).Model("user").Where("1=1", params).OrderAsc("id").All()
 }

.example/database/gdb/mysql/gdb_batch_insert.go

@@ -3,10 +3,14 @@ package main
 import (
 	"fmt"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gctx"
 )
 
 func main() {
-	db := g.DB()
+	var (
+		db  = g.DB()
+		ctx = gctx.New()
+	)
 	db.SetDebug(true)
 	list := make(g.List, 0)
 	for i := 0; i < 100; i++ {
@@ -14,7 +18,7 @@ func main() {
 			"name": fmt.Sprintf(`name_%d`, i),
 		})
 	}
-	r, e := db.Table("user").Data(list).Batch(2).Insert()
+	r, e := db.Ctx(ctx).Model("user").Data(list).Batch(2).Insert()
 	if e != nil {
 		panic(e)
 	}

.example/database/gdb/mysql/gdb_binary.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"github.com/gogf/gf/os/gctx"
 
 	"github.com/gogf/gf/crypto/gaes"
 	"github.com/gogf/gf/database/gdb"
@@ -19,6 +20,9 @@ func main() {
 		Role:    "master",
 		Charset: "utf8",
 	})
+	var (
+		ctx = gctx.New()
+	)
 	db, err := gdb.New()
 	if err != nil {
 		panic(err)
@@ -33,7 +37,7 @@ func main() {
 	}
 
 	// 写入
-	r, err := db.Table("user").Data(g.Map{
+	r, err := db.Ctx(ctx).Model("user").Data(g.Map{
 		"uid":  1,
 		"name": encryptedName,
 	}).Save()
@@ -43,9 +47,9 @@ func main() {
 	fmt.Println(r.RowsAffected())
 
 	// 查询
-	one, err := db.Table("user").Where("name=?", encryptedName).One()
+	one, err := db.Ctx(ctx).Model("user").Where("name=?", encryptedName).One()
 	if err != nil {
 		fmt.Println(err)
 	}
-	fmt.Println(one.ToMap())
+	fmt.Println(one.Map())
 }

.example/database/gdb/mysql/gdb_bit.go

@@ -2,19 +2,23 @@ package main
 
 import (
 	"fmt"
+	"github.com/gogf/gf/os/gctx"
 
 	"github.com/gogf/gf/frame/g"
 )
 
 func main() {
-	db := g.DB()
+	var (
+		db  = g.DB()
+		ctx = gctx.New()
+	)
 	db.SetDebug(true)
 
-	r, e := db.Table("test").All()
+	r, e := db.Ctx(ctx).Model("test").All()
 	if e != nil {
 		panic(e)
 	}
 	if r != nil {
-		fmt.Println(r.ToList())
+		fmt.Println(r.List())
 	}
 }

.example/database/gdb/mysql/gdb_cache.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"github.com/gogf/gf/database/gdb"
+	"github.com/gogf/gf/os/gctx"
 	"github.com/gogf/gf/util/gutil"
 	"time"
 )
@@ -17,6 +18,9 @@ func main() {
 		Role:    "master",
 		Charset: "utf8",
 	})
+	var (
+		ctx = gctx.New()
+	)
 	db, err := gdb.New()
 	if err != nil {
 		panic(err)
@@ -27,7 +31,7 @@ func main() {
 
 	// 执行2次查询并将查询结果缓存3秒，并可执行缓存名称(可选)
 	for i := 0; i < 3; i++ {
-		r, _ := db.Table("user").Cache(3000*time.Second).Where("id=?", 1).One()
+		r, _ := db.Ctx(ctx).Model("user").Cache(3000*time.Second).Where("id=?", 1).One()
 		gutil.Dump(r.Map())
 	}
 

.example/database/gdb/mysql/gdb_complecated.go

@@ -6,7 +6,7 @@ import (
 
 func main() {
 	// error!
-	r, err := g.DB().Table("user").Where(g.Map{
+	r, err := g.DB().Model("user").Where(g.Map{
 		"or": g.Map{
 			"nickname":       "jim",
 			"create_time > ": "2019-10-01",

.example/database/gdb/mysql/gdb_config.go

@@ -7,7 +7,7 @@ import (
 )
 
 func main() {
-	if r, err := g.DB().Table("user").Where("uid=?", 1).One(); err == nil {
+	if r, err := g.DB().Model("user").Where("uid=?", 1).One(); err == nil {
 		fmt.Println(r["uid"].Int())
 		fmt.Println(r["name"].String())
 	} else {

.example/database/gdb/mysql/gdb_config2.go

@@ -8,7 +8,7 @@ import (
 
 func main() {
 	g.Config().SetFileName("config2.toml")
-	if r, err := g.DB().Table("user").Where("uid=?", 1).One(); err == nil {
+	if r, err := g.DB().Model("user").Where("uid=?", 1).One(); err == nil {
 		fmt.Println(r["uid"].Int())
 		fmt.Println(r["name"].String())
 	} else {

.example/database/gdb/mysql/gdb_config3.go

@@ -8,14 +8,14 @@ import (
 
 func main() {
 	g.Config().SetFileName("config3.toml")
-	if r, err := g.DB().Table("user").Where("uid=?", 1).One(); err == nil {
+	if r, err := g.DB().Model("user").Where("uid=?", 1).One(); err == nil {
 		fmt.Println(r["uid"].Int())
 		fmt.Println(r["name"].String())
 	} else {
 		fmt.Println(err)
 	}
 
-	if r, err := g.DB("user").Table("user").Where("uid=?", 1).One(); err == nil {
+	if r, err := g.DB("user").Model("user").Where("uid=?", 1).One(); err == nil {
 		fmt.Println(r["uid"].Int())
 		fmt.Println(r["name"].String())
 	} else {

.example/database/gdb/mysql/gdb_ctx.go

@@ -6,7 +6,7 @@ import (
 )
 
 func main() {
-	ctx := context.WithValue(context.Background(), "Trace-Id", "123456789")
+	ctx := context.WithValue(context.Background(), "RequestId", "123456789")
 	_, err := g.DB().Ctx(ctx).Query("SELECT 1")
 	if err != nil {
 		panic(err)

.example/database/gdb/mysql/gdb_ctx_model.go

@@ -6,7 +6,7 @@ import (
 )
 
 func main() {
-	ctx := context.WithValue(context.Background(), "Trace-Id", "123456789")
+	ctx := context.WithValue(context.Background(), "RequestId", "123456789")
 	_, err := g.DB().Model("user").Ctx(ctx).All()
 	if err != nil {
 		panic(err)

.example/database/gdb/mysql/gdb_datetime.go

@@ -2,23 +2,20 @@ package main
 
 import (
 	"fmt"
+	"github.com/gogf/gf/os/gctx"
 
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/os/gtime"
 )
 
 func main() {
-	db := g.Database()
+	var (
+		db  = g.DB()
+		ctx = gctx.New()
+	)
 	db.SetDebug(true)
 
-	//r, err := db.Table("user").Data("create_time", gtime.Now().String()).Insert()
-	//if err == nil {
-	//    fmt.Println(r.LastInsertId())
-	//} else {
-	//    panic(err)
-	//}
-
-	r, err := db.Table("user").Data(g.Map{
+	r, err := db.Ctx(ctx).Model("user").Data(g.Map{
 		"name":        "john",
 		"create_time": gtime.Now().String(),
 	}).Insert()

.example/database/gdb/mysql/gdb_debug1.go

@@ -3,6 +3,7 @@ package main
 import (
 	"github.com/gogf/gf/database/gdb"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gctx"
 	"github.com/gogf/gf/os/glog"
 )
 
@@ -17,6 +18,9 @@ func main() {
 		Role:    "master",
 		Charset: "utf8",
 	})
+	var (
+		ctx = gctx.New()
+	)
 	db, err := gdb.New()
 	if err != nil {
 		panic(err)
@@ -27,11 +31,11 @@ func main() {
 
 	// 执行3条SQL查询
 	for i := 1; i <= 3; i++ {
-		db.Table("user").Where("uid=?", i).One()
+		db.Ctx(ctx).Model("user").Where("uid=?", i).One()
 	}
 	// 构造一条错误查询
-	db.Table("user").Where("no_such_field=?", "just_test").One()
+	db.Model("user").Where("no_such_field=?", "just_test").One()
 
-	db.Table("user").Data(g.Map{"name": "smith"}).Where("uid=?", 1).Save()
+	db.Ctx(ctx).Model("user").Data(g.Map{"name": "smith"}).Where("uid=?", 1).Save()
 
 }

.example/database/gdb/mysql/gdb_debug2.go

@@ -2,17 +2,21 @@ package main
 
 import (
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gctx"
 )
 
 func main() {
-	db := g.DB()
+	var (
+		db  = g.DB()
+		ctx = gctx.New()
+	)
 
 	// 执行3条SQL查询
 	for i := 1; i <= 3; i++ {
-		db.Table("user").Where("id=?", i).One()
+		db.Ctx(ctx).Model("user").Where("id=?", i).One()
 	}
 	// 构造一条错误查询
-	db.Table("user").Where("no_such_field=?", "just_test").One()
+	db.Ctx(ctx).Model("user").Where("no_such_field=?", "just_test").One()
 
-	db.Table("user").Data(g.Map{"name": "smith"}).Where("uid=?", 1).Save()
+	db.Ctx(ctx).Model("user").Data(g.Map{"name": "smith"}).Where("uid=?", 1).Save()
 }

.example/database/gdb/mysql/gdb_insert.go

@@ -18,7 +18,7 @@ func main() {
 
 	db.SetDebug(true)
 
-	r, e := db.Table("user").Data(g.Map{
+	r, e := db.Model("user").Data(g.Map{
 		"create_at": "now()",
 	}).Unscoped().Insert()
 	if e != nil {

.example/database/gdb/mysql/gdb_issue_278.go

@@ -8,7 +8,7 @@ import (
 
 var (
 	tableName = "orders"
-	dao       = g.DB().Table(tableName).Safe()
+	dao       = g.DB().Model(tableName).Safe()
 )
 
 type OrderServiceEntity struct {

.example/database/gdb/mysql/gdb_json_xml.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"github.com/gogf/gf/os/gctx"
 
 	"github.com/gogf/gf/database/gdb"
 	"github.com/gogf/gf/encoding/gparser"
@@ -19,19 +20,22 @@ func main() {
 		Role:    "master",
 		Charset: "utf8",
 	})
-	db := g.DB()
-	one, err := db.Table("user").Where("id=?", 1).One()
+	var (
+		db  = g.DB()
+		ctx = gctx.New()
+	)
+	one, err := db.Ctx(ctx).Model("user").Where("id=?", 1).One()
 	if err != nil {
 		panic(err)
 	}
 
 	// 使用内置方法转换为json/xml
-	fmt.Println(one.ToJson())
-	fmt.Println(one.ToXml())
+	fmt.Println(one.Json())
+	fmt.Println(one.Xml())
 
 	// 自定义方法方法转换为json/xml
-	jsonContent, _ := gparser.VarToJson(one.ToMap())
+	jsonContent, _ := gparser.VarToJson(one.Map())
 	fmt.Println(string(jsonContent))
-	xmlContent, _ := gparser.VarToXml(one.ToMap())
+	xmlContent, _ := gparser.VarToXml(one.Map())
 	fmt.Println(string(xmlContent))
 }

.example/database/gdb/mysql/gdb_pool.go

@@ -1,20 +1,24 @@
 package main
 
 import (
+	"github.com/gogf/gf/os/gctx"
 	"time"
 
 	"github.com/gogf/gf/frame/g"
 )
 
 func main() {
-	db := g.DB()
+	var (
+		db  = g.DB()
+		ctx = gctx.New()
+	)
 
 	// 开启调试模式，以便于记录所有执行的SQL
 	db.SetDebug(true)
 
 	for {
 		for i := 0; i < 10; i++ {
-			go db.Table("user").All()
+			go db.Ctx(ctx).Model("user").All()
 		}
 		time.Sleep(time.Millisecond * 100)
 	}

.example/database/gdb/mysql/gdb_reconnect.go

@@ -3,14 +3,18 @@ package main
 import (
 	"fmt"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gctx"
 	"time"
 )
 
 func main() {
-	db := g.DB()
+	var (
+		db  = g.DB()
+		ctx = gctx.New()
+	)
 	db.SetDebug(true)
 	for {
-		r, err := db.Table("user").All()
+		r, err := db.Ctx(ctx).Model("user").All()
 		fmt.Println(err)
 		fmt.Println(r)
 		time.Sleep(time.Second * 10)

.example/database/gdb/mysql/gdb_struct.go

@@ -17,7 +17,7 @@ func main() {
 	}
 	user := (*User)(nil)
 	fmt.Println(user)
-	err := db.Table("test").Where("id=1").Struct(&user)
+	err := db.Model("test").Where("id=1").Scan(&user)
 	fmt.Println(err)
 	fmt.Println(user)
 }

.example/database/gdb/mysql/gdb_tables.go

@@ -2,13 +2,17 @@ package main
 
 import (
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gctx"
 )
 
 func main() {
-	db := g.DB()
+	var (
+		db  = g.DB()
+		ctx = gctx.New()
+	)
 	db.SetDebug(true)
 
-	tables, err := db.Tables()
+	tables, err := db.Tables(ctx)
 	if err != nil {
 		panic(err)
 	}

.example/database/gdb/mysql/gdb_tables_fields.go

@@ -2,20 +2,24 @@ package main
 
 import (
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gctx"
 )
 
 func main() {
-	db := g.DB()
+	var (
+		db  = g.DB()
+		ctx = gctx.New()
+	)
 	db.SetDebug(true)
 
-	tables, e := db.Tables()
+	tables, e := db.Tables(ctx)
 	if e != nil {
 		panic(e)
 	}
 	if tables != nil {
 		g.Dump(tables)
 		for _, table := range tables {
-			fields, err := db.TableFields(table)
+			fields, err := db.TableFields(ctx, table)
 			if err != nil {
 				panic(err)
 			}

.example/database/gdb/mysql/gdb_transaction_closure.go

@@ -1,26 +1,29 @@
 package main
 
 import (
+	"context"
 	"github.com/gogf/gf/database/gdb"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gctx"
 )
 
 func main() {
 	var (
 		err   error
 		db    = g.DB()
+		ctx   = gctx.New()
 		table = "user"
 	)
-	if err = db.Transaction(func(tx *gdb.TX) error {
+	if err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
 		// Nested transaction 1.
-		if err = tx.Transaction(func(tx *gdb.TX) error {
+		if err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
 			_, err = tx.Model(table).Data(g.Map{"id": 1, "name": "john"}).Insert()
 			return err
 		}); err != nil {
 			return err
 		}
 		// Nested transaction 2, panic.
-		if err = tx.Transaction(func(tx *gdb.TX) error {
+		if err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
 			_, err = tx.Model(table).Data(g.Map{"id": 2, "name": "smith"}).Insert()
 			// Create a panic that can make this transaction rollback automatically.
 			panic("error")

.example/database/gdb/mysql/gdb_update_field.go

@@ -12,7 +12,7 @@ import (
 func main() {
 	db := g.DB()
 	table := "medicine_clinics_upload_yinchuan"
-	list, err := db.Table(table).All()
+	list, err := db.Model(table).All()
 	if err != nil && err != sql.ErrNoRows {
 		panic(err)
 	}

.example/database/gdb/mysql/gdb_update_union.go

@@ -9,7 +9,7 @@ import (
 func main() {
 	db := g.DB()
 	db.SetDebug(true)
-	result, err := db.Table("pw_passageway m,pw_template t").Data("t.status", 99).Where("m.templateId=t.id AND m.status = 0").Update()
+	result, err := db.Model("pw_passageway m,pw_template t").Data("t.status", 99).Where("m.templateId=t.id AND m.status = 0").Update()
 	if err != nil {
 		panic(err)
 	}

.example/database/gdb/mysql/gdb_value.go

@@ -6,7 +6,7 @@ import (
 )
 
 func main() {
-	one, err := g.DB().Table("carlist c").
+	one, err := g.Model("carlist c").
 		LeftJoin("cardetail d", "c.postid=d.carid").
 		Where("c.postid", "142039140032006").
 		Fields("c.*,d.*").One()

.example/database/gdb/mysql/gdb_with_insert.go

@@ -1,9 +1,11 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"github.com/gogf/gf/database/gdb"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gctx"
 	"github.com/gogf/gf/util/gmeta"
 )
 
@@ -30,13 +32,13 @@ func main() {
 	}
 
 	db := g.DB()
-	db.Transaction(func(tx *gdb.TX) error {
+	err := db.Transaction(gctx.New(), func(ctx context.Context, tx *gdb.TX) error {
 		for i := 1; i <= 5; i++ {
 			// User.
 			user := User{
 				Name: fmt.Sprintf(`name_%d`, i),
 			}
-			lastInsertId, err := db.Model(user).Data(user).OmitEmpty().InsertAndGetId()
+			lastInsertId, err := db.Ctx(ctx).Model(user).Data(user).OmitEmpty().InsertAndGetId()
 			if err != nil {
 				return err
 			}
@@ -45,7 +47,7 @@ func main() {
 				Uid:     int(lastInsertId),
 				Address: fmt.Sprintf(`address_%d`, lastInsertId),
 			}
-			_, err = db.Model(userDetail).Data(userDetail).OmitEmpty().Insert()
+			_, err = db.Ctx(ctx).Model(userDetail).Data(userDetail).OmitEmpty().Insert()
 			if err != nil {
 				return err
 			}
@@ -55,7 +57,7 @@ func main() {
 					Uid:   int(lastInsertId),
 					Score: j,
 				}
-				_, err = db.Model(userScore).Data(userScore).OmitEmpty().Insert()
+				_, err = db.Ctx(ctx).Model(userScore).Data(userScore).OmitEmpty().Insert()
 				if err != nil {
 					return err
 				}
@@ -63,4 +65,5 @@ func main() {
 		}
 		return nil
 	})
+	fmt.Println(err)
 }

.example/database/gdb/mysql/issue364.go

@@ -9,7 +9,7 @@ func test1() {
 	db := g.DB()
 	db.SetDebug(true)
 	time.Sleep(1 * time.Minute)
-	r, e := db.Table("test").Where("id", 10000).Count()
+	r, e := db.Model("test").Where("id", 10000).Count()
 	if e != nil {
 		panic(e)
 	}
@@ -19,7 +19,7 @@ func test1() {
 func test2() {
 	db := g.DB()
 	db.SetDebug(true)
-	dao := db.Table("test").Safe()
+	dao := db.Model("test").Safe()
 	time.Sleep(1 * time.Minute)
 	r, e := dao.Where("id", 10000).Count()
 	if e != nil {

database/gdb/gdb_core.go

@@ -205,20 +205,21 @@ func (c *Core) GetScan(pointer interface{}, sql string, args ...interface{}) err
 	t := reflect.TypeOf(pointer)
 	k := t.Kind()
 	if k != reflect.Ptr {
-		return fmt.Errorf("params should be type of pointer, but got: %v", k)
+		return gerror.NewCodef(gcode.CodeInvalidParameter, "params should be type of pointer, but got: %v", k)
 	}
 	k = t.Elem().Kind()
 	switch k {
 	case reflect.Array, reflect.Slice:
 		return c.db.GetCore().GetStructs(pointer, sql, args...)
+
 	case reflect.Struct:
 		return c.db.GetCore().GetStruct(pointer, sql, args...)
 	}
-	return fmt.Errorf("element type should be type of struct/slice, unsupported: %v", k)
+	return gerror.NewCodef(gcode.CodeInvalidParameter, "element type should be type of struct/slice, unsupported: %v", k)
 }
 
 // GetValue queries and returns the field value from database.
-// The sql should queries only one field from database, or else it returns only one
+// The sql should query only one field from database, or else it returns only one
 // field of the result.
 func (c *Core) GetValue(sql string, args ...interface{}) (Value, error) {
 	one, err := c.db.GetOne(sql, args...)
@@ -392,7 +393,7 @@ func (c *Core) DoInsert(ctx context.Context, link Link, table string, list List,
 		params         []interface{} // Values that will be committed to underlying database driver.
 		onDuplicateStr string        // onDuplicateStr is used in "ON DUPLICATE KEY UPDATE" statement.
 	)
-	// Handle the field names and place holders.
+	// Handle the field names and placeholders.
 	for k, _ := range list[0] {
 		keys = append(keys, k)
 	}
@@ -423,7 +424,7 @@ func (c *Core) DoInsert(ctx context.Context, link Link, table string, list List,
 			}
 		}
 		valueHolder = append(valueHolder, "("+gstr.Join(values, ",")+")")
-		// Batch package checks: It meets the batch number or it is the last element.
+		// Batch package checks: It meets the batch number, or it is the last element.
 		if len(valueHolder) == option.BatchCount || (i == listLength-1 && len(valueHolder) > 0) {
 			r, err := c.db.DoExec(ctx, link, fmt.Sprintf(
 				"%s INTO %s(%s) VALUES%s %s",

database/gdb/gdb_core_transaction.go

@@ -9,7 +9,8 @@ package gdb
 import (
 	"context"
 	"database/sql"
-	"fmt"
+	"github.com/gogf/gf/errors/gcode"
+	"github.com/gogf/gf/errors/gerror"
 	"reflect"
 
 	"github.com/gogf/gf/container/gtype"
@@ -117,8 +118,12 @@ func (c *Core) Transaction(ctx context.Context, f func(ctx context.Context, tx *
 	tx.ctx = WithTX(tx.ctx, tx)
 	defer func() {
 		if err == nil {
-			if e := recover(); e != nil {
-				err = fmt.Errorf("%v", e)
+			if exception := recover(); exception != nil {
+				if v, ok := exception.(error); ok {
+					err = v
+				} else {
+					err = gerror.NewCodef(gcode.CodeInternalError, "%v", v)
+				}
 			}
 		}
 		if err != nil {
@@ -307,8 +312,12 @@ func (tx *TX) Transaction(ctx context.Context, f func(ctx context.Context, tx *T
 	}
 	defer func() {
 		if err == nil {
-			if e := recover(); e != nil {
-				err = fmt.Errorf("%v", e)
+			if exception := recover(); exception != nil {
+				if v, ok := exception.(error); ok {
+					err = v
+				} else {
+					err = gerror.NewCodef(gcode.CodeInternalError, "%v", v)
+				}
 			}
 		}
 		if err != nil {
@@ -398,21 +407,21 @@ func (tx *TX) GetScan(pointer interface{}, sql string, args ...interface{}) erro
 	t := reflect.TypeOf(pointer)
 	k := t.Kind()
 	if k != reflect.Ptr {
-		return fmt.Errorf("params should be type of pointer, but got: %v", k)
+		return gerror.NewCodef(gcode.CodeInvalidParameter, "params should be type of pointer, but got: %v", k)
 	}
 	k = t.Elem().Kind()
 	switch k {
 	case reflect.Array, reflect.Slice:
 		return tx.GetStructs(pointer, sql, args...)
+
 	case reflect.Struct:
 		return tx.GetStruct(pointer, sql, args...)
-	default:
-		return fmt.Errorf("element type should be type of struct/slice, unsupported: %v", k)
 	}
+	return gerror.NewCodef(gcode.CodeInvalidParameter, "element type should be type of struct/slice, unsupported: %v", k)
 }
 
 // GetValue queries and returns the field value from database.
-// The sql should queries only one field from database, or else it returns only one
+// The sql should query only one field from database, or else it returns only one
 // field of the result.
 func (tx *TX) GetValue(sql string, args ...interface{}) (Value, error) {
 	one, err := tx.GetOne(sql, args...)

database/gdb/gdb_model.go

@@ -57,7 +57,7 @@ type Model struct {
 type ModelHandler func(m *Model) *Model
 
 // ChunkHandler is a function that is used in function Chunk, which handles given Result and error.
-// It returns true if it wants continue chunking, or else it returns false to stop chunking.
+// It returns true if it wants to continue chunking, or else it returns false to stop chunking.
 type ChunkHandler func(result Result, err error) bool
 
 // ModelWhereHolder is the holder for where condition preparing.

database/gdb/gdb_model_condition.go

@@ -62,7 +62,7 @@ func (m *Model) WherePri(where interface{}, args ...interface{}) *Model {
 }
 
 // Wheref builds condition string using fmt.Sprintf and arguments.
-// Note that if the number of `args` is more than the place holder in `format`,
+// Note that if the number of `args` is more than the placeholder in `format`,
 // the extra `args` will be used as the where condition arguments of the Model.
 func (m *Model) Wheref(format string, args ...interface{}) *Model {
 	var (

database/gdb/gdb_model_fields.go

@@ -9,6 +9,8 @@ package gdb
 import (
 	"fmt"
 	"github.com/gogf/gf/container/gset"
+	"github.com/gogf/gf/errors/gcode"
+	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/text/gstr"
 	"github.com/gogf/gf/util/gconv"
 	"github.com/gogf/gf/util/gutil"
@@ -247,7 +249,7 @@ func (m *Model) HasField(field string) (bool, error) {
 		return false, err
 	}
 	if len(tableFields) == 0 {
-		return false, fmt.Errorf(`empty table fields for table "%s"`, m.tables)
+		return false, gerror.NewCodef(gcode.CodeNotFound, `empty table fields for table "%s"`, m.tables)
 	}
 	fieldsArray := make([]string, len(tableFields))
 	for k, v := range tableFields {

encoding/gini/gini.go

@@ -79,24 +79,23 @@ func Decode(data []byte) (res map[string]interface{}, err error) {
 // Encode converts map to INI format.
 func Encode(data map[string]interface{}) (res []byte, err error) {
 	w := new(bytes.Buffer)
-
 	w.WriteString("; this ini file is produced by package gini\n")
 	for k, v := range data {
 		n, err := w.WriteString(fmt.Sprintf("[%s]\n", k))
 		if err != nil || n == 0 {
-			return nil, fmt.Errorf("write data failed. %v", err)
+			return nil, gerror.WrapCodef(gcode.CodeInternalError, err, "write data failed")
 		}
 		for kk, vv := range v.(map[string]interface{}) {
 			n, err := w.WriteString(fmt.Sprintf("%s=%s\n", kk, vv.(string)))
 			if err != nil || n == 0 {
-				return nil, fmt.Errorf("write data failed. %v", err)
+				return nil, gerror.WrapCodef(gcode.CodeInternalError, err, "write data failed")
 			}
 		}
 	}
 	res = make([]byte, w.Len())
 	n, err := w.Read(res)
 	if err != nil || n == 0 {
-		return nil, fmt.Errorf("write data failed. %v", err)
+		return nil, gerror.WrapCodef(gcode.CodeInternalError, err, "write data failed")
 	}
 
 	return res, nil

encoding/gjson/gjson.go

@@ -322,17 +322,28 @@ func (j *Json) getPointerByPatternWithViolenceCheck(pattern string) *interface{}
 	if !j.vc {
 		return j.getPointerByPatternWithoutViolenceCheck(pattern)
 	}
-	index := len(pattern)
-	start := 0
-	length := 0
-	pointer := j.p
+
+	// It returns nil if pattern is empty.
+	if pattern == "" {
+		return nil
+	}
+	// It returns all if pattern is ".".
+	if pattern == "." {
+		return j.p
+	}
+
+	var (
+		index   = len(pattern)
+		start   = 0
+		length  = 0
+		pointer = j.p
+	)
 	if index == 0 {
 		return pointer
 	}
 	for {
 		if r := j.checkPatternByPointer(pattern[start:index], pointer); r != nil {
-			length += index - start
-			if start > 0 {
+			if length += index - start; start > 0 {
 				length += 1
 			}
 			start = index + 1
@@ -361,6 +372,16 @@ func (j *Json) getPointerByPatternWithoutViolenceCheck(pattern string) *interfac
 	if j.vc {
 		return j.getPointerByPatternWithViolenceCheck(pattern)
 	}
+
+	// It returns nil if pattern is empty.
+	if pattern == "" {
+		return nil
+	}
+	// It returns all if pattern is ".".
+	if pattern == "." {
+		return j.p
+	}
+
 	pointer := j.p
 	if len(pattern) == 0 {
 		return pointer

encoding/gjson/gjson_api.go

@@ -8,6 +8,8 @@ package gjson
 
 import (
 	"fmt"
+	"github.com/gogf/gf/errors/gcode"
+	"github.com/gogf/gf/errors/gerror"
 	"time"
 
 	"github.com/gogf/gf/util/gutil"
@@ -59,11 +61,6 @@ func (j *Json) Get(pattern string, def ...interface{}) interface{} {
 		return nil
 	}
 
-	// It returns all if pattern is ".".
-	if pattern == "." {
-		return *j.p
-	}
-
 	var result *interface{}
 	if j.vc {
 		result = j.getPointerByPattern(pattern)
@@ -309,14 +306,20 @@ func (j *Json) Len(pattern string) int {
 // The target value by <pattern> should be type of slice.
 func (j *Json) Append(pattern string, value interface{}) error {
 	p := j.getPointerByPattern(pattern)
-	if p == nil {
+	if p == nil || *p == nil {
+		if pattern == "." {
+			return j.Set("0", value)
+		}
 		return j.Set(fmt.Sprintf("%s.0", pattern), value)
 	}
 	switch (*p).(type) {
 	case []interface{}:
+		if pattern == "." {
+			return j.Set(fmt.Sprintf("%d", len((*p).([]interface{}))), value)
+		}
 		return j.Set(fmt.Sprintf("%s.%d", pattern, len((*p).([]interface{}))), value)
 	}
-	return fmt.Errorf("invalid variable type of %s", pattern)
+	return gerror.NewCodef(gcode.CodeInvalidParameter, "invalid variable type of %s", pattern)
 }
 
 // GetStruct retrieves the value by specified <pattern> and converts it to specified object

encoding/gjson/gjson_api_new_load.go

@@ -8,7 +8,6 @@ package gjson
 
 import (
 	"bytes"
-	"fmt"
 	"github.com/gogf/gf/errors/gcode"
 	"github.com/gogf/gf/errors/gerror"
 	"reflect"
@@ -260,12 +259,14 @@ func doLoadContentWithOptions(dataType string, data []byte, options Options) (*J
 		if data, err = gtoml.ToJson(data); err != nil {
 			return nil, err
 		}
+
 	case "ini", ".ini":
 		if data, err = gini.ToJson(data); err != nil {
 			return nil, err
 		}
+
 	default:
-		err = gerror.NewCode(gcode.CodeInvalidParameter, "unsupported type for loading")
+		err = gerror.NewCodef(gcode.CodeInvalidParameter, `unsupported type "%s" for loading`, dataType)
 	}
 	if err != nil {
 		return nil, err
@@ -279,7 +280,7 @@ func doLoadContentWithOptions(dataType string, data []byte, options Options) (*J
 	}
 	switch result.(type) {
 	case string, []byte:
-		return nil, fmt.Errorf(`json decoding failed for content: %s`, string(data))
+		return nil, gerror.NewCodef(gcode.CodeInternalError, `json decoding failed for content: %s`, data)
 	}
 	return NewWithOptions(result, options), nil
 }

encoding/gjson/gjson_stdlib_json_util.go

@@ -35,7 +35,7 @@ func Decode(data interface{}) (interface{}, error) {
 	}
 }
 
-// Decode decodes json format <data> to specified golang variable <v>.
+// DecodeTo decodes json format <data> to specified golang variable <v>.
 // The parameter <data> can be either bytes or string type.
 // The parameter <v> should be a pointer type.
 func DecodeTo(data interface{}, v interface{}) error {

encoding/gjson/gjson_z_unit_basic_test.go

@@ -244,6 +244,22 @@ func Test_Append(t *testing.T) {
 	})
 }
 
+func Test_RawArray(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		j := gjson.New(nil)
+		t.AssertNil(j.Set("0", 1))
+		t.AssertNil(j.Set("1", 2))
+		t.Assert(j.MustToJsonString(), `[1,2]`)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		j := gjson.New(nil)
+		t.AssertNil(j.Append(".", 1))
+		t.AssertNil(j.Append(".", 2))
+		t.Assert(j.MustToJsonString(), `[1,2]`)
+	})
+}
+
 func TestJson_ToJson(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		p := gjson.New(1)

errors/gerror/gerror.go

@@ -6,8 +6,8 @@
 
 // Package gerror provides simple functions to manipulate errors.
 //
-// Very note that, this package is quite a base package, which should not import extra
-// packages except standard packages, to avoid cycle imports.
+// Very note that, this package is quite a basic package, which SHOULD NOT import extra
+// packages except standard packages and internal packages, to avoid cycle imports.
 package gerror
 
 import (

frame/g/g_object.go

@@ -89,7 +89,7 @@ func DB(name ...string) gdb.DB {
 // Table is alias of Model.
 // The database component is designed not only for
 // relational databases but also for NoSQL databases in the future. The name
-// "Table" is not proper for that purpose any more.
+// "Table" is not proper for that purpose anymore.
 // Deprecated, use Model instead.
 func Table(tableNameOrStruct ...interface{}) *gdb.Model {
 	return DB().Model(tableNameOrStruct...)
@@ -100,6 +100,11 @@ func Model(tableNameOrStruct ...interface{}) *gdb.Model {
 	return DB().Model(tableNameOrStruct...)
 }
 
+// ModelRaw creates and returns a model based on a raw sql not a table.
+func ModelRaw(rawSql string, args ...interface{}) *gdb.Model {
+	return DB().Raw(rawSql, args...)
+}
+
 // Redis returns an instance of redis client with specified configuration group name.
 func Redis(name ...string) *gredis.Redis {
 	return gins.Redis(name...)

net/ghttp/ghttp_func.go

@@ -36,11 +36,11 @@ func niceCallFunc(f func()) {
 					// Create a new error with stack info.
 					// Note that there's a skip pointing the start stacktrace
 					// of the real error point.
-					if err, ok := exception.(error); ok {
-						if gerror.Code(err) != gcode.CodeNil {
-							panic(err)
+					if v, ok := exception.(error); ok {
+						if gerror.Code(v) != gcode.CodeNil {
+							panic(v)
 						} else {
-							panic(gerror.WrapCodeSkip(gcode.CodeInternalError, 1, err, ""))
+							panic(gerror.WrapCodeSkip(gcode.CodeInternalError, 1, v, ""))
 						}
 					} else {
 						panic(gerror.NewCodeSkipf(gcode.CodeInternalError, 1, "%+v", exception))

net/ghttp/ghttp_request_param.go

@@ -70,7 +70,8 @@ func (r *Request) doParse(pointer interface{}, requestType int) error {
 		reflectKind1 = reflectVal1.Kind()
 	)
 	if reflectKind1 != reflect.Ptr {
-		return fmt.Errorf(
+		return gerror.NewCodef(
+			gcode.CodeInvalidParameter,
 			"parameter should be type of *struct/**struct/*[]struct/*[]*struct, but got: %v",
 			reflectKind1,
 		)

net/ghttp/ghttp_server_graceful.go

@@ -9,7 +9,6 @@ package ghttp
 import (
 	"context"
 	"crypto/tls"
-	"fmt"
 	"github.com/gogf/gf/errors/gcode"
 	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/os/gproc"
@@ -162,19 +161,21 @@ func (s *gracefulServer) doServe() error {
 
 // getNetListener retrieves and returns the wrapped net.Listener.
 func (s *gracefulServer) getNetListener() (net.Listener, error) {
-	var ln net.Listener
-	var err error
+	var (
+		ln  net.Listener
+		err error
+	)
 	if s.fd > 0 {
 		f := os.NewFile(s.fd, "")
 		ln, err = net.FileListener(f)
 		if err != nil {
-			err = fmt.Errorf("%d: net.FileListener error: %v", gproc.Pid(), err)
+			err = gerror.WrapCodef(gcode.CodeInternalError, err, "%d: net.FileListener failed", gproc.Pid())
 			return nil, err
 		}
 	} else {
 		ln, err = net.Listen("tcp", s.httpServer.Addr)
 		if err != nil {
-			err = fmt.Errorf("%d: net.Listen error: %v", gproc.Pid(), err)
+			err = gerror.WrapCodef(gcode.CodeInternalError, err, "%d: net.Listen failed", gproc.Pid())
 		}
 	}
 	return ln, err

net/ghttp/ghttp_server_handler.go

@@ -67,11 +67,11 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		} else {
 			if exception := recover(); exception != nil {
 				request.Response.WriteStatus(http.StatusInternalServerError)
-				if err, ok := exception.(error); ok {
-					if code := gerror.Code(err); code != gcode.CodeNil {
-						s.handleErrorLog(err, request)
+				if v, ok := exception.(error); ok {
+					if code := gerror.Code(v); code != gcode.CodeNil {
+						s.handleErrorLog(v, request)
 					} else {
-						s.handleErrorLog(gerror.WrapCodeSkip(gcode.CodeInternalError, 1, err, ""), request)
+						s.handleErrorLog(gerror.WrapCodeSkip(gcode.CodeInternalError, 1, v, ""), request)
 					}
 				} else {
 					s.handleErrorLog(gerror.NewCodeSkipf(gcode.CodeInternalError, 1, "%+v", exception), request)

net/gsmtp/gsmtp.go

@@ -14,6 +14,8 @@ package gsmtp
 import (
 	"encoding/base64"
 	"fmt"
+	"github.com/gogf/gf/errors/gcode"
+	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/util/gconv"
 	"net/smtp"
 	"strings"
@@ -53,13 +55,21 @@ func (s *SMTP) SendMail(from, tos, subject, body string, contentType ...string)
 		hp      = strings.Split(s.Address, ":")
 	)
 	if s.Address == "" || len(hp) > 2 {
-		return fmt.Errorf("server address is either empty or incorrect: %s", s.Address)
+		return gerror.NewCodef(
+			gcode.CodeInvalidParameter,
+			"server address is either empty or incorrect: %s",
+			s.Address,
+		)
 	} else if len(hp) == 1 {
 		server = s.Address
 		address = server + ":25"
 	} else if len(hp) == 2 {
 		if (hp[0] == "") || (hp[1] == "") {
-			return fmt.Errorf("server address is either empty or incorrect: %s", s.Address)
+			return gerror.NewCodef(
+				gcode.CodeInvalidParameter,
+				"server address is either empty or incorrect: %s",
+				s.Address,
+			)
 		}
 		server = hp[0]
 		address = s.Address
@@ -75,11 +85,11 @@ func (s *SMTP) SendMail(from, tos, subject, body string, contentType ...string)
 		}
 	}
 	if len(tosArr) == 0 {
-		return fmt.Errorf("tos if invalid: %s", tos)
+		return gerror.NewCodef(gcode.CodeInvalidParameter, `invalid parameter "tos": %s`, tos)
 	}
 
 	if !strings.Contains(from, "@") {
-		return fmt.Errorf("from is invalid: %s", from)
+		return gerror.NewCodef(gcode.CodeInvalidParameter, `invalid parameter "from": %s`, from)
 	}
 
 	header := map[string]string{

net/gtcp/gtcp_conn_pkg.go

@@ -8,7 +8,8 @@ package gtcp
 
 import (
 	"encoding/binary"
-	"fmt"
+	"github.com/gogf/gf/errors/gcode"
+	"github.com/gogf/gf/errors/gerror"
 	"time"
 )
 
@@ -46,7 +47,8 @@ func (c *Conn) SendPkg(data []byte, option ...PkgOption) error {
 	}
 	length := len(data)
 	if length > pkgOption.MaxDataSize {
-		return fmt.Errorf(
+		return gerror.NewCodef(
+			gcode.CodeInvalidParameter,
 			`data too long, data size %d exceeds allowed max data size %d`,
 			length, pkgOption.MaxDataSize,
 		)
@@ -116,7 +118,7 @@ func (c *Conn) RecvPkg(option ...PkgOption) (result []byte, err error) {
 	// It here validates the size of the package.
 	// It clears the buffer and returns error immediately if it validates failed.
 	if length < 0 || length > pkgOption.MaxDataSize {
-		return nil, fmt.Errorf(`invalid package size %d`, length)
+		return nil, gerror.NewCodef(gcode.CodeInvalidParameter, `invalid package size %d`, length)
 	}
 	// Empty package.
 	if length == 0 {
@@ -147,7 +149,8 @@ func getPkgOption(option ...PkgOption) (*PkgOption, error) {
 		pkgOption.HeaderSize = pkgHeaderSizeDefault
 	}
 	if pkgOption.HeaderSize > pkgHeaderSizeMax {
-		return nil, fmt.Errorf(
+		return nil, gerror.NewCodef(
+			gcode.CodeInvalidParameter,
 			`package header size %d definition exceeds max header size %d`,
 			pkgOption.HeaderSize, pkgHeaderSizeMax,
 		)
@@ -166,7 +169,8 @@ func getPkgOption(option ...PkgOption) (*PkgOption, error) {
 		}
 	}
 	if pkgOption.MaxDataSize > 0x7FFFFFFF {
-		return nil, fmt.Errorf(
+		return nil, gerror.NewCodef(
+			gcode.CodeInvalidParameter,
 			`package data size %d definition exceeds allowed max data size %d`,
 			pkgOption.MaxDataSize, 0x7FFFFFFF,
 		)

os/gcfg/gcfg_config.go

@@ -151,7 +151,11 @@ func (c *Config) SetPath(path string) error {
 	}
 	// Should be a directory.
 	if !isDir {
-		err := fmt.Errorf(`[gcfg] SetPath failed: path "%s" should be directory type`, path)
+		err := gerror.NewCodef(
+			gcode.CodeInvalidParameter,
+			`[gcfg] SetPath failed: path "%s" should be directory type`,
+			path,
+		)
 		if errorPrint() {
 			glog.Error(err)
 		}

os/gfile/gfile_copy.go

@@ -7,7 +7,6 @@
 package gfile
 
 import (
-	"fmt"
 	"github.com/gogf/gf/errors/gcode"
 	"github.com/gogf/gf/errors/gerror"
 	"io"
@@ -104,7 +103,7 @@ func CopyDir(src string, dst string) (err error) {
 		return err
 	}
 	if !si.IsDir() {
-		return fmt.Errorf("source is not a directory")
+		return gerror.NewCode(gcode.CodeInvalidParameter, "source is not a directory")
 	}
 	if !Exists(dst) {
 		err = os.MkdirAll(dst, DefaultPermCopy)

os/grpool/grpool.go

@@ -99,8 +99,8 @@ func (p *Pool) AddWithRecover(userFunc func(), recoverFunc ...func(err error)) e
 		defer func() {
 			if exception := recover(); exception != nil {
 				if len(recoverFunc) > 0 && recoverFunc[0] != nil {
-					if err, ok := exception.(error); ok {
-						recoverFunc[0](err)
+					if v, ok := exception.(error); ok {
+						recoverFunc[0](v)
 					} else {
 						recoverFunc[0](gerror.NewCodef(gcode.CodeInternalError, `%v`, exception))
 					}

os/gspath/gspath_cache.go

@@ -75,8 +75,6 @@ func (sp *SPath) addToCache(filePath, rootPath string) {
 			for _, path := range files {
 				sp.cache.SetIfNotExist(sp.nameFromPath(path, rootPath), sp.makeCacheValue(path, gfile.IsDir(path)))
 			}
-		} else {
-			//fmt.Errorf(err.Error())
 		}
 	}
 }

text/gstr/gstr_parse.go

@@ -7,7 +7,8 @@
 package gstr
 
 import (
-	"fmt"
+	"github.com/gogf/gf/errors/gcode"
+	"github.com/gogf/gf/errors/gerror"
 	"net/url"
 	"strings"
 )
@@ -116,7 +117,11 @@ func build(result map[string]interface{}, keys []string, value interface{}) erro
 		}
 		children, ok := val.([]interface{})
 		if !ok {
-			return fmt.Errorf("expected type '[]interface{}' for key '%s', but got '%T'", key, val)
+			return gerror.NewCodef(
+				gcode.CodeInvalidParameter,
+				"expected type '[]interface{}' for key '%s', but got '%T'",
+				key, val,
+			)
 		}
 		result[key] = append(children, value)
 		return nil
@@ -131,7 +136,11 @@ func build(result map[string]interface{}, keys []string, value interface{}) erro
 		}
 		children, ok := val.([]interface{})
 		if !ok {
-			return fmt.Errorf("expected type '[]interface{}' for key '%s', but got '%T'", key, val)
+			return gerror.NewCodef(
+				gcode.CodeInvalidParameter,
+				"expected type '[]interface{}' for key '%s', but got '%T'",
+				key, val,
+			)
 		}
 		if l := len(children); l > 0 {
 			if child, ok := children[l-1].(map[string]interface{}); ok {
@@ -155,7 +164,11 @@ func build(result map[string]interface{}, keys []string, value interface{}) erro
 	}
 	children, ok := val.(map[string]interface{})
 	if !ok {
-		return fmt.Errorf("expected type 'map[string]interface{}' for key '%s', but got '%T'", key, val)
+		return gerror.NewCodef(
+			gcode.CodeInvalidParameter,
+			"expected type 'map[string]interface{}' for key '%s', but got '%T'",
+			key, val,
+		)
 	}
 	if err := build(children, keys[1:], value); err != nil {
 		return err

util/gutil/gutil.go

@@ -9,6 +9,8 @@ package gutil
 
 import (
 	"fmt"
+	"github.com/gogf/gf/errors/gcode"
+	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/internal/empty"
 	"github.com/gogf/gf/util/gconv"
 	"reflect"
@@ -23,8 +25,12 @@ func Throw(exception interface{}) {
 // It returns error if any exception occurs, or else it returns nil.
 func Try(try func()) (err error) {
 	defer func() {
-		if e := recover(); e != nil {
-			err = fmt.Errorf(`%v`, e)
+		if exception := recover(); exception != nil {
+			if v, ok := exception.(error); ok {
+				err = v
+			} else {
+				err = gerror.NewCodef(gcode.CodeInternalError, `%v`, v)
+			}
 		}
 	}()
 	try()
@@ -36,8 +42,8 @@ func Try(try func()) (err error) {
 func TryCatch(try func(), catch ...func(exception error)) {
 	defer func() {
 		if exception := recover(); exception != nil && len(catch) > 0 {
-			if err, ok := exception.(error); ok {
-				catch[0](err)
+			if v, ok := exception.(error); ok {
+				catch[0](v)
 			} else {
 				catch[0](fmt.Errorf(`%v`, exception))
 			}