fix issue

Update ghttp_server_config.go

.example/database/gdb/mssql/gdb_sqlserver.go

@@ -512,16 +512,6 @@ func mapToStruct() {
 	}
 }
 
-// getQueriedSqls
-func getQueriedSqls() {
-	for k, v := range db.GetQueriedSqls() {
-		fmt.Println(k, ":")
-		fmt.Println("Sql  :", v.Sql)
-		fmt.Println("Args :", v.Args)
-		fmt.Println("Error:", v.Error)
-	}
-}
-
 func main() {
 
 	db.PingMaster()

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

@@ -1,10 +1,15 @@
 
-# MySQL数据库配置
+# MySQL.
 [database]
 	debug   = true
     link    = "mysql:root:12345678@tcp(127.0.0.1:3306)/test?parseTime=true&loc=Local"
     MaxOpen = 100
 
+# Redis.
+[redis]
+    default = "127.0.0.1:6379,0"
+    cache   = "127.0.0.1:6379,1"
+
 #[database]
 #   [[database.default]]
 #        type = "mysql"

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

@@ -3,6 +3,7 @@ package main
 import (
 	"github.com/gogf/gf/database/gdb"
 	"github.com/gogf/gf/util/gutil"
+	"time"
 )
 
 func main() {
@@ -10,7 +11,7 @@ func main() {
 		Host:    "127.0.0.1",
 		Port:    "3306",
 		User:    "root",
-		Pass:    "123456",
+		Pass:    "12345678",
 		Name:    "test",
 		Type:    "mysql",
 		Role:    "master",
@@ -20,19 +21,20 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
+	//db.GetCache().SetAdapter(adapter.NewRedis(g.Redis()))
 	// 开启调试模式，以便于记录所有执行的SQL
 	db.SetDebug(true)
 
 	// 执行2次查询并将查询结果缓存3秒，并可执行缓存名称(可选)
-	for i := 0; i < 2; i++ {
-		r, _ := db.Table("user").Cache(3, "vip-user").Where("uid=?", 1).One()
-		gutil.Dump(r.ToMap())
+	for i := 0; i < 3; i++ {
+		r, _ := db.Table("user").Cache(3000*time.Second).Where("id=?", 1).One()
+		gutil.Dump(r.Map())
 	}
 
 	// 执行更新操作，并清理指定名称的查询缓存
-	db.Table("user").Cache(-1, "vip-user").Data(gdb.Map{"name": "smith"}).Where("uid=?", 1).Update()
+	//db.Table("user").Cache(-1, "vip-user").Data(gdb.Map{"name": "smith"}).Where("id=?", 1).Update()
 
 	// 再次执行查询，启用查询缓存特性
-	r, _ := db.Table("user").Cache(3, "vip-user").Where("uid=?", 1).One()
-	gutil.Dump(r.ToMap())
+	//r, _ := db.Table("user").Cache(300000*time.Second, "vip-user").Where("id=?", 1).One()
+	//gutil.Dump(r.Map())
 }

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

@@ -8,9 +8,6 @@ import (
 
 func main() {
 	db := g.DB()
-	db.SetMaxIdleConnCount(10)
-	db.SetMaxOpenConnCount(10)
-	db.SetMaxConnLifetime(time.Minute)
 
 	// 开启调试模式，以便于记录所有执行的SQL
 	db.SetDebug(true)
@@ -19,7 +16,7 @@ func main() {
 		for i := 0; i < 10; i++ {
 			go db.Table("user").All()
 		}
-		time.Sleep(time.Second)
+		time.Sleep(time.Millisecond * 100)
 	}
 
 }

.example/database/gdb/oracle/gdb.go

@@ -513,16 +513,6 @@ func mapToStruct() {
 	}
 }
 
-// getQueriedSqls
-func getQueriedSqls() {
-	for k, v := range db.GetQueriedSqls() {
-		fmt.Println(k, ":")
-		fmt.Println("Sql  :", v.Sql)
-		fmt.Println("Args :", v.Args)
-		fmt.Println("Error:", v.Error)
-	}
-}
-
 func main() {
 
 	db.PingMaster()

.example/i18n/gi18n/gi18n.go

@@ -2,25 +2,14 @@ package main
 
 import (
 	"fmt"
-
-	"github.com/gogf/gf/i18n/gi18n"
+	"github.com/gogf/gf/frame/g"
 )
 
 func main() {
-	t := gi18n.New()
-	t.SetPath("/Users/john/Workspace/Go/GOPATH/src/github.com/gogf/gf/.example/i18n/gi18n/i18n")
-	t.SetLanguage("en")
-	fmt.Println(t.Translate(`hello`))
-	fmt.Println(t.Translate(`{#hello}{#world}!`))
-
-	t.SetLanguage("ja")
-	fmt.Println(t.Translate(`hello`))
-	fmt.Println(t.Translate(`{#hello}{#world}!`))
-
-	t.SetLanguage("ru")
-	fmt.Println(t.Translate(`hello`))
-	fmt.Println(t.Translate(`{#hello}{#world}!`))
-
-	fmt.Println(t.Translate(`hello`, "zh-CN"))
-	fmt.Println(t.Translate(`{#hello}{#world}!`, "zh-CN"))
+	var (
+		orderId     = 865271654
+		orderAmount = 99.8
+	)
+	fmt.Println(g.I18n().Tfl(`en`, `{#OrderPaid}`, orderId, orderAmount))
+	fmt.Println(g.I18n().Tfl(`zh-CN`, `{#OrderPaid}`, orderId, orderAmount))
 }

.example/i18n/gi18n/i18n/en.toml

@@ -1,3 +1 @@
-
-hello = "Hello"
-world = "World"
+OrderPaid = "You have successfully complete order #%d payment, paid amount: ￥%0.2f."

.example/i18n/gi18n/i18n/zh-CN.toml

@@ -1,2 +1 @@
-hello = "你好"
-world = "世界"
+OrderPaid = "您已成功完成订单号 #%d 支付，支付金额￥%.2f。"

.example/net/ghttp/server/hello.go

@@ -3,15 +3,21 @@ package main
 import (
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/net/ghttp"
-	"github.com/gogf/gf/os/glog"
 )
 
+type GetById struct {
+	Id *g.Var `p:"id" v:"required|integer#id不能为空|id必须为整数"`
+}
+
 func main() {
 	s := g.Server()
 	s.SetIndexFolder(true)
 	s.BindHandler("/", func(r *ghttp.Request) {
-		glog.Println(r.Header)
-		r.Response.Write("hello world")
+		var idInfo *GetById
+		if err := r.Parse(&idInfo); err != nil {
+			r.Response.Write(err)
+		}
+		r.Response.Write("ok")
 	})
 	s.SetPort(8999)
 	s.Run()

.example/net/ghttp/server/pprof.go

@@ -1,12 +1,13 @@
 package main
 
 import (
+	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/net/ghttp"
 )
 
 func main() {
-	s := ghttp.GetServer()
-	s.EnablePProf()
+	s := g.Server()
+	s.Domain("localhost").EnablePProf()
 	s.BindHandler("/", func(r *ghttp.Request) {
 		r.Response.Writeln("哈喽世界！")
 	})

.example/net/ghttp/server/reload/admin.go

@@ -6,6 +6,7 @@ import (
 
 func main() {
 	s := g.Server()
+	s.SetConfigWithMap(g.Map{"Graceful": true})
 	s.EnableAdmin()
 	s.SetPort(8199)
 	s.Run()

.example/os/gfcache/gfcache.go

@@ -1,29 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/gogf/gf/os/gfcache"
-	"github.com/gogf/gf/os/gfile"
-)
-
-func main() {
-	s := 0
-	r := ""
-	path := gfile.TempDir() + gfile.Separator + "temp"
-	gfile.PutContents(path, "hello")
-
-	s = gfcache.GetSize()
-	r = gfcache.GetContents(path)
-	fmt.Println(s, r)
-
-	gfile.PutContentsAppend(path, " john")
-
-	// 等待1秒以便gfsnotify回调能处理完成
-	time.Sleep(time.Second)
-
-	s = gfcache.GetSize()
-	r = gfcache.GetContents(path)
-	fmt.Println(s, r)
-}

.example/os/gview/layout/layout1/main.go

@@ -2,19 +2,18 @@ package main
 
 import (
 	"github.com/gogf/gf/frame/g"
-	"github.com/gogf/gf/frame/gmvc"
+	"github.com/gogf/gf/net/ghttp"
 )
 
-type Controller struct {
-	gmvc.Controller
-}
-
-func (c *Controller) Test() {
-	c.View.Display("layout.html")
-}
 func main() {
 	s := g.Server()
-	s.BindControllerMethod("/", new(Controller), "Test")
+	s.BindHandler("/", func(r *ghttp.Request) {
+		r.Response.WriteTpl("layout.html", g.Map{
+			"header":    "This is header",
+			"container": "This is container",
+			"footer":    "This is footer",
+		})
+	})
 	s.SetPort(8199)
 	s.Run()
 }

.example/os/gview/layout/layout1/template/container.html

@@ -1,3 +1,3 @@
 {{define "container"}}
-<h1>CONTAINER</h1>
+<h1>{{.container}}</h1>
 {{end}}

.example/os/gview/layout/layout1/template/footer.html

@@ -1,3 +1,3 @@
 {{define "footer"}}
-<h1>FOOTER</h1>
+<h1>{{.footer}}</h1>
 {{end}}

.example/os/gview/layout/layout1/template/header.html

@@ -1,3 +1,3 @@
 {{define "header"}}
-    <h1>HEADER</h1>
+    <h1>{{.header}}</h1>
 {{end}}

.example/os/gview/layout/layout1/template/layout.html

@@ -2,14 +2,14 @@
 <html>
 <head>
     <title>GoFrame Layout</title>
-    {{template "header"}}
+    {{template "header" .}}
 </head>
 <body>
     <div class="container">
-    {{template "container"}}
+    {{template "container" .}}
     </div>
     <div class="footer">
-    {{template "footer"}}
+    {{template "footer" .}}
     </div>
 </body>
 </html>

.example/os/gview/layout/layout2/main.go

@@ -9,11 +9,13 @@ func main() {
 	s := g.Server()
 	s.BindHandler("/main1", func(r *ghttp.Request) {
 		r.Response.WriteTpl("layout.html", g.Map{
+			"name":    "smith",
 			"mainTpl": "main/main1.html",
 		})
 	})
 	s.BindHandler("/main2", func(r *ghttp.Request) {
 		r.Response.WriteTpl("layout.html", g.Map{
+			"name":    "john",
 			"mainTpl": "main/main2.html",
 		})
 	})

.example/util/gutil/try_catch.go

@@ -11,7 +11,7 @@ func main() {
 		fmt.Println(1)
 		gutil.Throw("error")
 		fmt.Println(2)
-	}, func(err interface{}) {
+	}, func(err error) {
 		fmt.Println(err)
 	})
 }

.travis.yml

@@ -5,6 +5,7 @@ go:
   - "1.12.x"
   - "1.13.x"
   - "1.14.x"
+  - "1.15.x"
 
 branches:
   only:

DONATOR.MD

@@ -1,12 +1,17 @@
 # Donators
 
-We currently accept donation by [Alipay](https://goframe.org/images/donate.png) / [Gitee](https://gitee.com/johng/gf), 
-please note your github/gitee account in your payment bill.
+We currently accept donation by [Wechat](https://goframe.org/images/donate.png) / [Alipay](https://goframe.org/images/donate.png) / [Gitee](https://gitee.com/johng/gf), 
+please note your github/gitee account in your payment bill. All the donations will be used only for `GoFrame` project development and its community construction. 
+
+> If you cannot see the donation image, please click [here](https://goframe.org/images/donate.png).
+
+<img src="https://goframe.org/images/donate.png?20200718"/>
+
 
 | Name | Channel | Amount | Comment 
 |---|---|--- | ---
 |[hailaz](https://gitee.com/hailaz)|gitee|￥20.00 | 
-|[ireadx](https://github.com/ireadx)|alipay|￥301.00 |
+|[ireadx](https://github.com/ireadx)|alipay|￥501.00 |
 |[mg91](https://gitee.com/mg91)|gitee|￥10.00 |
 |[pibigstar](https://github.com/pibigstar)|alipay|￥10.00 |
 |[tiangenglan](https://gitee.com/tiangenglan)|gitee|￥30.00 |
@@ -92,8 +97,30 @@ please note your github/gitee account in your payment bill.
 |六七     ·|wechat|￥88.88| gf越来越好
 |Tom|wechat|￥500.00| 一点心意  希望GF越来越好
 |Chao|wechat|￥166.00| 
+|汤sir|wechat|￥10.00| 强哥，喝杯咖啡☕️
+|秋叶、|wechat|￥66.66| GF带我一起玩
+||wechat|￥20.00| 
+|程凤明|wechat|￥18.80|
+|Glowworm|wechat|￥8.88| 感谢大佬
+|徒行|wechat|￥10.00| 目前项目在转用这个框架，鼓励一下大佬吧👍👍👍
+|产品设计.软件开发|wechat|￥10.00| 祝愿走向更成功！
+|[charlieccGuo](https://github.com/charlieccGuo)|wechat|￥10.00| 
+|yiran|wechat|￥20.00| 赏给大佬喝茶🍵
+|长夏朔酒|wechat|￥20.00| 请大佬喝茶
+|💥聪จุ๊บ 🇨🇳|wechat|￥66.66| 请大佬喝茶
+|Even_|wechat|￥10.00| 日照市民发来贺电！
+|智慧人生|wechat|￥50.00| 智慧人生
+|一滴水|wechat|￥10.00| goframe 越来越强大
+|[wenzi1](https://github.com/wenzi1)|alipay|￥100.00| 
+|[hyuant](https://github.com/hyuant)|alipay|￥66.66| 
+|*庆|alipay|￥9.99| 支持一下，gf越来越好
+|**君|alipay|￥10.00| 加油
+|向回走的闹钟|wechat|￥20.00| 越来越好
+|金毛|wechat|￥100.00| 
+|莫失莫忘|wechat|￥100.00| 
+|**航|alipay|￥20.00| 
+
 
 
 
-<img src="https://goframe.org/images/donate.jpeg"/>
 

README.MD

@@ -115,9 +115,18 @@ The concurrency starts from `100` to `10000`.
 
 `GF` is licensed under the [MIT License](LICENSE), 100% free and open-source, forever.
 
-# Known Users
+# Part Of Users
 
-Logos are not authorized to be shown due to trademark copyrights.
+- [Tencent](https://www.tencent.com/)
+- [ZTE](https://www.zte.com.cn/china/)
+- [Ant Financial Services](https://www.antfin.com/)
+- [MedLinker](https://www.medlinker.com/)
+- [KuCoin](https://www.kucoin.io/)
+- [LeYouJia](https://www.leyoujia.com/)
+- [IGG](https://igg.com)
+- [XiMaLaYa](https://www.ximalaya.com)
+
+> We list part of the users here, if your company or products are using `GoFrame`, please let us know [here](https://github.com/gogf/gf/issues/168).
 
 
 # Contributors

README_ZH.MD

@@ -137,7 +137,16 @@ ab -t 10 -c 100 http://127.0.0.1:3000/json
 
 # 用户
 
-由于商标版权缘故，未经厂商商务部授权允许无法用于宣传展示。
+- [腾讯科技](https://www.tencent.com/)
+- [中兴科技](https://www.zte.com.cn/china/)
+- [蚂蚁金服](https://www.antfin.com/)
+- [医联科技](https://www.medlinker.com/)
+- [库币科技](https://www.kucoin.io/)
+- [乐有家](https://www.leyoujia.com/)
+- [IGG](https://igg.com)
+- [喜马拉雅](https://www.ximalaya.com)
+
+> 在这里只列举了部分知名的用户，如果您的企业或者产品正在使用`GoFrame`，欢迎到 [这里](https://github.com/gogf/gf/issues/168) 留言。
 
 # 贡献
 

container/gmap/gmap_hash_any_any_map.go

@@ -457,6 +457,12 @@ func (m *AnyAnyMap) Merge(other *AnyAnyMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *AnyAnyMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *AnyAnyMap) MarshalJSON() ([]byte, error) {
 	return json.Marshal(gconv.Map(m.Map()))

container/gmap/gmap_hash_int_any_map.go

@@ -455,6 +455,12 @@ func (m *IntAnyMap) Merge(other *IntAnyMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *IntAnyMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *IntAnyMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()

container/gmap/gmap_hash_int_int_map.go

@@ -426,6 +426,12 @@ func (m *IntIntMap) Merge(other *IntIntMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *IntIntMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *IntIntMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()

container/gmap/gmap_hash_int_str_map.go

@@ -426,6 +426,12 @@ func (m *IntStrMap) Merge(other *IntStrMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *IntStrMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *IntStrMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()

container/gmap/gmap_hash_str_any_map.go

@@ -451,6 +451,12 @@ func (m *StrAnyMap) Merge(other *StrAnyMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *StrAnyMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *StrAnyMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()

container/gmap/gmap_hash_str_int_map.go

@@ -429,6 +429,12 @@ func (m *StrIntMap) Merge(other *StrIntMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *StrIntMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *StrIntMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()

container/gmap/gmap_hash_str_str_map.go

@@ -429,6 +429,12 @@ func (m *StrStrMap) Merge(other *StrStrMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *StrStrMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *StrStrMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()

container/gmap/gmap_list_map.go

@@ -510,6 +510,12 @@ func (m *ListMap) Merge(other *ListMap) {
 	})
 }
 
+// String returns the map as a string.
+func (m *ListMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *ListMap) MarshalJSON() ([]byte, error) {
 	return json.Marshal(gconv.Map(m.Map()))

container/gtree/gtree.go

@@ -5,4 +5,7 @@
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package gtree provides concurrent-safe/unsafe tree containers.
+//
+// Some implements are from: https://github.com/emirpasic/gods
+// Thanks!
 package gtree

database/gdb/gdb.go

@@ -11,9 +11,11 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
+	"github.com/gogf/gf/internal/cmdenv"
+	"time"
+
 	"github.com/gogf/gf/container/gvar"
 	"github.com/gogf/gf/internal/intlog"
-	"time"
 
 	"github.com/gogf/gf/os/glog"
 
@@ -126,6 +128,7 @@ type DB interface {
 	GetDryRun() bool
 	SetLogger(logger *glog.Logger)
 	GetLogger() *glog.Logger
+	GetConfig() *ConfigNode
 	SetMaxIdleConnCount(n int)
 	SetMaxOpenConnCount(n int)
 	SetMaxConnLifetime(d time.Duration)
@@ -142,6 +145,7 @@ type DB interface {
 	QuotePrefixTableName(table string) string
 	Tables(schema ...string) (tables []string, err error)
 	TableFields(table string, schema ...string) (map[string]*TableField, error)
+	HasTable(name string) (bool, error)
 
 	// HandleSqlBeforeCommit is a hook function, which deals with the sql string before
 	// it's committed to underlying driver. The parameter <link> specifies the current
@@ -153,8 +157,8 @@ type DB interface {
 	// Internal methods.
 	// ===========================================================================
 
-	filterFields(schema, table string, data map[string]interface{}) map[string]interface{}
-	convertValue(fieldValue []byte, fieldType string) interface{}
+	mappingAndFilterData(schema, table string, data map[string]interface{}, filter bool) (map[string]interface{}, error)
+	convertValue(fieldValue interface{}, fieldType string) interface{}
 	rowsToResult(rows *sql.Rows) (Result, error)
 }
 
@@ -163,11 +167,12 @@ type Core struct {
 	DB               DB            // DB interface object.
 	group            string        // Configuration group name.
 	debug            *gtype.Bool   // Enable debug mode for the database.
-	cache            *gcache.Cache // Cache manager.
+	cache            *gcache.Cache // Cache manager, SQL result cache only.
 	schema           *gtype.String // Custom schema for this object.
 	dryrun           *gtype.Bool   // Dry run.
 	prefix           string        // Table prefix.
 	logger           *glog.Logger  // Logger.
+	config           *ConfigNode   // Current config node.
 	maxIdleConnCount int           // Max idle connection count.
 	maxOpenConnCount int           // Max open connection count.
 	maxConnLifetime  time.Duration // Max TTL for a connection.
@@ -187,6 +192,7 @@ type Sql struct {
 	Error  error         // Execution result.
 	Start  int64         // Start execution timestamp in milliseconds.
 	End    int64         // End execution timestamp in milliseconds.
+	Group  string        // Group is the group name of the configuration that the sql is executed from.
 }
 
 // TableField is the struct for table field.
@@ -259,8 +265,17 @@ var (
 	// regularFieldNameRegPattern is the regular expression pattern for a string
 	// which is a regular field name of table.
 	regularFieldNameRegPattern = `^[\w\.\-]+$`
+
+	// allDryRun sets dry-run feature for all database connections.
+	// It is commonly used for command options for convenience.
+	allDryRun = false
 )
 
+func init() {
+	// allDryRun is initialized from environment or command options.
+	allDryRun = cmdenv.Get("gf.gdb.dryrun", false).Bool()
+}
+
 // Register registers custom database driver to gdb.
 func Register(name string, driver Driver) error {
 	driverMap[name] = driver
@@ -270,10 +285,10 @@ func Register(name string, driver Driver) error {
 // New creates and returns an ORM object with global configurations.
 // The parameter <name> specifies the configuration group name,
 // which is DEFAULT_GROUP_NAME in default.
-func New(name ...string) (db DB, err error) {
-	group := configs.group
-	if len(name) > 0 && name[0] != "" {
-		group = name[0]
+func New(group ...string) (db DB, err error) {
+	groupName := configs.group
+	if len(group) > 0 && group[0] != "" {
+		groupName = group[0]
 	}
 	configs.RLock()
 	defer configs.RUnlock()
@@ -281,16 +296,17 @@ func New(name ...string) (db DB, err error) {
 	if len(configs.config) < 1 {
 		return nil, errors.New("empty database configuration")
 	}
-	if _, ok := configs.config[group]; ok {
-		if node, err := getConfigNodeByGroup(group, true); err == nil {
+	if _, ok := configs.config[groupName]; ok {
+		if node, err := getConfigNodeByGroup(groupName, true); err == nil {
 			c := &Core{
-				group:            group,
+				group:            groupName,
 				debug:            gtype.NewBool(),
 				cache:            gcache.New(),
 				schema:           gtype.NewString(),
 				dryrun:           gtype.NewBool(),
 				logger:           glog.New(),
 				prefix:           node.Prefix,
+				config:           node,
 				maxIdleConnCount: gDEFAULT_CONN_MAX_IDLE_COUNT,
 				maxConnLifetime:  gDEFAULT_CONN_MAX_LIFE_TIME, // Default max connection life time if user does not configure.
 			}
@@ -307,7 +323,7 @@ func New(name ...string) (db DB, err error) {
 			return nil, err
 		}
 	} else {
-		return nil, errors.New(fmt.Sprintf(`database configuration node "%s" is not found`, group))
+		return nil, errors.New(fmt.Sprintf(`database configuration node "%s" is not found`, groupName))
 	}
 }
 
@@ -425,11 +441,11 @@ func (c *Core) getSqlDb(master bool, schema ...string) (sqlDb *sql.DB, err error
 		node = &n
 	}
 	// Cache the underlying connection pool object by node.
-	v := c.cache.GetOrSetFuncLock(node.String(), func() interface{} {
+	v, _ := gcache.GetOrSetFuncLock(node.String(), func() (interface{}, error) {
 		sqlDb, err = c.DB.Open(node)
 		if err != nil {
 			intlog.Printf("DB open failed: %v, %+v", err, node)
-			return nil
+			return nil, err
 		}
 		if c.maxIdleConnCount > 0 {
 			sqlDb.SetMaxIdleConns(c.maxIdleConnCount)
@@ -448,7 +464,7 @@ func (c *Core) getSqlDb(master bool, schema ...string) (sqlDb *sql.DB, err error
 		} else if node.MaxConnLifetime > 0 {
 			sqlDb.SetConnMaxLifetime(node.MaxConnLifetime * time.Second)
 		}
-		return sqlDb
+		return sqlDb, nil
 	}, 0)
 	if v != nil && sqlDb == nil {
 		sqlDb = v.(*sql.DB)

database/gdb/gdb_core.go

@@ -11,10 +11,12 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
-	"github.com/gogf/gf/internal/utils"
+	"github.com/gogf/gf/text/gstr"
 	"reflect"
 	"strings"
 
+	"github.com/gogf/gf/internal/utils"
+
 	"github.com/gogf/gf/container/gvar"
 	"github.com/gogf/gf/os/gtime"
 	"github.com/gogf/gf/text/gregex"
@@ -59,6 +61,7 @@ func (c *Core) DoQuery(link Link, sql string, args ...interface{}) (rows *sql.Ro
 			Error:  err,
 			Start:  mTime1,
 			End:    mTime2,
+			Group:  c.DB.GetGroup(),
 		}
 		c.writeSqlToLogger(s)
 	} else {
@@ -102,6 +105,7 @@ func (c *Core) DoExec(link Link, sql string, args ...interface{}) (result sql.Re
 			Error:  err,
 			Start:  mTime1,
 			End:    mTime2,
+			Group:  c.DB.GetGroup(),
 		}
 		c.writeSqlToLogger(s)
 	} else {
@@ -307,6 +311,11 @@ func (c *Core) Transaction(f func(tx *TX) error) (err error) {
 		return err
 	}
 	defer func() {
+		if err == nil {
+			if e := recover(); e != nil {
+				err = fmt.Errorf("%v", e)
+			}
+		}
 		if err != nil {
 			if e := tx.Rollback(); e != nil {
 				err = e
@@ -331,7 +340,10 @@ func (c *Core) Transaction(f func(tx *TX) error) (err error) {
 //
 // The parameter <batch> specifies the batch operation count when given data is slice.
 func (c *Core) Insert(table string, data interface{}, batch ...int) (sql.Result, error) {
-	return c.DB.DoInsert(nil, table, data, gINSERT_OPTION_DEFAULT, batch...)
+	if len(batch) > 0 {
+		return c.Model(table).Data(data).Batch(batch[0]).Insert()
+	}
+	return c.Model(table).Data(data).Insert()
 }
 
 // InsertIgnore does "INSERT IGNORE INTO ..." statement for the table.
@@ -344,7 +356,10 @@ func (c *Core) Insert(table string, data interface{}, batch ...int) (sql.Result,
 //
 // The parameter <batch> specifies the batch operation count when given data is slice.
 func (c *Core) InsertIgnore(table string, data interface{}, batch ...int) (sql.Result, error) {
-	return c.DB.DoInsert(nil, table, data, gINSERT_OPTION_IGNORE, batch...)
+	if len(batch) > 0 {
+		return c.Model(table).Data(data).Batch(batch[0]).InsertIgnore()
+	}
+	return c.Model(table).Data(data).InsertIgnore()
 }
 
 // Replace does "REPLACE INTO ..." statement for the table.
@@ -360,7 +375,10 @@ func (c *Core) InsertIgnore(table string, data interface{}, batch ...int) (sql.R
 // If given data is type of slice, it then does batch replacing, and the optional parameter
 // <batch> specifies the batch operation count.
 func (c *Core) Replace(table string, data interface{}, batch ...int) (sql.Result, error) {
-	return c.DB.DoInsert(nil, table, data, gINSERT_OPTION_REPLACE, batch...)
+	if len(batch) > 0 {
+		return c.Model(table).Data(data).Batch(batch[0]).Replace()
+	}
+	return c.Model(table).Data(data).Replace()
 }
 
 // Save does "INSERT INTO ... ON DUPLICATE KEY UPDATE..." statement for the table.
@@ -375,11 +393,14 @@ func (c *Core) Replace(table string, data interface{}, batch ...int) (sql.Result
 // If given data is type of slice, it then does batch saving, and the optional parameter
 // <batch> specifies the batch operation count.
 func (c *Core) Save(table string, data interface{}, batch ...int) (sql.Result, error) {
-	return c.DB.DoInsert(nil, table, data, gINSERT_OPTION_SAVE, batch...)
+	if len(batch) > 0 {
+		return c.Model(table).Data(data).Batch(batch[0]).Save()
+	}
+	return c.Model(table).Data(data).Save()
 }
 
 // doInsert inserts or updates data for given table.
-//
+// This function is usually used for custom interface definition, you do not need call it manually.
 // The parameter <data> can be type of map/gmap/struct/*struct/[]map/[]struct, etc.
 // Eg:
 // Data(g.Map{"uid": 10000, "name":"john"})
@@ -407,8 +428,14 @@ func (c *Core) DoInsert(link Link, table string, data interface{}, option int, b
 	switch reflectKind {
 	case reflect.Slice, reflect.Array:
 		return c.DB.DoBatchInsert(link, table, data, option, batch...)
-	case reflect.Map, reflect.Struct:
-		dataMap = DataToMapDeep(data)
+	case reflect.Struct:
+		if _, ok := data.(apiInterfaces); ok {
+			return c.DB.DoBatchInsert(link, table, data, option, batch...)
+		} else {
+			dataMap = ConvertDataForTableRecord(data)
+		}
+	case reflect.Map:
+		dataMap = ConvertDataForTableRecord(data)
 	default:
 		return result, errors.New(fmt.Sprint("unsupported data type:", reflectKind))
 	}
@@ -429,7 +456,7 @@ func (c *Core) DoInsert(link Link, table string, data interface{}, option int, b
 		for k, _ := range dataMap {
 			// If it's SAVE operation,
 			// do not automatically update the creating time.
-			if utils.EqualFoldWithoutChars(k, gSOFT_FIELD_NAME_CREATE) {
+			if c.isSoftCreatedFiledName(k) {
 				continue
 			}
 			if len(updateStr) > 0 {
@@ -462,45 +489,58 @@ func (c *Core) DoInsert(link Link, table string, data interface{}, option int, b
 // BatchInsert batch inserts data.
 // The parameter <list> must be type of slice of map or struct.
 func (c *Core) BatchInsert(table string, list interface{}, batch ...int) (sql.Result, error) {
-	return c.DB.DoBatchInsert(nil, table, list, gINSERT_OPTION_DEFAULT, batch...)
+	if len(batch) > 0 {
+		return c.Model(table).Data(list).Batch(batch[0]).Insert()
+	}
+	return c.Model(table).Data(list).Insert()
 }
 
-// BatchInsert batch inserts data with ignore option.
+// BatchInsertIgnore batch inserts data with ignore option.
 // The parameter <list> must be type of slice of map or struct.
 func (c *Core) BatchInsertIgnore(table string, list interface{}, batch ...int) (sql.Result, error) {
-	return c.DB.DoBatchInsert(nil, table, list, gINSERT_OPTION_IGNORE, batch...)
+	if len(batch) > 0 {
+		return c.Model(table).Data(list).Batch(batch[0]).InsertIgnore()
+	}
+	return c.Model(table).Data(list).InsertIgnore()
 }
 
 // BatchReplace batch replaces data.
 // The parameter <list> must be type of slice of map or struct.
 func (c *Core) BatchReplace(table string, list interface{}, batch ...int) (sql.Result, error) {
-	return c.DB.DoBatchInsert(nil, table, list, gINSERT_OPTION_REPLACE, batch...)
+	if len(batch) > 0 {
+		return c.Model(table).Data(list).Batch(batch[0]).Replace()
+	}
+	return c.Model(table).Data(list).Replace()
 }
 
 // BatchSave batch replaces data.
 // The parameter <list> must be type of slice of map or struct.
 func (c *Core) BatchSave(table string, list interface{}, batch ...int) (sql.Result, error) {
-	return c.DB.DoBatchInsert(nil, table, list, gINSERT_OPTION_SAVE, batch...)
+	if len(batch) > 0 {
+		return c.Model(table).Data(list).Batch(batch[0]).Save()
+	}
+	return c.Model(table).Data(list).Save()
 }
 
 // DoBatchInsert batch inserts/replaces/saves data.
+// This function is usually used for custom interface definition, you do not need call it manually.
 func (c *Core) DoBatchInsert(link Link, table string, list interface{}, option int, batch ...int) (result sql.Result, err error) {
 	table = c.DB.QuotePrefixTableName(table)
 	var (
-		keys    []string
-		values  []string
-		params  []interface{}
-		listMap List
+		keys    []string      // Field names.
+		values  []string      // Value holder string array, like: (?,?,?)
+		params  []interface{} // Values that will be committed to underlying database driver.
+		listMap List          // The data list that passed from caller.
 	)
-	switch v := list.(type) {
+	switch value := list.(type) {
 	case Result:
-		listMap = v.List()
+		listMap = value.List()
 	case Record:
-		listMap = List{v.Map()}
+		listMap = List{value.Map()}
 	case List:
-		listMap = v
+		listMap = value
 	case Map:
-		listMap = List{v}
+		listMap = List{value}
 	default:
 		var (
 			rv   = reflect.ValueOf(list)
@@ -515,10 +555,23 @@ func (c *Core) DoBatchInsert(link Link, table string, list interface{}, option i
 		case reflect.Slice, reflect.Array:
 			listMap = make(List, rv.Len())
 			for i := 0; i < rv.Len(); i++ {
-				listMap[i] = DataToMapDeep(rv.Index(i).Interface())
+				listMap[i] = ConvertDataForTableRecord(rv.Index(i).Interface())
+			}
+		case reflect.Map:
+			listMap = List{ConvertDataForTableRecord(value)}
+		case reflect.Struct:
+			if v, ok := value.(apiInterfaces); ok {
+				var (
+					array = v.Interfaces()
+					list  = make(List, len(array))
+				)
+				for i := 0; i < len(array); i++ {
+					list[i] = ConvertDataForTableRecord(array[i])
+				}
+				listMap = list
+			} else {
+				listMap = List{ConvertDataForTableRecord(value)}
 			}
-		case reflect.Map, reflect.Struct:
-			listMap = List{DataToMapDeep(v)}
 		default:
 			return result, errors.New(fmt.Sprint("unsupported list type:", kind))
 		}
@@ -550,7 +603,7 @@ func (c *Core) DoBatchInsert(link Link, table string, list interface{}, option i
 		for _, k := range keys {
 			// If it's SAVE operation,
 			// do not automatically update the creating time.
-			if utils.EqualFoldWithoutChars(k, gSOFT_FIELD_NAME_CREATE) {
+			if c.isSoftCreatedFiledName(k) {
 				continue
 			}
 			if len(updateStr) > 0 {
@@ -620,15 +673,11 @@ func (c *Core) DoBatchInsert(link Link, table string, list interface{}, option i
 // "age IN(?,?)", 18, 50
 // User{ Id : 1, UserName : "john"}
 func (c *Core) Update(table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error) {
-	newWhere, newArgs := formatWhere(c.DB, condition, args, false)
-	if newWhere != "" {
-		newWhere = " WHERE " + newWhere
-	}
-	return c.DB.DoUpdate(nil, table, data, newWhere, newArgs...)
+	return c.Model(table).Data(data).Where(condition, args...).Update()
 }
 
 // doUpdate does "UPDATE ... " statement for the table.
-// Also see Update.
+// This function is usually used for custom interface definition, you do not need call it manually.
 func (c *Core) DoUpdate(link Link, table string, data interface{}, condition string, args ...interface{}) (result sql.Result, err error) {
 	table = c.DB.QuotePrefixTableName(table)
 	var (
@@ -647,7 +696,7 @@ func (c *Core) DoUpdate(link Link, table string, data interface{}, condition str
 	case reflect.Map, reflect.Struct:
 		var (
 			fields  []string
-			dataMap = DataToMapDeep(data)
+			dataMap = ConvertDataForTableRecord(data)
 		)
 		for k, v := range dataMap {
 			fields = append(fields, c.DB.QuoteWord(k)+"=?")
@@ -688,15 +737,11 @@ func (c *Core) DoUpdate(link Link, table string, data interface{}, condition str
 // "age IN(?,?)", 18, 50
 // User{ Id : 1, UserName : "john"}
 func (c *Core) Delete(table string, condition interface{}, args ...interface{}) (result sql.Result, err error) {
-	newWhere, newArgs := formatWhere(c.DB, condition, args, false)
-	if newWhere != "" {
-		newWhere = " WHERE " + newWhere
-	}
-	return c.DB.DoDelete(nil, table, newWhere, newArgs...)
+	return c.Model(table).Where(condition, args...).Delete()
 }
 
 // DoDelete does "DELETE FROM ... " statement for the table.
-// Also see Delete.
+// This function is usually used for custom interface definition, you do not need call it manually.
 func (c *Core) DoDelete(link Link, table string, condition string, args ...interface{}) (result sql.Result, err error) {
 	if link == nil {
 		if link, err = c.DB.Master(); err != nil {
@@ -724,7 +769,7 @@ func (c *Core) rowsToResult(rows *sql.Rows) (Result, error) {
 		columnNames[k] = v.Name()
 	}
 	var (
-		values   = make([]sql.RawBytes, len(columnNames))
+		values   = make([]interface{}, len(columnNames))
 		records  = make(Result, 0)
 		scanArgs = make([]interface{}, len(values))
 	)
@@ -735,19 +780,12 @@ func (c *Core) rowsToResult(rows *sql.Rows) (Result, error) {
 		if err := rows.Scan(scanArgs...); err != nil {
 			return records, err
 		}
-		// Creates a new row object.
 		row := make(Record)
-		// Note that the internal looping variable <value> is type of []byte,
-		// which points to the same memory address. So it should do a copy.
 		for i, value := range values {
 			if value == nil {
 				row[columnNames[i]] = gvar.New(nil)
 			} else {
-				// As sql.RawBytes is type of slice,
-				// it should do a copy of it.
-				v := make([]byte, len(value))
-				copy(v, value)
-				row[columnNames[i]] = gvar.New(c.DB.convertValue(v, columnTypes[i]))
+				row[columnNames[i]] = gvar.New(c.DB.convertValue(value, columnTypes[i]))
 			}
 		}
 		records = append(records, row)
@@ -770,7 +808,7 @@ func (c *Core) MarshalJSON() ([]byte, error) {
 // writeSqlToLogger outputs the sql object to logger.
 // It is enabled when configuration "debug" is true.
 func (c *Core) writeSqlToLogger(v *Sql) {
-	s := fmt.Sprintf("[%3d ms] %s", v.End-v.Start, v.Format)
+	s := fmt.Sprintf("[%3d ms] [%s] %s", v.End-v.Start, v.Group, v.Format)
 	if v.Error != nil {
 		s += "\nError: " + v.Error.Error()
 		c.logger.Error(s)
@@ -778,3 +816,36 @@ func (c *Core) writeSqlToLogger(v *Sql) {
 		c.logger.Debug(s)
 	}
 }
+
+// HasTable determine whether the table name exists in the database.
+func (c *Core) HasTable(name string) (bool, error) {
+	tableList, err := c.DB.Tables()
+	if err != nil {
+		return false, err
+	}
+	for _, table := range tableList {
+		if table == name {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+// isSoftCreatedFiledName checks and returns whether given filed name is an automatic-filled created time.
+func (c *Core) isSoftCreatedFiledName(fieldName string) bool {
+	if fieldName == "" {
+		return false
+	}
+	if config := c.DB.GetConfig(); config.CreatedAt != "" {
+		if utils.EqualFoldWithoutChars(fieldName, config.CreatedAt) {
+			return true
+		}
+		return gstr.InArray(append([]string{config.CreatedAt}, createdFiledNames...), fieldName)
+	}
+	for _, v := range createdFiledNames {
+		if utils.EqualFoldWithoutChars(fieldName, v) {
+			return true
+		}
+	}
+	return false
+}

database/gdb/gdb_core_config.go

@@ -39,6 +39,9 @@ type ConfigNode struct {
 	DryRun           bool          // (Optional) Dry run, which does SELECT but no INSERT/UPDATE/DELETE statements.
 	Weight           int           // (Optional) Weight for load balance calculating, it's useless if there's just one node.
 	Charset          string        // (Optional, "utf8mb4" in default) Custom charset when operating on database.
+	CreatedAt        string        // (Optional) The filed name of table for automatic-filled created datetime.
+	UpdatedAt        string        // (Optional) The filed name of table for automatic-filled updated datetime.
+	DeletedAt        string        // (Optional) The filed name of table for automatic-filled updated datetime.
 	LinkInfo         string        `json:"link"`        // (Optional) Custom link information, when it is used, configuration Host/Port/User/Pass/Name are ignored.
 	MaxIdleConnCount int           `json:"maxidle"`     // (Optional) Max idle connection configuration for underlying connection pool.
 	MaxOpenConnCount int           `json:"maxopen"`     // (Optional) Max open connection configuration for underlying connection pool.
@@ -115,6 +118,14 @@ func GetDefaultGroup() string {
 	return configs.group
 }
 
+// IsConfigured checks and returns whether the database configured.
+// It returns true if any configuration exists.
+func IsConfigured() bool {
+	configs.RLock()
+	defer configs.RUnlock()
+	return len(configs.config) > 0
+}
+
 // SetLogger sets the logger for orm.
 func (c *Core) SetLogger(logger *glog.Logger) {
 	c.logger = logger
@@ -186,6 +197,10 @@ func (c *Core) SetDryRun(dryrun bool) {
 
 // GetDryRun returns the DryRun value.
 func (c *Core) GetDryRun() bool {
+	if allDryRun {
+		// Globally set.
+		return true
+	}
 	return c.dryrun.Val()
 }
 
@@ -200,3 +215,8 @@ func (c *Core) SetSchema(schema string) {
 func (c *Core) GetSchema() string {
 	return c.schema.Val()
 }
+
+// GetConfig returns the current used node configuration.
+func (c *Core) GetConfig() *ConfigNode {
+	return c.config
+}

database/gdb/gdb_core_structure.go

@@ -0,0 +1,196 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gdb
+
+import (
+	"github.com/gogf/gf/errors/gerror"
+	"github.com/gogf/gf/util/gutil"
+	"strings"
+	"time"
+
+	"github.com/gogf/gf/text/gstr"
+
+	"github.com/gogf/gf/os/gtime"
+
+	"github.com/gogf/gf/encoding/gbinary"
+
+	"github.com/gogf/gf/text/gregex"
+	"github.com/gogf/gf/util/gconv"
+)
+
+// convertValue automatically checks and converts field value from database type
+// to golang variable type.
+func (c *Core) convertValue(fieldValue interface{}, fieldType string) interface{} {
+	// If there's no type retrieved, it returns the <fieldValue> directly
+	// to use its original data type, as <fieldValue> is type of interface{}.
+	if fieldType == "" {
+		return fieldValue
+	}
+	t, _ := gregex.ReplaceString(`\(.+\)`, "", fieldType)
+	t = strings.ToLower(t)
+	switch t {
+	case
+		"binary",
+		"varbinary",
+		"blob",
+		"tinyblob",
+		"mediumblob",
+		"longblob":
+		return gconv.Bytes(fieldValue)
+
+	case
+		"int",
+		"tinyint",
+		"small_int",
+		"smallint",
+		"medium_int",
+		"mediumint",
+		"serial":
+		if gstr.ContainsI(fieldType, "unsigned") {
+			gconv.Uint(gconv.String(fieldValue))
+		}
+		return gconv.Int(gconv.String(fieldValue))
+
+	case
+		"big_int",
+		"bigint",
+		"bigserial":
+		if gstr.ContainsI(fieldType, "unsigned") {
+			gconv.Uint64(gconv.String(fieldValue))
+		}
+		return gconv.Int64(gconv.String(fieldValue))
+
+	case "real":
+		return gconv.Float32(gconv.String(fieldValue))
+
+	case
+		"float",
+		"double",
+		"decimal",
+		"money",
+		"numeric",
+		"smallmoney":
+		return gconv.Float64(gconv.String(fieldValue))
+
+	case "bit":
+		s := gconv.String(fieldValue)
+		// mssql is true|false string.
+		if strings.EqualFold(s, "true") {
+			return 1
+		}
+		if strings.EqualFold(s, "false") {
+			return 0
+		}
+		return gbinary.BeDecodeToInt64(gconv.Bytes(fieldValue))
+
+	case "bool":
+		return gconv.Bool(fieldValue)
+
+	case "date":
+		if t, ok := fieldValue.(time.Time); ok {
+			return gtime.NewFromTime(t).Format("Y-m-d")
+		}
+		t, _ := gtime.StrToTime(gconv.String(fieldValue))
+		return t.Format("Y-m-d")
+
+	case
+		"datetime",
+		"timestamp":
+		if t, ok := fieldValue.(time.Time); ok {
+			return gtime.NewFromTime(t)
+		}
+		t, _ := gtime.StrToTime(gconv.String(fieldValue))
+		return t.String()
+
+	default:
+		// Auto detect field type, using key match.
+		switch {
+		case strings.Contains(t, "text") || strings.Contains(t, "char") || strings.Contains(t, "character"):
+			return gconv.String(fieldValue)
+
+		case strings.Contains(t, "float") || strings.Contains(t, "double") || strings.Contains(t, "numeric"):
+			return gconv.Float64(gconv.String(fieldValue))
+
+		case strings.Contains(t, "bool"):
+			return gconv.Bool(gconv.String(fieldValue))
+
+		case strings.Contains(t, "binary") || strings.Contains(t, "blob"):
+			return fieldValue
+
+		case strings.Contains(t, "int"):
+			return gconv.Int(gconv.String(fieldValue))
+
+		case strings.Contains(t, "time"):
+			s := gconv.String(fieldValue)
+			t, err := gtime.StrToTime(s)
+			if err != nil {
+				return s
+			}
+			return t.String()
+
+		case strings.Contains(t, "date"):
+			s := gconv.String(fieldValue)
+			t, err := gtime.StrToTime(s)
+			if err != nil {
+				return s
+			}
+			return t.Format("Y-m-d")
+
+		default:
+			return gconv.String(fieldValue)
+		}
+	}
+}
+
+// filterFields removes all key-value pairs which are not the field of given table.
+func (c *Core) mappingAndFilterData(schema, table string, data map[string]interface{}, filter bool) (map[string]interface{}, error) {
+	if fieldsMap, err := c.DB.TableFields(table, schema); err == nil {
+		fieldsKeyMap := make(map[string]interface{}, len(fieldsMap))
+		for k, _ := range fieldsMap {
+			fieldsKeyMap[k] = nil
+		}
+		// Automatic data key to table field name mapping.
+		var foundKey string
+		for dataKey, dataValue := range data {
+			if _, ok := fieldsKeyMap[dataKey]; !ok {
+				foundKey, _ = gutil.MapPossibleItemByKey(fieldsKeyMap, dataKey)
+				if foundKey != "" {
+					data[foundKey] = dataValue
+					delete(data, dataKey)
+				} else if !filter {
+					if schema != "" {
+						return nil, gerror.Newf(`no column of name "%s" found for table "%s" in schema "%s"`, dataKey, table, schema)
+					}
+					return nil, gerror.Newf(`no column of name "%s" found for table "%s"`, dataKey, table)
+				}
+			}
+		}
+		// Data filtering.
+		if filter {
+			for dataKey, _ := range data {
+				if _, ok := fieldsMap[dataKey]; !ok {
+					delete(data, dataKey)
+				}
+			}
+		}
+	}
+	return data, nil
+}
+
+//// filterFields removes all key-value pairs which are not the field of given table.
+//func (c *Core) filterFields(schema, table string, data map[string]interface{}) map[string]interface{} {
+//	// It must use data copy here to avoid its changing the origin data map.
+//	newDataMap := make(map[string]interface{}, len(data))
+//	if fields, err := c.DB.TableFields(table, schema); err == nil {
+//		for k, v := range data {
+//			if _, ok := fields[k]; ok {
+//				newDataMap[k] = v
+//			}
+//		}
+//	}
+//	return newDataMap
+//}

database/gdb/gdb_driver_mssql.go

@@ -15,6 +15,7 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
+	"github.com/gogf/gf/os/gcache"
 	"strconv"
 	"strings"
 
@@ -64,10 +65,10 @@ func (d *DriverMssql) GetChars() (charLeft string, charRight string) {
 // HandleSqlBeforeCommit deals with the sql string before commits it to underlying sql driver.
 func (d *DriverMssql) HandleSqlBeforeCommit(link Link, sql string, args []interface{}) (string, []interface{}) {
 	var index int
-	// Convert place holder char '?' to string "@vx".
+	// Convert place holder char '?' to string "@px".
 	str, _ := gregex.ReplaceStringFunc("\\?", sql, func(s string) string {
 		index++
-		return fmt.Sprintf("@v%d", index)
+		return fmt.Sprintf("@p%d", index)
 	})
 	str, _ = gregex.ReplaceString("\"", "", str)
 	return d.parseSql(str), args
@@ -198,47 +199,58 @@ func (d *DriverMssql) TableFields(table string, schema ...string) (fields map[st
 	if len(schema) > 0 && schema[0] != "" {
 		checkSchema = schema[0]
 	}
-	v := d.DB.GetCache().GetOrSetFunc(
-		fmt.Sprintf(`mssql_table_fields_%s_%s`, table, checkSchema), func() interface{} {
-			var result Result
-			var link *sql.DB
+	v, _ := gcache.GetOrSetFunc(
+		fmt.Sprintf(`mssql_table_fields_%s_%s`, table, checkSchema),
+		func() (interface{}, error) {
+			var (
+				result Result
+				link   *sql.DB
+			)
 			link, err = d.DB.GetSlave(checkSchema)
 			if err != nil {
-				return nil
+				return nil, err
 			}
-			result, err = d.DB.DoGetAll(link, fmt.Sprintf(`
-			SELECT a.name Field,
+			structureSql := fmt.Sprintf(`
+SELECT 
+	a.name Field,
 	CASE b.name 
 		WHEN 'datetime' THEN 'datetime'
-		WHEN 'numeric' THEN b.name + '(' + convert(varchar(20),a.xprec) + ',' + convert(varchar(20),a.xscale) + ')' 
-		WHEN 'char' THEN b.name + '(' + convert(varchar(20),a.length)+ ')'
-		WHEN 'varchar' THEN b.name + '(' + convert(varchar(20),a.length)+ ')'
-		ELSE b.name + '(' + convert(varchar(20),a.length)+ ')' END as TYPE,
-	case when a.isnullable=1 then 'YES'else 'NO' end as [Null],
-	case when exists(SELECT 1 FROM sysobjects where xtype='PK' and name in (
-	  SELECT name FROM sysindexes WHERE indid in(
-	   SELECT indid FROM sysindexkeys WHERE id = a.id AND colid=a.colid
-	   ))) then 'PRI' else '' end AS [Key],
-	case when COLUMNPROPERTY(a.id,a.name,'IsIdentity')=1 then 'auto_increment'else '' end Extra,
-	isnull(e.text,'') as [Default],
+		WHEN 'numeric' THEN b.name + '(' + convert(varchar(20), a.xprec) + ',' + convert(varchar(20), a.xscale) + ')' 
+		WHEN 'char' THEN b.name + '(' + convert(varchar(20), a.length)+ ')'
+		WHEN 'varchar' THEN b.name + '(' + convert(varchar(20), a.length)+ ')'
+		ELSE b.name + '(' + convert(varchar(20),a.length)+ ')' END AS Type,
+	CASE WHEN a.isnullable=1 THEN 'YES' ELSE 'NO' end AS [Null],
+	CASE WHEN exists (
+		SELECT 1 FROM sysobjects WHERE xtype='PK' AND name IN (
+			SELECT name FROM sysindexes WHERE indid IN (
+				SELECT indid FROM sysindexkeys WHERE id = a.id AND colid=a.colid
+			)
+		)
+	) THEN 'PRI' ELSE '' END AS [Key],
+	CASE WHEN COLUMNPROPERTY(a.id,a.name,'IsIdentity')=1 THEN 'auto_increment' ELSE '' END Extra,
+	isnull(e.text,'') AS [Default],
 	isnull(g.[value],'') AS [Comment]
-	FROM syscolumns a
-	left join systypes b on a.xtype=b.xusertype
-	inner join sysobjects d on a.id=d.id and d.xtype='U' and d.name<>'dtproperties'
-	left join syscomments e on a.cdefault=e.id
-	left join sys.extended_properties g on a.id=g.major_id and a.colid=g.minor_id
-	left join sys.extended_properties f on d.id=f.major_id and f.minor_id =0
-	where d.name='%s'
-	order by a.id,a.colorder`, strings.ToUpper(table)))
+FROM syscolumns a
+LEFT JOIN systypes b ON a.xtype=b.xtype AND a.xusertype=b.xusertype
+INNER JOIN sysobjects d ON a.id=d.id AND d.xtype='U' AND d.name<>'dtproperties'
+LEFT JOIN syscomments e ON a.cdefault=e.id
+LEFT JOIN sys.extended_properties g ON a.id=g.major_id AND a.colid=g.minor_id
+LEFT JOIN sys.extended_properties f ON d.id=f.major_id AND f.minor_id =0
+WHERE d.name='%s'
+ORDER BY a.id,a.colorder`,
+				strings.ToUpper(table),
+			)
+			structureSql, _ = gregex.ReplaceString(`[\n\r\s]+`, " ", gstr.Trim(structureSql))
+			result, err = d.DB.DoGetAll(link, structureSql)
 			if err != nil {
-				return nil
+				return nil, err
 			}
 			fields = make(map[string]*TableField)
 			for i, m := range result {
-				fields[strings.ToLower(m["FIELD"].String())] = &TableField{
+				fields[strings.ToLower(m["Field"].String())] = &TableField{
 					Index:   i,
-					Name:    strings.ToLower(m["FIELD"].String()),
-					Type:    strings.ToLower(m["TYPE"].String()),
+					Name:    strings.ToLower(m["Field"].String()),
+					Type:    strings.ToLower(m["Type"].String()),
 					Null:    m["Null"].Bool(),
 					Key:     m["Key"].String(),
 					Default: m["Default"].Val(),
@@ -246,7 +258,7 @@ func (d *DriverMssql) TableFields(table string, schema ...string) (fields map[st
 					Comment: m["Comment"].String(),
 				}
 			}
-			return fields
+			return fields, nil
 		}, 0)
 	if err == nil {
 		fields = v.(map[string]*TableField)

database/gdb/gdb_driver_mysql.go

@@ -11,6 +11,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/gogf/gf/internal/intlog"
+	"github.com/gogf/gf/os/gcache"
 	"github.com/gogf/gf/text/gregex"
 	"github.com/gogf/gf/text/gstr"
 
@@ -102,21 +103,23 @@ func (d *DriverMysql) TableFields(table string, schema ...string) (fields map[st
 	if len(schema) > 0 && schema[0] != "" {
 		checkSchema = schema[0]
 	}
-	v := d.cache.GetOrSetFunc(
+	v, _ := gcache.GetOrSetFunc(
 		fmt.Sprintf(`mysql_table_fields_%s_%s`, table, checkSchema),
-		func() interface{} {
-			var result Result
-			var link *sql.DB
+		func() (interface{}, error) {
+			var (
+				result Result
+				link   *sql.DB
+			)
 			link, err = d.DB.GetSlave(checkSchema)
 			if err != nil {
-				return nil
+				return nil, err
 			}
 			result, err = d.DB.DoGetAll(
 				link,
 				fmt.Sprintf(`SHOW FULL COLUMNS FROM %s`, d.DB.QuoteWord(table)),
 			)
 			if err != nil {
-				return nil
+				return nil, err
 			}
 			fields = make(map[string]*TableField)
 			for i, m := range result {
@@ -131,7 +134,7 @@ func (d *DriverMysql) TableFields(table string, schema ...string) (fields map[st
 					Comment: m["Comment"].String(),
 				}
 			}
-			return fields
+			return fields, nil
 		}, 0)
 	if err == nil {
 		fields = v.(map[string]*TableField)

database/gdb/gdb_driver_oracle.go

@@ -16,6 +16,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/gogf/gf/internal/intlog"
+	"github.com/gogf/gf/os/gcache"
 	"github.com/gogf/gf/text/gstr"
 	"reflect"
 	"strconv"
@@ -78,44 +79,45 @@ func (d *DriverOracle) HandleSqlBeforeCommit(link Link, sql string, args []inter
 // parseSql does some replacement of the sql before commits it to underlying driver,
 // for support of oracle server.
 func (d *DriverOracle) parseSql(sql string) string {
-	patten := `^\s*(?i)(SELECT)|(LIMIT\s*(\d+)\s*,\s*(\d+))`
-	if gregex.IsMatchString(patten, sql) == false {
+	var (
+		patten      = `^\s*(?i)(SELECT)|(LIMIT\s*(\d+)\s*,{0,1}\s*(\d*))`
+		allMatch, _ = gregex.MatchAllString(patten, sql)
+	)
+	if len(allMatch) == 0 {
 		return sql
 	}
-
-	res, err := gregex.MatchAllString(patten, sql)
-	if err != nil {
-		return ""
-	}
-
 	var (
 		index   = 0
-		keyword = strings.ToUpper(strings.TrimSpace(res[index][0]))
+		keyword = strings.ToUpper(strings.TrimSpace(allMatch[index][0]))
 	)
 	index++
 	switch keyword {
 	case "SELECT":
-		if len(res) < 2 || (strings.HasPrefix(res[index][0], "LIMIT") == false &&
-			strings.HasPrefix(res[index][0], "limit") == false) {
+		if len(allMatch) < 2 || strings.HasPrefix(allMatch[index][0], "LIMIT") == false {
 			break
 		}
 		if gregex.IsMatchString("((?i)SELECT)(.+)((?i)LIMIT)", sql) == false {
 			break
 		}
 		queryExpr, _ := gregex.MatchString("((?i)SELECT)(.+)((?i)LIMIT)", sql)
-		if len(queryExpr) != 4 || strings.EqualFold(queryExpr[1], "SELECT") == false ||
+		if len(queryExpr) != 4 ||
+			strings.EqualFold(queryExpr[1], "SELECT") == false ||
 			strings.EqualFold(queryExpr[3], "LIMIT") == false {
 			break
 		}
 		first, limit := 0, 0
-		for i := 1; i < len(res[index]); i++ {
-			if len(strings.TrimSpace(res[index][i])) == 0 {
+		for i := 1; i < len(allMatch[index]); i++ {
+			if len(strings.TrimSpace(allMatch[index][i])) == 0 {
 				continue
 			}
 
-			if strings.HasPrefix(res[index][i], "LIMIT") || strings.HasPrefix(res[index][i], "limit") {
-				first, _ = strconv.Atoi(res[index][i+1])
-				limit, _ = strconv.Atoi(res[index][i+2])
+			if strings.HasPrefix(allMatch[index][i], "LIMIT") {
+				if allMatch[index][i+2] != "" {
+					first, _ = strconv.Atoi(allMatch[index][i+1])
+					limit, _ = strconv.Atoi(allMatch[index][i+2])
+				} else {
+					limit, _ = strconv.Atoi(allMatch[index][i+1])
+				}
 				break
 			}
 		}
@@ -157,18 +159,24 @@ func (d *DriverOracle) TableFields(table string, schema ...string) (fields map[s
 	if len(schema) > 0 && schema[0] != "" {
 		checkSchema = schema[0]
 	}
-	v := d.DB.GetCache().GetOrSetFunc(
+	v, _ := gcache.GetOrSetFunc(
 		fmt.Sprintf(`oracle_table_fields_%s_%s`, table, checkSchema),
-		func() interface{} {
+		func() (interface{}, error) {
 			result := (Result)(nil)
-			result, err = d.DB.GetAll(fmt.Sprintf(`
-			SELECT COLUMN_NAME AS FIELD, CASE DATA_TYPE 
-			    WHEN 'NUMBER' THEN DATA_TYPE||'('||DATA_PRECISION||','||DATA_SCALE||')' 
-				WHEN 'FLOAT' THEN DATA_TYPE||'('||DATA_PRECISION||','||DATA_SCALE||')' 
-				ELSE DATA_TYPE||'('||DATA_LENGTH||')' END AS TYPE  
-			FROM USER_TAB_COLUMNS WHERE TABLE_NAME = '%s' ORDER BY COLUMN_ID`, strings.ToUpper(table)))
+			structureSql := fmt.Sprintf(`
+SELECT 
+	COLUMN_NAME AS FIELD, 
+	CASE DATA_TYPE  
+	WHEN 'NUMBER' THEN DATA_TYPE||'('||DATA_PRECISION||','||DATA_SCALE||')' 
+	WHEN 'FLOAT' THEN DATA_TYPE||'('||DATA_PRECISION||','||DATA_SCALE||')' 
+	ELSE DATA_TYPE||'('||DATA_LENGTH||')' END AS TYPE  
+FROM USER_TAB_COLUMNS WHERE TABLE_NAME = '%s' ORDER BY COLUMN_ID`,
+				strings.ToUpper(table),
+			)
+			structureSql, _ = gregex.ReplaceString(`[\n\r\s]+`, " ", gstr.Trim(structureSql))
+			result, err = d.DB.GetAll(structureSql)
 			if err != nil {
-				return nil
+				return nil, err
 			}
 			fields = make(map[string]*TableField)
 			for i, m := range result {
@@ -178,7 +186,7 @@ func (d *DriverOracle) TableFields(table string, schema ...string) (fields map[s
 					Type:  strings.ToLower(m["TYPE"].String()),
 				}
 			}
-			return fields
+			return fields, nil
 		}, 0)
 	if err == nil {
 		fields = v.(map[string]*TableField)
@@ -188,24 +196,26 @@ func (d *DriverOracle) TableFields(table string, schema ...string) (fields map[s
 
 func (d *DriverOracle) getTableUniqueIndex(table string) (fields map[string]map[string]string, err error) {
 	table = strings.ToUpper(table)
-	v := d.DB.GetCache().GetOrSetFunc("table_unique_index_"+table, func() interface{} {
-		res := (Result)(nil)
-		res, err = d.DB.GetAll(fmt.Sprintf(`
+	v, _ := gcache.GetOrSetFunc(
+		"table_unique_index_"+table,
+		func() (interface{}, error) {
+			res := (Result)(nil)
+			res, err = d.DB.GetAll(fmt.Sprintf(`
 		SELECT INDEX_NAME,COLUMN_NAME,CHAR_LENGTH FROM USER_IND_COLUMNS 
 		WHERE TABLE_NAME = '%s' 
 		AND INDEX_NAME IN(SELECT INDEX_NAME FROM USER_INDEXES WHERE TABLE_NAME='%s' AND UNIQUENESS='UNIQUE') 
 		ORDER BY INDEX_NAME,COLUMN_POSITION`, table, table))
-		if err != nil {
-			return nil
-		}
-		fields := make(map[string]map[string]string)
-		for _, v := range res {
-			mm := make(map[string]string)
-			mm[v["COLUMN_NAME"].String()] = v["CHAR_LENGTH"].String()
-			fields[v["INDEX_NAME"].String()] = mm
-		}
-		return fields
-	}, 0)
+			if err != nil {
+				return nil, err
+			}
+			fields := make(map[string]map[string]string)
+			for _, v := range res {
+				mm := make(map[string]string)
+				mm[v["COLUMN_NAME"].String()] = v["CHAR_LENGTH"].String()
+				fields[v["INDEX_NAME"].String()] = mm
+			}
+			return fields, nil
+		}, 0)
 	if err == nil {
 		fields = v.(map[string]map[string]string)
 	}
@@ -231,7 +241,7 @@ func (d *DriverOracle) DoInsert(link Link, table string, data interface{}, optio
 	case reflect.Map:
 		fallthrough
 	case reflect.Struct:
-		dataMap = DataToMapDeep(data)
+		dataMap = ConvertDataForTableRecord(data)
 	default:
 		return result, errors.New(fmt.Sprint("unsupported data type:", kind))
 	}
@@ -351,12 +361,12 @@ func (d *DriverOracle) DoBatchInsert(link Link, table string, list interface{},
 		case reflect.Array:
 			listMap = make(List, rv.Len())
 			for i := 0; i < rv.Len(); i++ {
-				listMap[i] = DataToMapDeep(rv.Index(i).Interface())
+				listMap[i] = ConvertDataForTableRecord(rv.Index(i).Interface())
 			}
 		case reflect.Map:
 			fallthrough
 		case reflect.Struct:
-			listMap = List{Map(DataToMapDeep(list))}
+			listMap = List{Map(ConvertDataForTableRecord(list))}
 		default:
 			return result, errors.New(fmt.Sprint("unsupported list type:", kind))
 		}

database/gdb/gdb_driver_pgsql.go

@@ -16,6 +16,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/gogf/gf/internal/intlog"
+	"github.com/gogf/gf/os/gcache"
 	"github.com/gogf/gf/text/gstr"
 	"strings"
 
@@ -62,10 +63,10 @@ func (d *DriverPgsql) GetChars() (charLeft string, charRight string) {
 // HandleSqlBeforeCommit deals with the sql string before commits it to underlying sql driver.
 func (d *DriverPgsql) HandleSqlBeforeCommit(link Link, sql string, args []interface{}) (string, []interface{}) {
 	var index int
-	// Convert place holder char '?' to string "$vx".
+	// Convert place holder char '?' to string "$x".
 	sql, _ = gregex.ReplaceStringFunc("\\?", sql, func(s string) string {
 		index++
-		return fmt.Sprintf("$v%d", index)
+		return fmt.Sprintf("$%d", index)
 	})
 	sql, _ = gregex.ReplaceString(` LIMIT (\d+),\s*(\d+)`, ` LIMIT $2 OFFSET $1`, sql)
 	return sql, args
@@ -107,21 +108,28 @@ func (d *DriverPgsql) TableFields(table string, schema ...string) (fields map[st
 	if len(schema) > 0 && schema[0] != "" {
 		checkSchema = schema[0]
 	}
-	v := d.DB.GetCache().GetOrSetFunc(
-		fmt.Sprintf(`pgsql_table_fields_%s_%s`, table, checkSchema), func() interface{} {
-			var result Result
-			var link *sql.DB
+	v, _ := gcache.GetOrSetFunc(
+		fmt.Sprintf(`pgsql_table_fields_%s_%s`, table, checkSchema),
+		func() (interface{}, error) {
+			var (
+				result Result
+				link   *sql.DB
+			)
 			link, err = d.DB.GetSlave(checkSchema)
 			if err != nil {
-				return nil
+				return nil, err
 			}
-			result, err = d.DB.DoGetAll(link, fmt.Sprintf(`
-			SELECT a.attname AS field, t.typname AS type FROM pg_class c, pg_attribute a 
-	        LEFT OUTER JOIN pg_description b ON a.attrelid=b.objoid AND a.attnum = b.objsubid,pg_type t
-	        WHERE c.relname = '%s' and a.attnum > 0 and a.attrelid = c.oid and a.atttypid = t.oid 
-			ORDER BY a.attnum`, strings.ToLower(table)))
+			structureSql := fmt.Sprintf(`
+SELECT a.attname AS field, t.typname AS type FROM pg_class c, pg_attribute a 
+LEFT OUTER JOIN pg_description b ON a.attrelid=b.objoid AND a.attnum = b.objsubid,pg_type t
+WHERE c.relname = '%s' and a.attnum > 0 and a.attrelid = c.oid and a.atttypid = t.oid 
+ORDER BY a.attnum`,
+				strings.ToLower(table),
+			)
+			structureSql, _ = gregex.ReplaceString(`[\n\r\s]+`, " ", gstr.Trim(structureSql))
+			result, err = d.DB.DoGetAll(link, structureSql)
 			if err != nil {
-				return nil
+				return nil, err
 			}
 
 			fields = make(map[string]*TableField)
@@ -132,7 +140,7 @@ func (d *DriverPgsql) TableFields(table string, schema ...string) (fields map[st
 					Type:  m["type"].String(),
 				}
 			}
-			return fields
+			return fields, nil
 		}, 0)
 	if err == nil {
 		fields = v.(map[string]*TableField)

database/gdb/gdb_driver_sqlite.go

@@ -15,6 +15,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/gogf/gf/internal/intlog"
+	"github.com/gogf/gf/os/gcache"
 	"github.com/gogf/gf/os/gfile"
 	"github.com/gogf/gf/text/gstr"
 	"strings"
@@ -98,17 +99,20 @@ func (d *DriverSqlite) TableFields(table string, schema ...string) (fields map[s
 	if len(schema) > 0 && schema[0] != "" {
 		checkSchema = schema[0]
 	}
-	v := d.DB.GetCache().GetOrSetFunc(
-		fmt.Sprintf(`sqlite_table_fields_%s_%s`, table, checkSchema), func() interface{} {
-			var result Result
-			var link *sql.DB
+	v, _ := gcache.GetOrSetFunc(
+		fmt.Sprintf(`sqlite_table_fields_%s_%s`, table, checkSchema),
+		func() (interface{}, error) {
+			var (
+				result Result
+				link   *sql.DB
+			)
 			link, err = d.DB.GetSlave(checkSchema)
 			if err != nil {
-				return nil
+				return nil, err
 			}
 			result, err = d.DB.DoGetAll(link, fmt.Sprintf(`PRAGMA TABLE_INFO(%s)`, table))
 			if err != nil {
-				return nil
+				return nil, err
 			}
 			fields = make(map[string]*TableField)
 			for i, m := range result {
@@ -118,7 +122,7 @@ func (d *DriverSqlite) TableFields(table string, schema ...string) (fields map[s
 					Type:  strings.ToLower(m["type"].String()),
 				}
 			}
-			return fields
+			return fields, nil
 		}, 0)
 	if err == nil {
 		fields = v.(map[string]*TableField)

database/gdb/gdb_func.go

@@ -11,6 +11,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/gogf/gf/internal/empty"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/internal/utils"
 	"github.com/gogf/gf/os/gtime"
 	"github.com/gogf/gf/util/gutil"
@@ -55,14 +56,34 @@ const (
 var (
 	// quoteWordReg is the regular expression object for a word check.
 	quoteWordReg = regexp.MustCompile(`^[a-zA-Z0-9\-_]+$`)
+
+	// Priority tags for struct converting for orm field mapping.
+	structTagPriority = append([]string{ORM_TAG_FOR_STRUCT}, gconv.StructTagPriority...)
 )
 
-// ListItemValues is alias for gutil.ListItemValues.
+// ListItemValues retrieves and returns the elements of all item struct/map with key <key>.
+// Note that the parameter <list> should be type of slice which contains elements of map or struct,
+// or else it returns an empty slice.
+//
+// The parameter <list> supports types like:
+// []map[string]interface{}
+// []map[string]sub-map
+// []struct
+// []struct:sub-struct
+// Note that the sub-map/sub-struct makes sense only if the optional parameter <subKey> is given.
 // See gutil.ListItemValues.
 func ListItemValues(list interface{}, key interface{}, subKey ...interface{}) (values []interface{}) {
 	return gutil.ListItemValues(list, key, subKey...)
 }
 
+// ListItemValuesUnique retrieves and returns the unique elements of all struct/map with key <key>.
+// Note that the parameter <list> should be type of slice which contains elements of map or struct,
+// or else it returns an empty slice.
+// See gutil.ListItemValuesUnique.
+func ListItemValuesUnique(list interface{}, key string, subKey ...interface{}) []interface{} {
+	return gutil.ListItemValuesUnique(list, key, subKey...)
+}
+
 // GetInsertOperationByOption returns proper insert option with given parameter <option>.
 func GetInsertOperationByOption(option int) string {
 	var operator string
@@ -77,34 +98,142 @@ func GetInsertOperationByOption(option int) string {
 	return operator
 }
 
-// DataToMapDeep converts struct object to map type recursively.
-func DataToMapDeep(obj interface{}) map[string]interface{} {
-	data := gconv.Map(obj, ORM_TAG_FOR_STRUCT)
-	for key, value := range data {
-		rv := reflect.ValueOf(value)
-		kind := rv.Kind()
-		if kind == reflect.Ptr {
-			rv = rv.Elem()
-			kind = rv.Kind()
+// ConvertDataForTableRecord is a very important function, which does converting for any data that
+// will be inserted into table as a record.
+//
+// The parameter <obj> should be type of *map/map/*struct/struct.
+// It supports inherit struct definition for struct.
+func ConvertDataForTableRecord(value interface{}) map[string]interface{} {
+	var (
+		rvValue reflect.Value
+		rvKind  reflect.Kind
+		data    = DataToMapDeep(value)
+	)
+	for k, v := range data {
+		rvValue = reflect.ValueOf(v)
+		rvKind = rvValue.Kind()
+		for rvKind == reflect.Ptr {
+			rvValue = rvValue.Elem()
+			rvKind = rvValue.Kind()
 		}
-		switch kind {
+		switch rvKind {
+		case reflect.Slice, reflect.Array, reflect.Map:
+			// It should ignore the bytes type.
+			if _, ok := v.([]byte); !ok {
+				// Convert the value to JSON.
+				data[k], _ = json.Marshal(v)
+			}
 		case reflect.Struct:
-			// The underlying driver supports time.Time/*time.Time types.
-			if _, ok := value.(time.Time); ok {
+			switch v.(type) {
+			case time.Time, *time.Time, gtime.Time, *gtime.Time:
 				continue
+			default:
+				// Use string conversion in default.
+				if s, ok := v.(apiString); ok {
+					data[k] = s.String()
+				} else {
+					// Convert the value to JSON.
+					data[k], _ = json.Marshal(v)
+				}
 			}
-			if _, ok := value.(*time.Time); ok {
-				continue
-			}
-			// Use string conversion in default.
-			if s, ok := value.(apiString); ok {
-				data[key] = s.String()
-				continue
-			}
-			delete(data, key)
-			for k, v := range DataToMapDeep(value) {
+		}
+	}
+	return data
+}
+
+// DataToMapDeep converts <value> to map type recursively.
+// The parameter <value> should be type of *map/map/*struct/struct.
+// It supports inherit struct definition for struct.
+func DataToMapDeep(value interface{}) map[string]interface{} {
+	if v, ok := value.(apiMapStrAny); ok {
+		return v.MapStrAny()
+	}
+	var (
+		rvValue reflect.Value
+		rvField reflect.Value
+		rvKind  reflect.Kind
+		rtField reflect.StructField
+	)
+	if v, ok := value.(reflect.Value); ok {
+		rvValue = v
+	} else {
+		rvValue = reflect.ValueOf(value)
+	}
+	rvKind = rvValue.Kind()
+	if rvKind == reflect.Ptr {
+		rvValue = rvValue.Elem()
+		rvKind = rvValue.Kind()
+	}
+	// If given <value> is not a struct, it uses gconv.Map for converting.
+	if rvKind != reflect.Struct {
+		return gconv.Map(value, structTagPriority...)
+	}
+	// Struct handling.
+	var (
+		fieldTag reflect.StructTag
+		rvType   = rvValue.Type()
+		name     = ""
+		data     = make(map[string]interface{})
+	)
+	for i := 0; i < rvValue.NumField(); i++ {
+		rtField = rvType.Field(i)
+		rvField = rvValue.Field(i)
+		fieldName := rtField.Name
+		if !utils.IsLetterUpper(fieldName[0]) {
+			continue
+		}
+		// Struct attribute inherit
+		if rtField.Anonymous {
+			for k, v := range DataToMapDeep(rvField) {
 				data[k] = v
 			}
+			continue
+		}
+		// Other attributes.
+		name = ""
+		fieldTag = rtField.Tag
+		for _, tag := range structTagPriority {
+			if s := fieldTag.Get(tag); s != "" {
+				name = s
+				break
+			}
+		}
+		if name == "" {
+			name = fieldName
+		} else {
+			// The "orm" tag supports json tag feature: -, omitempty
+			// The "orm" tag would be like: "id,priority", so it should use splitting handling.
+			name = gstr.Trim(name)
+			if name == "-" {
+				continue
+			}
+			array := gstr.SplitAndTrim(name, ",")
+			if len(array) > 1 {
+				switch array[1] {
+				case "omitempty":
+					if empty.IsEmpty(rvField.Interface()) {
+						continue
+					} else {
+						name = array[0]
+					}
+				default:
+					name = array[0]
+				}
+			}
+		}
+
+		// The underlying driver supports time.Time/*time.Time types.
+		fieldValue := rvField.Interface()
+		switch fieldValue.(type) {
+		case time.Time, *time.Time, gtime.Time, *gtime.Time:
+			data[name] = fieldValue
+		default:
+			// Use string conversion in default.
+			if s, ok := fieldValue.(apiString); ok {
+				data[name] = s.String()
+			} else {
+				data[name] = fieldValue
+			}
 		}
 	}
 	return data
@@ -231,8 +360,10 @@ func GetPrimaryKeyCondition(primary string, where ...interface{}) (newWhereCondi
 		return where
 	}
 	if len(where) == 1 {
-		rv := reflect.ValueOf(where[0])
-		kind := rv.Kind()
+		var (
+			rv   = reflect.ValueOf(where[0])
+			kind = rv.Kind()
+		)
 		if kind == reflect.Ptr {
 			rv = rv.Elem()
 			kind = rv.Kind()
@@ -255,9 +386,10 @@ func GetPrimaryKeyCondition(primary string, where ...interface{}) (newWhereCondi
 // The internal handleArguments function might be called twice during the SQL procedure,
 // but do not worry about it, it's safe and efficient.
 func formatSql(sql string, args []interface{}) (newSql string, newArgs []interface{}) {
-	sql = gstr.Trim(sql)
-	sql = gstr.Replace(sql, "\n", " ")
-	sql, _ = gregex.ReplaceString(`\s{2,}`, ` `, sql)
+	// DO NOT do this as there may be multiple lines and comments in the sql.
+	// sql = gstr.Trim(sql)
+	// sql = gstr.Replace(sql, "\n", " ")
+	// sql, _ = gregex.ReplaceString(`\s{2,}`, ` `, sql)
 	return handleArguments(sql, args)
 }
 
@@ -553,7 +685,7 @@ func formatError(err error, sql string, args ...interface{}) error {
 func FormatSqlWithArgs(sql string, args []interface{}) string {
 	index := -1
 	newQuery, _ := gregex.ReplaceStringFunc(
-		`(\?|:v\d+|\$v\d+|@v\d+)`, sql, func(s string) string {
+		`(\?|:v\d+|\$\d+|@p\d+)`, sql, func(s string) string {
 			index++
 			if len(args) > index {
 				if args[index] == nil {

database/gdb/gdb_model_condition.go

@@ -140,7 +140,7 @@ func (m *Model) Offset(offset int) *Model {
 
 // Page sets the paging number for the model.
 // The parameter <page> is started from 1 for paging.
-// Note that, it differs that the Limit function start from 0 for "LIMIT" statement.
+// Note that, it differs that the Limit function starts from 0 for "LIMIT" statement.
 func (m *Model) Page(page, limit int) *Model {
 	model := m.getModel()
 	if page <= 0 {

database/gdb/gdb_model_delete.go

@@ -12,13 +12,6 @@ import (
 	"github.com/gogf/gf/os/gtime"
 )
 
-// Unscoped disables the soft deleting feature.
-func (m *Model) Unscoped() *Model {
-	model := m.getModel()
-	model.unscoped = true
-	return model
-}
-
 // Delete does "DELETE FROM ... " statement for the model.
 // The optional parameter <where> is the same as the parameter of Model.Where function,
 // see Model.Where.
@@ -32,7 +25,7 @@ func (m *Model) Delete(where ...interface{}) (result sql.Result, err error) {
 		}
 	}()
 	var (
-		fieldNameDelete                               = m.getSoftFieldNameDelete()
+		fieldNameDelete                               = m.getSoftFieldNameDeleted()
 		conditionWhere, conditionExtra, conditionArgs = m.formatCondition(false)
 	)
 	// Soft deleting.

database/gdb/gdb_model_fields.go

@@ -24,49 +24,35 @@ func (m *Model) Filter() *Model {
 }
 
 // Fields sets the operation fields of the model, multiple fields joined using char ','.
-func (m *Model) Fields(fields string) *Model {
-	model := m.getModel()
-	model.fields = fields
-	return model
+func (m *Model) Fields(fields ...string) *Model {
+	if len(fields) > 0 {
+		model := m.getModel()
+		model.fields = gstr.Join(fields, ",")
+		return model
+	}
+	return m
 }
 
 // FieldsEx sets the excluded operation fields of the model, multiple fields joined using char ','.
 // Note that this function supports only single table operations.
-func (m *Model) FieldsEx(fields string) *Model {
-	if gstr.Contains(m.tables, " ") {
-		panic("function FieldsEx supports only single table operations")
+func (m *Model) FieldsEx(fields ...string) *Model {
+	if len(fields) > 0 {
+		model := m.getModel()
+		model.fieldsEx = gstr.Join(fields, ",")
+		return model
 	}
-	tableFields, err := m.db.TableFields(m.tables)
-	if err != nil {
-		panic(err)
-	}
-	if len(tableFields) == 0 {
-		panic(fmt.Sprintf(`empty table fields for table "%s"`, m.tables))
-	}
-	model := m.getModel()
-	model.fieldsEx = fields
-	fieldsExSet := gset.NewStrSetFrom(gstr.SplitAndTrim(fields, ","))
-	fieldsArray := make([]string, len(tableFields))
-	for k, v := range tableFields {
-		fieldsArray[v.Index] = k
-	}
-	model.fields = ""
-	for _, k := range fieldsArray {
-		if fieldsExSet.Contains(k) {
-			continue
-		}
-		if len(model.fields) > 0 {
-			model.fields += ","
-		}
-		model.fields += k
-	}
-	model.fields = model.db.QuoteString(model.fields)
-	return model
+	return m
+}
+
+// Deprecated, use GetFieldsStr instead.
+// This function name confuses the user that it was a chaining function.
+func (m *Model) FieldsStr(prefix ...string) string {
+	return m.GetFieldsStr(prefix...)
 }
 
 // FieldsStr retrieves and returns all fields from the table, joined with char ','.
 // The optional parameter <prefix> specifies the prefix for each field, eg: FieldsStr("u.").
-func (m *Model) FieldsStr(prefix ...string) string {
+func (m *Model) GetFieldsStr(prefix ...string) string {
 	prefixStr := ""
 	if len(prefix) > 0 {
 		prefixStr = prefix[0]
@@ -93,11 +79,17 @@ func (m *Model) FieldsStr(prefix ...string) string {
 	return newFields
 }
 
+// Deprecated, use GetFieldsExStr instead.
+// This function name confuses the user that it was a chaining function.
+func (m *Model) FieldsExStr(fields string, prefix ...string) string {
+	return m.GetFieldsExStr(fields, prefix...)
+}
+
 // FieldsExStr retrieves and returns fields which are not in parameter <fields> from the table,
 // joined with char ','.
 // The parameter <fields> specifies the fields that are excluded.
 // The optional parameter <prefix> specifies the prefix for each field, eg: FieldsExStr("id", "u.").
-func (m *Model) FieldsExStr(fields string, prefix ...string) string {
+func (m *Model) GetFieldsExStr(fields string, prefix ...string) string {
 	prefixStr := ""
 	if len(prefix) > 0 {
 		prefixStr = prefix[0]
@@ -127,3 +119,24 @@ func (m *Model) FieldsExStr(fields string, prefix ...string) string {
 	newFields = m.db.QuoteString(newFields)
 	return newFields
 }
+
+// HasField determine whether the field exists in the table.
+func (m *Model) HasField(field string) (bool, error) {
+	tableFields, err := m.db.TableFields(m.tables)
+	if err != nil {
+		return false, err
+	}
+	if len(tableFields) == 0 {
+		return false, fmt.Errorf(`empty table fields for table "%s"`, m.tables)
+	}
+	fieldsArray := make([]string, len(tableFields))
+	for k, v := range tableFields {
+		fieldsArray[v.Index] = k
+	}
+	for _, f := range fieldsArray {
+		if f == field {
+			return true, nil
+		}
+	}
+	return false, nil
+}

database/gdb/gdb_model_insert.go

@@ -56,8 +56,10 @@ func (m *Model) Data(data ...interface{}) *Model {
 		case Map:
 			model.data = params
 		default:
-			rv := reflect.ValueOf(params)
-			kind := rv.Kind()
+			var (
+				rv   = reflect.ValueOf(params)
+				kind = rv.Kind()
+			)
 			if kind == reflect.Ptr {
 				rv = rv.Elem()
 				kind = rv.Kind()
@@ -66,23 +68,23 @@ func (m *Model) Data(data ...interface{}) *Model {
 			case reflect.Slice, reflect.Array:
 				list := make(List, rv.Len())
 				for i := 0; i < rv.Len(); i++ {
-					list[i] = DataToMapDeep(rv.Index(i).Interface())
+					list[i] = ConvertDataForTableRecord(rv.Index(i).Interface())
 				}
 				model.data = list
 			case reflect.Map:
-				model.data = DataToMapDeep(data[0])
+				model.data = ConvertDataForTableRecord(data[0])
 			case reflect.Struct:
-				if v, ok := data[0].(apiMapStrAny); ok {
-					model.data = v.MapStrAny()
-				} else if v, ok := data[0].(apiInterfaces); ok {
-					array := v.Interfaces()
-					list := make(List, len(array))
+				if v, ok := data[0].(apiInterfaces); ok {
+					var (
+						array = v.Interfaces()
+						list  = make(List, len(array))
+					)
 					for i := 0; i < len(array); i++ {
-						list[i] = DataToMapDeep(array[i])
+						list[i] = ConvertDataForTableRecord(array[i])
 					}
 					model.data = list
 				} else {
-					model.data = DataToMapDeep(data[0])
+					model.data = ConvertDataForTableRecord(data[0])
 				}
 			default:
 				model.data = data[0]
@@ -147,9 +149,9 @@ func (m *Model) doInsertWithOption(option int, data ...interface{}) (result sql.
 	}
 	var (
 		nowString       = gtime.Now().String()
-		fieldNameCreate = m.getSoftFieldNameCreate()
-		fieldNameUpdate = m.getSoftFieldNameUpdate()
-		fieldNameDelete = m.getSoftFieldNameDelete()
+		fieldNameCreate = m.getSoftFieldNameCreated()
+		fieldNameUpdate = m.getSoftFieldNameUpdated()
+		fieldNameDelete = m.getSoftFieldNameDeleted()
 	)
 	// Batch operation.
 	if list, ok := m.data.(List); ok {
@@ -170,10 +172,14 @@ func (m *Model) doInsertWithOption(option int, data ...interface{}) (result sql.
 				list[k] = v
 			}
 		}
+		newData, err := m.filterDataForInsertOrUpdate(list)
+		if err != nil {
+			return nil, err
+		}
 		return m.db.DoBatchInsert(
 			m.getLink(true),
 			m.tables,
-			m.filterDataForInsertOrUpdate(list),
+			newData,
 			option,
 			batch,
 		)
@@ -190,10 +196,14 @@ func (m *Model) doInsertWithOption(option int, data ...interface{}) (result sql.
 				data[fieldNameUpdate] = nowString
 			}
 		}
+		newData, err := m.filterDataForInsertOrUpdate(data)
+		if err != nil {
+			return nil, err
+		}
 		return m.db.DoInsert(
 			m.getLink(true),
 			m.tables,
-			m.filterDataForInsertOrUpdate(data),
+			newData,
 			option,
 		)
 	}

database/gdb/gdb_model_join.go

@@ -6,7 +6,21 @@
 
 package gdb
 
-import "fmt"
+import (
+	"fmt"
+	"github.com/gogf/gf/text/gstr"
+)
+
+// isSubQuery checks and returns whether given string a sub-query sql string.
+func isSubQuery(s string) bool {
+	s = gstr.TrimLeft(s)
+	if p := gstr.Pos(s, " "); p != -1 {
+		if gstr.Equal(s[:p], "select") {
+			return true
+		}
+	}
+	return false
+}
 
 // LeftJoin does "LEFT JOIN ... ON ..." statement on the model.
 // The parameter <table> can be joined table and its joined condition,
@@ -14,19 +28,32 @@ import "fmt"
 // Table("user").LeftJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").LeftJoin("user_detail", "ud", "ud.uid=u.uid")
 func (m *Model) LeftJoin(table ...string) *Model {
-	model := m.getModel()
+	var (
+		model   = m.getModel()
+		joinStr = ""
+	)
+	if len(table) > 0 {
+		if isSubQuery(table[0]) {
+			joinStr = "(" + table[0] + ")"
+		} else {
+			joinStr = m.db.QuotePrefixTableName(table[0])
+		}
+	}
 	if len(table) > 2 {
 		model.tables += fmt.Sprintf(
 			" LEFT JOIN %s AS %s ON (%s)",
-			m.db.QuotePrefixTableName(table[0]), m.db.QuoteWord(table[1]), table[2],
+			joinStr, m.db.QuoteWord(table[1]), table[2],
 		)
 	} else if len(table) == 2 {
 		model.tables += fmt.Sprintf(
 			" LEFT JOIN %s ON (%s)",
-			m.db.QuotePrefixTableName(table[0]), table[1],
+			joinStr, table[1],
+		)
+	} else if len(table) == 1 {
+		model.tables += fmt.Sprintf(
+			" LEFT JOIN %s",
+			joinStr,
 		)
-	} else {
-		panic("invalid join table parameter")
 	}
 	return model
 }
@@ -37,19 +64,32 @@ func (m *Model) LeftJoin(table ...string) *Model {
 // Table("user").RightJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").RightJoin("user_detail", "ud", "ud.uid=u.uid")
 func (m *Model) RightJoin(table ...string) *Model {
-	model := m.getModel()
+	var (
+		model   = m.getModel()
+		joinStr = ""
+	)
+	if len(table) > 0 {
+		if isSubQuery(table[0]) {
+			joinStr = "(" + table[0] + ")"
+		} else {
+			joinStr = m.db.QuotePrefixTableName(table[0])
+		}
+	}
 	if len(table) > 2 {
 		model.tables += fmt.Sprintf(
 			" RIGHT JOIN %s AS %s ON (%s)",
-			m.db.QuotePrefixTableName(table[0]), m.db.QuoteWord(table[1]), table[2],
+			joinStr, m.db.QuoteWord(table[1]), table[2],
 		)
 	} else if len(table) == 2 {
 		model.tables += fmt.Sprintf(
 			" RIGHT JOIN %s ON (%s)",
-			m.db.QuotePrefixTableName(table[0]), table[1],
+			joinStr, table[1],
+		)
+	} else if len(table) == 1 {
+		model.tables += fmt.Sprintf(
+			" RIGHT JOIN %s",
+			joinStr,
 		)
-	} else {
-		panic("invalid join table parameter")
 	}
 	return model
 }
@@ -60,19 +100,32 @@ func (m *Model) RightJoin(table ...string) *Model {
 // Table("user").InnerJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").InnerJoin("user_detail", "ud", "ud.uid=u.uid")
 func (m *Model) InnerJoin(table ...string) *Model {
-	model := m.getModel()
+	var (
+		model   = m.getModel()
+		joinStr = ""
+	)
+	if len(table) > 0 {
+		if isSubQuery(table[0]) {
+			joinStr = "(" + table[0] + ")"
+		} else {
+			joinStr = m.db.QuotePrefixTableName(table[0])
+		}
+	}
 	if len(table) > 2 {
 		model.tables += fmt.Sprintf(
 			" INNER JOIN %s AS %s ON (%s)",
-			m.db.QuotePrefixTableName(table[0]), m.db.QuoteWord(table[1]), table[2],
+			joinStr, m.db.QuoteWord(table[1]), table[2],
 		)
 	} else if len(table) == 2 {
 		model.tables += fmt.Sprintf(
 			" INNER JOIN %s ON (%s)",
-			m.db.QuotePrefixTableName(table[0]), table[1],
+			joinStr, table[1],
+		)
+	} else if len(table) == 1 {
+		model.tables += fmt.Sprintf(
+			" INNER JOIN %s",
+			joinStr,
 		)
-	} else {
-		panic("invalid join table parameter")
 	}
 	return model
 }

database/gdb/gdb_model_select.go

@@ -8,7 +8,10 @@ package gdb
 
 import (
 	"fmt"
+	"github.com/gogf/gf/container/gset"
 	"github.com/gogf/gf/container/gvar"
+	"github.com/gogf/gf/internal/json"
+	"github.com/gogf/gf/text/gstr"
 	"github.com/gogf/gf/util/gconv"
 	"reflect"
 )
@@ -53,12 +56,13 @@ func (m *Model) doGetAll(limit1 bool, where ...interface{}) (Result, error) {
 		}
 		conditionWhere += softDeletingCondition
 	}
+
 	// DO NOT quote the m.fields where, in case of fields like:
 	// DISTINCT t.user_id uid
 	return m.doGetAllBySql(
 		fmt.Sprintf(
 			"SELECT %s FROM %s%s",
-			m.fields,
+			m.getFieldsFiltered(),
 			m.tables,
 			conditionWhere+conditionExtra,
 		),
@@ -66,6 +70,53 @@ func (m *Model) doGetAll(limit1 bool, where ...interface{}) (Result, error) {
 	)
 }
 
+// getFieldsFiltered checks the fields and fieldsEx attributes, filters and returns the fields that will
+// really be committed to underlying database driver.
+func (m *Model) getFieldsFiltered() string {
+	if m.fieldsEx == "" {
+		// No filtering.
+		return m.fields
+	}
+	var (
+		fieldsArray []string
+		fieldsExSet = gset.NewStrSetFrom(gstr.SplitAndTrim(m.fieldsEx, ","))
+	)
+	if m.fields != "*" {
+		// Filter custom fields with fieldEx.
+		fieldsArray = make([]string, 0, 8)
+		for _, v := range gstr.SplitAndTrim(m.fields, ",") {
+			fieldsArray = append(fieldsArray, v[gstr.PosR(v, "-")+1:])
+		}
+	} else {
+		if gstr.Contains(m.tables, " ") {
+			panic("function FieldsEx supports only single table operations")
+		}
+		// Filter table fields with fieldEx.
+		tableFields, err := m.db.TableFields(m.tables)
+		if err != nil {
+			panic(err)
+		}
+		if len(tableFields) == 0 {
+			panic(fmt.Sprintf(`empty table fields for table "%s"`, m.tables))
+		}
+		fieldsArray = make([]string, len(tableFields))
+		for k, v := range tableFields {
+			fieldsArray[v.Index] = k
+		}
+	}
+	newFields := ""
+	for _, k := range fieldsArray {
+		if fieldsExSet.Contains(k) {
+			continue
+		}
+		if len(newFields) > 0 {
+			newFields += ","
+		}
+		newFields += k
+	}
+	return newFields
+}
+
 // Chunk iterates the query result with given size and callback function.
 func (m *Model) Chunk(limit int, callback func(result Result, err error) bool) {
 	page := m.start
@@ -381,23 +432,35 @@ func (m *Model) FindScan(pointer interface{}, where ...interface{}) error {
 // doGetAllBySql does the select statement on the database.
 func (m *Model) doGetAllBySql(sql string, args ...interface{}) (result Result, err error) {
 	cacheKey := ""
+	cacheObj := m.db.GetCache()
 	// Retrieve from cache.
 	if m.cacheEnabled && m.tx == nil {
 		cacheKey = m.cacheName
 		if len(cacheKey) == 0 {
-			cacheKey = sql + "/" + gconv.String(args)
+			cacheKey = sql + ", @PARAMS:" + gconv.String(args)
 		}
-		if v := m.db.GetCache().Get(cacheKey); v != nil {
-			return v.(Result), nil
+		if v, _ := cacheObj.GetVar(cacheKey); !v.IsNil() {
+			if result, ok := v.Val().(Result); ok {
+				// In-memory cache.
+				return result, nil
+			} else {
+				// Other cache, it needs conversion.
+				var result Result
+				if err = json.Unmarshal(v.Bytes(), &result); err != nil {
+					return nil, err
+				} else {
+					return result, nil
+				}
+			}
 		}
 	}
 	result, err = m.db.DoGetAll(m.getLink(false), sql, m.mergeArguments(args)...)
 	// Cache the result.
 	if cacheKey != "" && err == nil {
 		if m.cacheDuration < 0 {
-			m.db.GetCache().Remove(cacheKey)
+			cacheObj.Remove(cacheKey)
 		} else {
-			m.db.GetCache().Set(cacheKey, result, m.cacheDuration)
+			cacheObj.Set(cacheKey, result, m.cacheDuration)
 		}
 	}
 	return result, err

database/gdb/gdb_model_soft_time.go

@@ -15,58 +15,82 @@ import (
 	"github.com/gogf/gf/util/gutil"
 )
 
-const (
-	gSOFT_FIELD_NAME_CREATE = "create_at"
-	gSOFT_FIELD_NAME_UPDATE = "update_at"
-	gSOFT_FIELD_NAME_DELETE = "delete_at"
+var (
+	createdFiledNames = []string{"created_at", "create_at"} // Default filed names of table for automatic-filled created datetime.
+	updatedFiledNames = []string{"updated_at", "update_at"} // Default filed names of table for automatic-filled updated datetime.
+	deletedFiledNames = []string{"deleted_at", "delete_at"} // Default filed names of table for automatic-filled deleted datetime.
 )
 
+// Unscoped disables the auto-update time feature for insert, update and delete options.
+func (m *Model) Unscoped() *Model {
+	model := m.getModel()
+	model.unscoped = true
+	return model
+}
+
 // getSoftFieldNameCreate checks and returns the field name for record creating time.
 // If there's no field name for storing creating time, it returns an empty string.
 // It checks the key with or without cases or chars '-'/'_'/'.'/' '.
-func (m *Model) getSoftFieldNameCreate(table ...string) string {
+func (m *Model) getSoftFieldNameCreated(table ...string) string {
 	tableName := ""
 	if len(table) > 0 {
 		tableName = table[0]
 	} else {
 		tableName = m.getPrimaryTableName()
 	}
-	return m.getSoftFieldName(tableName, gSOFT_FIELD_NAME_CREATE)
+	config := m.db.GetConfig()
+	if config.CreatedAt != "" {
+		return m.getSoftFieldName(tableName, append([]string{config.CreatedAt}, createdFiledNames...))
+	}
+	return m.getSoftFieldName(tableName, createdFiledNames)
 }
 
 // getSoftFieldNameUpdate checks and returns the field name for record updating time.
 // If there's no field name for storing updating time, it returns an empty string.
 // It checks the key with or without cases or chars '-'/'_'/'.'/' '.
-func (m *Model) getSoftFieldNameUpdate(table ...string) (field string) {
+func (m *Model) getSoftFieldNameUpdated(table ...string) (field string) {
 	tableName := ""
 	if len(table) > 0 {
 		tableName = table[0]
 	} else {
 		tableName = m.getPrimaryTableName()
 	}
-	return m.getSoftFieldName(tableName, gSOFT_FIELD_NAME_UPDATE)
+	config := m.db.GetConfig()
+	if config.UpdatedAt != "" {
+		return m.getSoftFieldName(tableName, append([]string{config.UpdatedAt}, updatedFiledNames...))
+	}
+	return m.getSoftFieldName(tableName, updatedFiledNames)
 }
 
 // getSoftFieldNameDelete checks and returns the field name for record deleting time.
 // If there's no field name for storing deleting time, it returns an empty string.
 // It checks the key with or without cases or chars '-'/'_'/'.'/' '.
-func (m *Model) getSoftFieldNameDelete(table ...string) (field string) {
+func (m *Model) getSoftFieldNameDeleted(table ...string) (field string) {
 	tableName := ""
 	if len(table) > 0 {
 		tableName = table[0]
 	} else {
 		tableName = m.getPrimaryTableName()
 	}
-	return m.getSoftFieldName(tableName, gSOFT_FIELD_NAME_DELETE)
+	config := m.db.GetConfig()
+	if config.UpdatedAt != "" {
+		return m.getSoftFieldName(tableName, append([]string{config.DeletedAt}, deletedFiledNames...))
+	}
+	return m.getSoftFieldName(tableName, deletedFiledNames)
 }
 
 // getSoftFieldName retrieves and returns the field name of the table for possible key.
-func (m *Model) getSoftFieldName(table string, key string) (field string) {
+func (m *Model) getSoftFieldName(table string, keys []string) (field string) {
 	fieldsMap, _ := m.db.TableFields(table)
 	if len(fieldsMap) > 0 {
-		field, _ = gutil.MapPossibleItemByKey(
-			gconv.Map(fieldsMap), key,
-		)
+		for _, key := range keys {
+			field, _ = gutil.MapPossibleItemByKey(
+				gconv.Map(fieldsMap), key,
+			)
+			if field != "" {
+				return
+			}
+		}
 	}
 	return
 }
@@ -86,8 +110,8 @@ func (m *Model) getConditionForSoftDeleting() string {
 		// Base table.
 		match, _ := gregex.MatchString(`(.+?) [A-Z]+ JOIN`, m.tables)
 		conditionArray.Append(m.getConditionOfTableStringForSoftDeleting(match[1]))
-		// Multiple joined tables.
-		matches, _ := gregex.MatchAllString(`JOIN (.+?) ON`, m.tables)
+		// Multiple joined tables, exclude the sub query sql which contains char '(' and ')'.
+		matches, _ := gregex.MatchAllString(`JOIN ([^()]+?) ON`, m.tables)
 		for _, match := range matches {
 			conditionArray.Append(m.getConditionOfTableStringForSoftDeleting(match[1]))
 		}
@@ -103,7 +127,7 @@ func (m *Model) getConditionForSoftDeleting() string {
 		return conditionArray.Join(" AND ")
 	}
 	// Only one table.
-	if fieldName := m.getSoftFieldNameDelete(); fieldName != "" {
+	if fieldName := m.getSoftFieldNameDeleted(); fieldName != "" {
 		return fmt.Sprintf(`%s IS NULL`, m.db.QuoteWord(fieldName))
 	}
 	return ""
@@ -122,7 +146,7 @@ func (m *Model) getConditionOfTableStringForSoftDeleting(s string) string {
 	} else {
 		table = array2[0]
 	}
-	field = m.getSoftFieldNameDelete(table)
+	field = m.getSoftFieldNameDeleted(table)
 	if field == "" {
 		return ""
 	}

database/gdb/gdb_model_update.go

@@ -42,9 +42,9 @@ func (m *Model) Update(dataAndWhere ...interface{}) (result sql.Result, err erro
 	}
 	var (
 		updateData                                    = m.data
-		fieldNameCreate                               = m.getSoftFieldNameCreate()
-		fieldNameUpdate                               = m.getSoftFieldNameUpdate()
-		fieldNameDelete                               = m.getSoftFieldNameDelete()
+		fieldNameCreate                               = m.getSoftFieldNameCreated()
+		fieldNameUpdate                               = m.getSoftFieldNameUpdated()
+		fieldNameDelete                               = m.getSoftFieldNameDeleted()
 		conditionWhere, conditionExtra, conditionArgs = m.formatCondition(false)
 	)
 	// Automatically update the record updating time.
@@ -59,7 +59,7 @@ func (m *Model) Update(dataAndWhere ...interface{}) (result sql.Result, err erro
 		}
 		switch refKind {
 		case reflect.Map, reflect.Struct:
-			dataMap := DataToMapDeep(m.data)
+			dataMap := ConvertDataForTableRecord(m.data)
 			gutil.MapDelete(dataMap, fieldNameCreate, fieldNameUpdate, fieldNameDelete)
 			if fieldNameUpdate != "" {
 				dataMap[fieldNameUpdate] = gtime.Now().String()
@@ -73,10 +73,14 @@ func (m *Model) Update(dataAndWhere ...interface{}) (result sql.Result, err erro
 			updateData = updates
 		}
 	}
+	newData, err := m.filterDataForInsertOrUpdate(updateData)
+	if err != nil {
+		return nil, err
+	}
 	return m.db.DoUpdate(
 		m.getLink(true),
 		m.tables,
-		m.filterDataForInsertOrUpdate(updateData),
+		newData,
 		conditionWhere+conditionExtra,
 		m.mergeArguments(conditionArgs)...,
 	)

database/gdb/gdb_model_utility.go

@@ -28,27 +28,33 @@ func (m *Model) getModel() *Model {
 
 // filterDataForInsertOrUpdate does filter feature with data for inserting/updating operations.
 // Note that, it does not filter list item, which is also type of map, for "omit empty" feature.
-func (m *Model) filterDataForInsertOrUpdate(data interface{}) interface{} {
+func (m *Model) filterDataForInsertOrUpdate(data interface{}) (interface{}, error) {
+	var err error
 	switch value := data.(type) {
 	case List:
 		for k, item := range value {
-			value[k] = m.doFilterDataMapForInsertOrUpdate(item, false)
+			value[k], err = m.doMappingAndFilterForInsertOrUpdateDataMap(item, false)
+			if err != nil {
+				return nil, err
+			}
 		}
-		return value
+		return value, nil
 
 	case Map:
-		return m.doFilterDataMapForInsertOrUpdate(value, true)
+		return m.doMappingAndFilterForInsertOrUpdateDataMap(value, true)
 
 	default:
-		return data
+		return data, nil
 	}
 }
 
-// doFilterDataMapForInsertOrUpdate does the filter features for map.
+// doMappingAndFilterForInsertOrUpdateDataMap does the filter features for map.
 // Note that, it does not filter list item, which is also type of map, for "omit empty" feature.
-func (m *Model) doFilterDataMapForInsertOrUpdate(data Map, allowOmitEmpty bool) Map {
-	if m.filter {
-		data = m.db.filterFields(m.schema, m.tables, data)
+func (m *Model) doMappingAndFilterForInsertOrUpdateDataMap(data Map, allowOmitEmpty bool) (Map, error) {
+	var err error
+	data, err = m.db.mappingAndFilterData(m.schema, m.tables, data, m.filter)
+	if err != nil {
+		return nil, err
 	}
 	// Remove key-value pairs of which the value is empty.
 	if allowOmitEmpty && m.option&OPTION_OMITEMPTY > 0 {
@@ -103,7 +109,7 @@ func (m *Model) doFilterDataMapForInsertOrUpdate(data Map, allowOmitEmpty bool)
 			delete(data, v)
 		}
 	}
-	return data
+	return data, nil
 }
 
 // getLink returns the underlying database link object with configured <linkType> attribute.

database/gdb/gdb_structure.go

@@ -1,147 +0,0 @@
-// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package gdb
-
-import (
-	"strings"
-
-	"github.com/gogf/gf/text/gstr"
-
-	"github.com/gogf/gf/os/gtime"
-
-	"github.com/gogf/gf/encoding/gbinary"
-
-	"github.com/gogf/gf/text/gregex"
-	"github.com/gogf/gf/util/gconv"
-)
-
-// convertValue automatically checks and converts field value from database type
-// to golang variable type.
-func (c *Core) convertValue(fieldValue []byte, fieldType string) interface{} {
-	t, _ := gregex.ReplaceString(`\(.+\)`, "", fieldType)
-	t = strings.ToLower(t)
-	switch t {
-	case
-		"binary",
-		"varbinary",
-		"blob",
-		"tinyblob",
-		"mediumblob",
-		"longblob":
-		return fieldValue
-
-	case
-		"int",
-		"tinyint",
-		"small_int",
-		"smallint",
-		"medium_int",
-		"mediumint",
-		"serial":
-		if gstr.ContainsI(fieldType, "unsigned") {
-			gconv.Uint(string(fieldValue))
-		}
-		return gconv.Int(string(fieldValue))
-
-	case
-		"big_int",
-		"bigint",
-		"bigserial":
-		if gstr.ContainsI(fieldType, "unsigned") {
-			gconv.Uint64(string(fieldValue))
-		}
-		return gconv.Int64(string(fieldValue))
-
-	case "real":
-		return gconv.Float32(string(fieldValue))
-
-	case
-		"float",
-		"double",
-		"decimal",
-		"money",
-		"numeric",
-		"smallmoney":
-		return gconv.Float64(string(fieldValue))
-
-	case "bit":
-		s := string(fieldValue)
-		// mssql is true|false string.
-		if strings.EqualFold(s, "true") {
-			return 1
-		}
-		if strings.EqualFold(s, "false") {
-			return 0
-		}
-		return gbinary.BeDecodeToInt64(fieldValue)
-
-	case "bool":
-		return gconv.Bool(fieldValue)
-
-	case "date":
-		t, _ := gtime.StrToTime(string(fieldValue))
-		return t.Format("Y-m-d")
-
-	case
-		"datetime",
-		"timestamp":
-		t, _ := gtime.StrToTime(string(fieldValue))
-		return t.String()
-
-	default:
-		// Auto detect field type, using key match.
-		switch {
-		case strings.Contains(t, "text") || strings.Contains(t, "char") || strings.Contains(t, "character"):
-			return string(fieldValue)
-
-		case strings.Contains(t, "float") || strings.Contains(t, "double") || strings.Contains(t, "numeric"):
-			return gconv.Float64(string(fieldValue))
-
-		case strings.Contains(t, "bool"):
-			return gconv.Bool(string(fieldValue))
-
-		case strings.Contains(t, "binary") || strings.Contains(t, "blob"):
-			return fieldValue
-
-		case strings.Contains(t, "int"):
-			return gconv.Int(string(fieldValue))
-
-		case strings.Contains(t, "time"):
-			s := string(fieldValue)
-			t, err := gtime.StrToTime(s)
-			if err != nil {
-				return s
-			}
-			return t.String()
-
-		case strings.Contains(t, "date"):
-			s := string(fieldValue)
-			t, err := gtime.StrToTime(s)
-			if err != nil {
-				return s
-			}
-			return t.Format("Y-m-d")
-
-		default:
-			return string(fieldValue)
-		}
-	}
-}
-
-// filterFields removes all key-value pairs which are not the field of given table.
-func (c *Core) filterFields(schema, table string, data map[string]interface{}) map[string]interface{} {
-	// It must use data copy here to avoid its changing the origin data map.
-	newDataMap := make(map[string]interface{}, len(data))
-	if fields, err := c.DB.TableFields(table, schema); err == nil {
-		for k, v := range data {
-			if _, ok := fields[k]; ok {
-				newDataMap[k] = v
-			}
-		}
-	}
-	return newDataMap
-}

database/gdb/gdb_transaction.go

@@ -115,7 +115,6 @@ func (tx *TX) GetScan(objPointer interface{}, sql string, args ...interface{}) e
 	default:
 		return fmt.Errorf("element type should be type of struct/slice, unsupported: %v", k)
 	}
-	return nil
 }
 
 // GetValue queries and returns the field value from database.
@@ -154,7 +153,10 @@ func (tx *TX) GetCount(sql string, args ...interface{}) (int, error) {
 //
 // The parameter <batch> specifies the batch operation count when given data is slice.
 func (tx *TX) Insert(table string, data interface{}, batch ...int) (sql.Result, error) {
-	return tx.db.DoInsert(tx.tx, table, data, gINSERT_OPTION_DEFAULT, batch...)
+	if len(batch) > 0 {
+		return tx.Model(table).Data(data).Batch(batch[0]).Insert()
+	}
+	return tx.Model(table).Data(data).Insert()
 }
 
 // InsertIgnore does "INSERT IGNORE INTO ..." statement for the table.
@@ -167,7 +169,10 @@ func (tx *TX) Insert(table string, data interface{}, batch ...int) (sql.Result,
 //
 // The parameter <batch> specifies the batch operation count when given data is slice.
 func (tx *TX) InsertIgnore(table string, data interface{}, batch ...int) (sql.Result, error) {
-	return tx.db.DoInsert(tx.tx, table, data, gINSERT_OPTION_IGNORE, batch...)
+	if len(batch) > 0 {
+		return tx.Model(table).Data(data).Batch(batch[0]).InsertIgnore()
+	}
+	return tx.Model(table).Data(data).InsertIgnore()
 }
 
 // Replace does "REPLACE INTO ..." statement for the table.
@@ -183,7 +188,10 @@ func (tx *TX) InsertIgnore(table string, data interface{}, batch ...int) (sql.Re
 // If given data is type of slice, it then does batch replacing, and the optional parameter
 // <batch> specifies the batch operation count.
 func (tx *TX) Replace(table string, data interface{}, batch ...int) (sql.Result, error) {
-	return tx.db.DoInsert(tx.tx, table, data, gINSERT_OPTION_REPLACE, batch...)
+	if len(batch) > 0 {
+		return tx.Model(table).Data(data).Batch(batch[0]).Replace()
+	}
+	return tx.Model(table).Data(data).Replace()
 }
 
 // Save does "INSERT INTO ... ON DUPLICATE KEY UPDATE..." statement for the table.
@@ -198,31 +206,46 @@ func (tx *TX) Replace(table string, data interface{}, batch ...int) (sql.Result,
 // If given data is type of slice, it then does batch saving, and the optional parameter
 // <batch> specifies the batch operation count.
 func (tx *TX) Save(table string, data interface{}, batch ...int) (sql.Result, error) {
-	return tx.db.DoInsert(tx.tx, table, data, gINSERT_OPTION_SAVE, batch...)
+	if len(batch) > 0 {
+		return tx.Model(table).Data(data).Batch(batch[0]).Save()
+	}
+	return tx.Model(table).Data(data).Save()
 }
 
 // BatchInsert batch inserts data.
 // The parameter <list> must be type of slice of map or struct.
 func (tx *TX) BatchInsert(table string, list interface{}, batch ...int) (sql.Result, error) {
-	return tx.db.DoBatchInsert(tx.tx, table, list, gINSERT_OPTION_DEFAULT, batch...)
+	if len(batch) > 0 {
+		return tx.Model(table).Data(list).Batch(batch[0]).Insert()
+	}
+	return tx.Model(table).Data(list).Insert()
 }
 
 // BatchInsert batch inserts data with ignore option.
 // The parameter <list> must be type of slice of map or struct.
 func (tx *TX) BatchInsertIgnore(table string, list interface{}, batch ...int) (sql.Result, error) {
-	return tx.db.DoBatchInsert(tx.tx, table, list, gINSERT_OPTION_IGNORE, batch...)
+	if len(batch) > 0 {
+		return tx.Model(table).Data(list).Batch(batch[0]).InsertIgnore()
+	}
+	return tx.Model(table).Data(list).InsertIgnore()
 }
 
 // BatchReplace batch replaces data.
 // The parameter <list> must be type of slice of map or struct.
 func (tx *TX) BatchReplace(table string, list interface{}, batch ...int) (sql.Result, error) {
-	return tx.db.DoBatchInsert(tx.tx, table, list, gINSERT_OPTION_REPLACE, batch...)
+	if len(batch) > 0 {
+		return tx.Model(table).Data(list).Batch(batch[0]).Replace()
+	}
+	return tx.Model(table).Data(list).Replace()
 }
 
 // BatchSave batch replaces data.
 // The parameter <list> must be type of slice of map or struct.
 func (tx *TX) BatchSave(table string, list interface{}, batch ...int) (sql.Result, error) {
-	return tx.db.DoBatchInsert(tx.tx, table, list, gINSERT_OPTION_SAVE, batch...)
+	if len(batch) > 0 {
+		return tx.Model(table).Data(list).Batch(batch[0]).Save()
+	}
+	return tx.Model(table).Data(list).Save()
 }
 
 // Update does "UPDATE ... " statement for the table.
@@ -240,11 +263,7 @@ func (tx *TX) BatchSave(table string, list interface{}, batch ...int) (sql.Resul
 // "age IN(?,?)", 18, 50
 // User{ Id : 1, UserName : "john"}
 func (tx *TX) Update(table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error) {
-	newWhere, newArgs := formatWhere(tx.db, condition, args, false)
-	if newWhere != "" {
-		newWhere = " WHERE " + newWhere
-	}
-	return tx.db.DoUpdate(tx.tx, table, data, newWhere, newArgs...)
+	return tx.Model(table).Data(data).Where(condition, args...).Update()
 }
 
 // Delete does "DELETE FROM ... " statement for the table.
@@ -259,9 +278,5 @@ func (tx *TX) Update(table string, data interface{}, condition interface{}, args
 // "age IN(?,?)", 18, 50
 // User{ Id : 1, UserName : "john"}
 func (tx *TX) Delete(table string, condition interface{}, args ...interface{}) (sql.Result, error) {
-	newWhere, newArgs := formatWhere(tx.db, condition, args, false)
-	if newWhere != "" {
-		newWhere = " WHERE " + newWhere
-	}
-	return tx.db.DoDelete(tx.tx, table, newWhere, newArgs...)
+	return tx.Model(table).Where(condition, args...).Delete()
 }

database/gdb/gdb_type_result_scanlist.go

@@ -32,11 +32,15 @@ import (
 // ScanList(&users, "User")
 // ScanList(&users, "UserDetail", "User", "uid:Uid")
 // ScanList(&users, "UserScores", "User", "uid:Uid")
+//
 // The parameters "User"/"UserDetail"/"UserScores" in the example codes specify the target attribute struct
 // that current result will be bound to.
+//
 // The "uid" in the example codes is the table field name of the result, and the "Uid" is the relational
-// struct attribute name. It automatically calculates the HasOne/HasMany relationship with given <relation>
-// parameter.
+// struct attribute name - not the attribute name of the bound to target. In the example codes, it's attribute
+// name "Uid" of "User" of entity "Entity". It automatically calculates the HasOne/HasMany relationship with
+// given <relation> parameter.
+//
 // See the example or unit testing cases for clear understanding for this function.
 func (r Result) ScanList(listPointer interface{}, attributeName string, relation ...string) (err error) {
 	// Necessary checks for parameters.
@@ -177,7 +181,7 @@ func (r Result) ScanList(listPointer interface{}, attributeName string, relation
 			}
 		}
 		if len(relationDataMap) > 0 && !relationValue.IsValid() {
-			return fmt.Errorf(`invalid relation: %s, %s`, relation[0], relation[1])
+			return fmt.Errorf(`invalid relation: "%s:%s"`, relation[0], relation[1])
 		}
 		switch attrKind {
 		case reflect.Array, reflect.Slice:
@@ -192,7 +196,7 @@ func (r Result) ScanList(listPointer interface{}, attributeName string, relation
 					}
 				} else {
 					// May be the attribute does not exist yet.
-					return fmt.Errorf(`invalid relation: %s, %s`, relation[0], relation[1])
+					return fmt.Errorf(`invalid relation: "%s:%s"`, relation[0], relation[1])
 				}
 			} else {
 				return fmt.Errorf(`relationKey should not be empty as field "%s" is slice`, attributeName)
@@ -203,15 +207,25 @@ func (r Result) ScanList(listPointer interface{}, attributeName string, relation
 			if len(relationDataMap) > 0 {
 				relationField = relationValue.FieldByName(relationAttrName)
 				if relationField.IsValid() {
-					if err = gconv.Struct(relationDataMap[gconv.String(relationField.Interface())], e); err != nil {
+					v := relationDataMap[gconv.String(relationField.Interface())]
+					if v == nil {
+						// There's no relational data.
+						continue
+					}
+					if err = gconv.Struct(v, e); err != nil {
 						return err
 					}
 				} else {
 					// May be the attribute does not exist yet.
-					return fmt.Errorf(`invalid relation: %s, %s`, relation[0], relation[1])
+					return fmt.Errorf(`invalid relation: "%s:%s"`, relation[0], relation[1])
 				}
 			} else {
-				if err = gconv.Struct(r[i], e); err != nil {
+				v := r[i]
+				if v == nil {
+					// There's no relational data.
+					continue
+				}
+				if err = gconv.Struct(v, e); err != nil {
 					return err
 				}
 			}
@@ -222,15 +236,25 @@ func (r Result) ScanList(listPointer interface{}, attributeName string, relation
 			if len(relationDataMap) > 0 {
 				relationField = relationValue.FieldByName(relationAttrName)
 				if relationField.IsValid() {
-					if err = gconv.Struct(relationDataMap[gconv.String(relationField.Interface())], e); err != nil {
+					v := relationDataMap[gconv.String(relationField.Interface())]
+					if v == nil {
+						// There's no relational data.
+						continue
+					}
+					if err = gconv.Struct(v, e); err != nil {
 						return err
 					}
 				} else {
 					// May be the attribute does not exist yet.
-					return fmt.Errorf(`invalid relation: %s, %s`, relation[0], relation[1])
+					return fmt.Errorf(`invalid relation: "%s:%s"`, relation[0], relation[1])
 				}
 			} else {
-				if err = gconv.Struct(r[i], e); err != nil {
+				v := r[i]
+				if v == nil {
+					// There's no relational data.
+					continue
+				}
+				if err = gconv.Struct(v, e); err != nil {
 					return err
 				}
 			}

database/gdb/gdb_z_mysql_association_test.go

@@ -17,7 +17,152 @@ import (
 	"github.com/gogf/gf/test/gtest"
 )
 
-func Test_Table_Relation(t *testing.T) {
+func Test_Table_Relation_One(t *testing.T) {
+	var (
+		tableUser       = "user_" + gtime.TimestampMicroStr()
+		tableUserDetail = "user_detail_" + gtime.TimestampMicroStr()
+		tableUserScores = "user_scores_" + gtime.TimestampMicroStr()
+	)
+	if _, err := db.Exec(fmt.Sprintf(`
+CREATE TABLE %s (
+  uid int(10) unsigned NOT NULL AUTO_INCREMENT,
+  name varchar(45) NOT NULL,
+  PRIMARY KEY (uid)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+    `, tableUser)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(tableUser)
+
+	if _, err := db.Exec(fmt.Sprintf(`
+CREATE TABLE %s (
+  uid int(10) unsigned NOT NULL AUTO_INCREMENT,
+  address varchar(45) NOT NULL,
+  PRIMARY KEY (uid)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+    `, tableUserDetail)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(tableUserDetail)
+
+	if _, err := db.Exec(fmt.Sprintf(`
+CREATE TABLE %s (
+  id int(10) unsigned NOT NULL AUTO_INCREMENT,
+  uid int(10) unsigned NOT NULL,
+  score int(10) unsigned NOT NULL,
+  course varchar(45) NOT NULL,
+  PRIMARY KEY (id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+    `, tableUserScores)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(tableUserScores)
+
+	type EntityUser struct {
+		Uid  int    `orm:"uid"`
+		Name string `orm:"name"`
+	}
+
+	type EntityUserDetail struct {
+		Uid     int    `orm:"uid"`
+		Address string `orm:"address"`
+	}
+
+	type EntityUserScores struct {
+		Id     int    `orm:"id"`
+		Uid    int    `orm:"uid"`
+		Score  int    `orm:"score"`
+		Course string `orm:"course"`
+	}
+
+	type Entity struct {
+		User       *EntityUser
+		UserDetail *EntityUserDetail
+		UserScores []*EntityUserScores
+	}
+
+	// Initialize the data.
+	var err error
+	gtest.C(t, func(t *gtest.T) {
+		err = db.Transaction(func(tx *gdb.TX) error {
+			r, err := tx.Table(tableUser).Save(EntityUser{
+				Name: "john",
+			})
+			if err != nil {
+				return err
+			}
+			uid, err := r.LastInsertId()
+			if err != nil {
+				return err
+			}
+			_, err = tx.Table(tableUserDetail).Save(EntityUserDetail{
+				Uid:     int(uid),
+				Address: "Beijing DongZhiMen #66",
+			})
+			if err != nil {
+				return err
+			}
+			_, err = tx.Table(tableUserScores).Save(g.Slice{
+				EntityUserScores{Uid: int(uid), Score: 100, Course: "math"},
+				EntityUserScores{Uid: int(uid), Score: 99, Course: "physics"},
+			})
+			return err
+		})
+		t.Assert(err, nil)
+	})
+	// Data check.
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.Table(tableUser).All()
+		t.Assert(err, nil)
+		t.Assert(r.Len(), 1)
+		t.Assert(r[0]["uid"].Int(), 1)
+		t.Assert(r[0]["name"].String(), "john")
+
+		r, err = db.Table(tableUserDetail).Where("uid", r[0]["uid"].Int()).All()
+		t.Assert(err, nil)
+		t.Assert(r.Len(), 1)
+		t.Assert(r[0]["uid"].Int(), 1)
+		t.Assert(r[0]["address"].String(), `Beijing DongZhiMen #66`)
+
+		r, err = db.Table(tableUserScores).Where("uid", r[0]["uid"].Int()).All()
+		t.Assert(err, nil)
+		t.Assert(r.Len(), 2)
+		t.Assert(r[0]["uid"].Int(), 1)
+		t.Assert(r[1]["uid"].Int(), 1)
+		t.Assert(r[0]["course"].String(), `math`)
+		t.Assert(r[1]["course"].String(), `physics`)
+	})
+	// Entity query.
+	gtest.C(t, func(t *gtest.T) {
+		var user Entity
+		// SELECT * FROM `user` WHERE `name`='john'
+		err := db.Table(tableUser).Scan(&user.User, "name", "john")
+		t.Assert(err, nil)
+
+		// SELECT * FROM `user_detail` WHERE `uid`=1
+		err = db.Table(tableUserDetail).Scan(&user.UserDetail, "uid", user.User.Uid)
+		t.Assert(err, nil)
+
+		// SELECT * FROM `user_scores` WHERE `uid`=1
+		err = db.Table(tableUserScores).Scan(&user.UserScores, "uid", user.User.Uid)
+		t.Assert(err, nil)
+
+		t.Assert(user.User, EntityUser{
+			Uid:  1,
+			Name: "john",
+		})
+		t.Assert(user.UserDetail, EntityUserDetail{
+			Uid:     1,
+			Address: "Beijing DongZhiMen #66",
+		})
+		t.Assert(user.UserScores, []EntityUserScores{
+			{Id: 1, Uid: 1, Course: "math", Score: 100},
+			{Id: 2, Uid: 1, Course: "physics", Score: 99},
+		})
+	})
+}
+
+func Test_Table_Relation_Many(t *testing.T) {
 	var (
 		tableUser       = "user_" + gtime.TimestampMicroStr()
 		tableUserDetail = "user_detail_" + gtime.TimestampMicroStr()

database/gdb/gdb_z_mysql_internal_test.go

@@ -8,6 +8,7 @@ package gdb
 
 import (
 	"fmt"
+	"github.com/go-sql-driver/mysql"
 	"github.com/gogf/gf/os/gcmd"
 	"github.com/gogf/gf/os/gtime"
 	"github.com/gogf/gf/test/gtest"
@@ -75,13 +76,13 @@ func Test_Func_FormatSqlWithArgs(t *testing.T) {
 	// mssql
 	gtest.C(t, func(t *gtest.T) {
 		var s string
-		s = FormatSqlWithArgs("select * from table where id>=@v1 and sex=@v2", []interface{}{100, 1})
+		s = FormatSqlWithArgs("select * from table where id>=@p1 and sex=@p2", []interface{}{100, 1})
 		t.Assert(s, "select * from table where id>=100 and sex=1")
 	})
 	// pgsql
 	gtest.C(t, func(t *gtest.T) {
 		var s string
-		s = FormatSqlWithArgs("select * from table where id>=$v1 and sex=$v2", []interface{}{100, 1})
+		s = FormatSqlWithArgs("select * from table where id>=$1 and sex=$2", []interface{}{100, 1})
 		t.Assert(s, "select * from table where id>=100 and sex=1")
 	})
 	// oracle
@@ -203,9 +204,9 @@ CREATE TABLE %s (
 
 	gtest.C(t, func(t *gtest.T) {
 		model := db.Table(table1)
-		gtest.Assert(model.getSoftFieldNameCreate(table2), "createat")
-		gtest.Assert(model.getSoftFieldNameUpdate(table2), "updateat")
-		gtest.Assert(model.getSoftFieldNameDelete(table2), "deleteat")
+		gtest.Assert(model.getSoftFieldNameCreated(table2), "createat")
+		gtest.Assert(model.getSoftFieldNameUpdated(table2), "updateat")
+		gtest.Assert(model.getSoftFieldNameDeleted(table2), "deleteat")
 	})
 }
 
@@ -289,3 +290,25 @@ CREATE TABLE %s (
 		)
 	})
 }
+
+// Fix issue: https://github.com/gogf/gf/issues/819
+func Test_Func_ConvertDataForTableRecord(t *testing.T) {
+	type Test struct {
+		ResetPasswordTokenAt mysql.NullTime `orm:"reset_password_token_at"`
+	}
+	gtest.C(t, func(t *gtest.T) {
+		m := ConvertDataForTableRecord(new(Test))
+		t.Assert(len(m), 1)
+		t.AssertNE(m["reset_password_token_at"], nil)
+		t.Assert(m["reset_password_token_at"], new(mysql.NullTime))
+	})
+}
+
+func Test_isSubQuery(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(isSubQuery("user"), false)
+		t.Assert(isSubQuery("user.uid"), false)
+		t.Assert(isSubQuery("u, user.uid"), false)
+		t.Assert(isSubQuery("select 1"), true)
+	})
+}

database/gdb/gdb_z_mysql_method_test.go

@@ -9,6 +9,7 @@ package gdb_test
 import (
 	"fmt"
 	"github.com/gogf/gf/container/garray"
+	"github.com/gogf/gf/encoding/gparser"
 	"testing"
 	"time"
 
@@ -183,6 +184,119 @@ func Test_DB_Insert(t *testing.T) {
 	})
 }
 
+// Fix issue: https://github.com/gogf/gf/issues/819
+func Test_DB_Insert_WithStructAndSliceAttribute(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type Password struct {
+			Salt string `json:"salt"`
+			Pass string `json:"pass"`
+		}
+		data := g.Map{
+			"id":          1,
+			"passport":    "t1",
+			"password":    &Password{"123", "456"},
+			"nickname":    []string{"A", "B", "C"},
+			"create_time": gtime.Now().String(),
+		}
+		_, err := db.Insert(table, data)
+		t.Assert(err, nil)
+
+		one, err := db.GetOne(fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1)
+		t.Assert(err, nil)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["create_time"], data["create_time"])
+		t.Assert(one["nickname"], gparser.MustToJson(data["nickname"]))
+	})
+}
+
+func Test_DB_Insert_KeyFieldNameMapping(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			Nickname   string
+			CreateTime string
+		}
+		data := User{
+			Id:         1,
+			Passport:   "user_1",
+			Password:   "pass_1",
+			Nickname:   "name_1",
+			CreateTime: "2020-10-10 12:00:01",
+		}
+		_, err := db.Insert(table, data)
+		t.Assert(err, nil)
+
+		one, err := db.GetOne(fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1)
+		t.Assert(err, nil)
+		t.Assert(one["passport"], data.Passport)
+		t.Assert(one["create_time"], data.CreateTime)
+		t.Assert(one["nickname"], data.Nickname)
+	})
+}
+
+func Test_DB_Upadte_KeyFieldNameMapping(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			Nickname   string
+			CreateTime string
+		}
+		data := User{
+			Id:         1,
+			Passport:   "user_10",
+			Password:   "pass_10",
+			Nickname:   "name_10",
+			CreateTime: "2020-10-10 12:00:01",
+		}
+		_, err := db.Update(table, data, "id=1")
+		t.Assert(err, nil)
+
+		one, err := db.GetOne(fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1)
+		t.Assert(err, nil)
+		t.Assert(one["passport"], data.Passport)
+		t.Assert(one["create_time"], data.CreateTime)
+		t.Assert(one["nickname"], data.Nickname)
+	})
+}
+
+func Test_DB_Insert_KeyFieldNameMapping_Error(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id             int
+			Passport       string
+			Password       string
+			Nickname       string
+			CreateTime     string
+			NoneExistField string
+		}
+		data := User{
+			Id:         1,
+			Passport:   "user_1",
+			Password:   "pass_1",
+			Nickname:   "name_1",
+			CreateTime: "2020-10-10 12:00:01",
+		}
+		_, err := db.Insert(table, data)
+		t.AssertNE(err, nil)
+	})
+}
+
 func Test_DB_InsertIgnore(t *testing.T) {
 	table := createInitTable()
 	defer dropTable(table)

database/gdb/gdb_z_mysql_model_test.go

@@ -11,6 +11,7 @@ import (
 	"fmt"
 	"github.com/gogf/gf/container/garray"
 	"github.com/gogf/gf/container/gmap"
+	"github.com/gogf/gf/encoding/gparser"
 	"github.com/gogf/gf/util/gutil"
 	"testing"
 	"time"
@@ -52,20 +53,20 @@ func Test_Model_Insert(t *testing.T) {
 		t.Assert(n, 1)
 
 		type User struct {
-			Id         int    `gconv:"id"`
-			Uid        int    `gconv:"uid"`
-			Passport   string `json:"passport"`
-			Password   string `gconv:"password"`
-			Nickname   string `gconv:"nickname"`
-			CreateTime string `json:"create_time"`
+			Id         int         `gconv:"id"`
+			Uid        int         `gconv:"uid"`
+			Passport   string      `json:"passport"`
+			Password   string      `gconv:"password"`
+			Nickname   string      `gconv:"nickname"`
+			CreateTime *gtime.Time `json:"create_time"`
 		}
+		// Model inserting.
 		result, err = db.Table(table).Filter().Data(User{
-			Id:         3,
-			Uid:        3,
-			Passport:   "t3",
-			Password:   "25d55ad283aa400af464c76d713c07ad",
-			Nickname:   "name_3",
-			CreateTime: gtime.Now().String(),
+			Id:       3,
+			Uid:      3,
+			Passport: "t3",
+			Password: "25d55ad283aa400af464c76d713c07ad",
+			Nickname: "name_3",
 		}).Insert()
 		t.Assert(err, nil)
 		n, _ = result.RowsAffected()
@@ -80,7 +81,7 @@ func Test_Model_Insert(t *testing.T) {
 			Passport:   "t4",
 			Password:   "25d55ad283aa400af464c76d713c07ad",
 			Nickname:   "T4",
-			CreateTime: gtime.Now().String(),
+			CreateTime: gtime.Now(),
 		}).Insert()
 		t.Assert(err, nil)
 		n, _ = result.RowsAffected()
@@ -94,7 +95,164 @@ func Test_Model_Insert(t *testing.T) {
 		n, _ = result.RowsAffected()
 		t.Assert(n, 3)
 	})
+}
 
+// Fix issue: https://github.com/gogf/gf/issues/819
+func Test_Model_Insert_WithStructAndSliceAttribute(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		type Password struct {
+			Salt string `json:"salt"`
+			Pass string `json:"pass"`
+		}
+		data := g.Map{
+			"id":          1,
+			"passport":    "t1",
+			"password":    &Password{"123", "456"},
+			"nickname":    []string{"A", "B", "C"},
+			"create_time": gtime.Now().String(),
+		}
+		_, err := db.Table(table).Data(data).Insert()
+		t.Assert(err, nil)
+
+		one, err := db.Table(table).One("id", 1)
+		t.Assert(err, nil)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["create_time"], data["create_time"])
+		t.Assert(one["nickname"], gparser.MustToJson(data["nickname"]))
+	})
+}
+
+func Test_Model_Insert_KeyFieldNameMapping(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			Nickname   string
+			CreateTime string
+		}
+		data := User{
+			Id:         1,
+			Passport:   "user_1",
+			Password:   "pass_1",
+			Nickname:   "name_1",
+			CreateTime: "2020-10-10 12:00:01",
+		}
+		_, err := db.Model(table).Data(data).Insert()
+		t.Assert(err, nil)
+
+		one, err := db.Model(table).FindOne(1)
+		t.Assert(err, nil)
+		t.Assert(one["passport"], data.Passport)
+		t.Assert(one["create_time"], data.CreateTime)
+		t.Assert(one["nickname"], data.Nickname)
+	})
+}
+
+func Test_Model_Update_KeyFieldNameMapping(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			Nickname   string
+			CreateTime string
+		}
+		data := User{
+			Id:         1,
+			Passport:   "user_10",
+			Password:   "pass_10",
+			Nickname:   "name_10",
+			CreateTime: "2020-10-10 12:00:01",
+		}
+		_, err := db.Model(table).Data(data).WherePri(1).Update()
+		t.Assert(err, nil)
+
+		one, err := db.Model(table).FindOne(1)
+		t.Assert(err, nil)
+		t.Assert(one["passport"], data.Passport)
+		t.Assert(one["create_time"], data.CreateTime)
+		t.Assert(one["nickname"], data.Nickname)
+	})
+}
+
+func Test_Model_Insert_KeyFieldNameMapping_Error(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id             int
+			Passport       string
+			Password       string
+			Nickname       string
+			CreateTime     string
+			NoneExistFiled string
+		}
+		data := User{
+			Id:         1,
+			Passport:   "user_1",
+			Password:   "pass_1",
+			Nickname:   "name_1",
+			CreateTime: "2020-10-10 12:00:01",
+		}
+		_, err := db.Model(table).Data(data).Insert()
+		t.AssertNE(err, nil)
+	})
+}
+
+func Test_Model_Insert_Time(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "t1",
+			"password":    "p1",
+			"nickname":    "n1",
+			"create_time": "2020-10-10 20:09:18.334",
+		}
+		_, err := db.Table(table).Data(data).Insert()
+		t.Assert(err, nil)
+
+		one, err := db.Table(table).One("id", 1)
+		t.Assert(err, nil)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["create_time"], "2020-10-10 20:09:18")
+		t.Assert(one["nickname"], data["nickname"])
+	})
+}
+
+func Test_Model_BatchInsertWithArrayStruct(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		user := db.Table(table)
+		array := garray.New()
+		for i := 1; i <= SIZE; i++ {
+			array.Append(g.Map{
+				"id":          i,
+				"uid":         i,
+				"passport":    fmt.Sprintf("t%d", i),
+				"password":    "25d55ad283aa400af464c76d713c07ad",
+				"nickname":    fmt.Sprintf("name_%d", i),
+				"create_time": gtime.Now().String(),
+			})
+		}
+
+		result, err := user.Filter().Data(array).Insert()
+		t.Assert(err, nil)
+		n, _ := result.LastInsertId()
+		t.Assert(n, SIZE)
+	})
 }
 
 func Test_Model_InsertIgnore(t *testing.T) {
@@ -2243,6 +2401,19 @@ func Test_Model_DryRun(t *testing.T) {
 	})
 }
 
+func Test_Model_Join_SubQuery(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		subQuery := fmt.Sprintf("select * from `%s`", table)
+		r, err := db.Table(table, "t1").Fields("t2.id").LeftJoin(subQuery, "t2", "t2.id=t1.id").Array()
+		t.Assert(err, nil)
+		t.Assert(len(r), SIZE)
+		t.Assert(r[0], "1")
+		t.Assert(r[SIZE-1], SIZE)
+	})
+}
+
 func Test_Model_Cache(t *testing.T) {
 	table := createInitTable()
 	defer dropTable(table)
@@ -2437,3 +2608,37 @@ func Test_Model_Empty_Slice_Argument(t *testing.T) {
 		t.Assert(len(result), 0)
 	})
 }
+
+func Test_Model_HasTable(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.HasTable(table)
+		t.Assert(result, true)
+		t.Assert(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.HasTable("table12321")
+		t.Assert(result, false)
+		t.Assert(err, nil)
+	})
+}
+
+func Test_Model_HasField(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Table(table).HasField("id")
+		t.Assert(result, true)
+		t.Assert(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Table(table).HasField("id123")
+		t.Assert(result, false)
+		t.Assert(err, nil)
+	})
+}

database/gdb/gdb_z_mysql_soft_time_test.go

@@ -151,7 +151,7 @@ CREATE TABLE %s (
 }
 
 func Test_SoftUpdateTime(t *testing.T) {
-	table := "time_test_table"
+	table := "time_test_table_" + gtime.TimestampNanoStr()
 	if _, err := db.Exec(fmt.Sprintf(`
 CREATE TABLE %s (
   id        int(11) NOT NULL,

database/gdb/gdb_z_mysql_transaction_test.go

@@ -764,3 +764,31 @@ func Test_Transaction(t *testing.T) {
 		}
 	})
 }
+
+func Test_Transaction_Panic(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		err := db.Transaction(func(tx *gdb.TX) error {
+			if _, err := tx.Replace(table, g.Map{
+				"id":          1,
+				"passport":    "USER_1",
+				"password":    "PASS_1",
+				"nickname":    "NAME_1",
+				"create_time": gtime.Now().String(),
+			}); err != nil {
+				t.Error(err)
+			}
+			panic("error")
+			return nil
+		})
+		t.AssertNE(err, nil)
+
+		if value, err := db.Table(table).Fields("nickname").Where("id", 1).Value(); err != nil {
+			gtest.Error(err)
+		} else {
+			t.Assert(value.String(), "name_1")
+		}
+	})
+}

database/gdb/gdb_z_mysql_types_test.go

@@ -16,7 +16,6 @@ import (
 )
 
 func Test_Types(t *testing.T) {
-
 	gtest.C(t, func(t *gtest.T) {
 		if _, err := db.Exec(fmt.Sprintf(`
     CREATE TABLE IF NOT EXISTS types (
@@ -32,8 +31,16 @@ func Test_Types(t *testing.T) {
         %s bool NOT NULL,
         PRIMARY KEY (id)
     ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-    `, "`blob`", "`binary`", "`date`", "`time`",
-			"`decimal`", "`double`", "`bit`", "`tinyint`", "`bool`")); err != nil {
+    `,
+			"`blob`",
+			"`binary`",
+			"`date`",
+			"`time`",
+			"`decimal`",
+			"`double`",
+			"`bit`",
+			"`tinyint`",
+			"`bool`")); err != nil {
 			gtest.Error(err)
 		}
 		defer dropTable("types")
@@ -41,7 +48,7 @@ func Test_Types(t *testing.T) {
 			"id":      1,
 			"blob":    "i love gf",
 			"binary":  []byte("abcdefgh"),
-			"date":    "2018-10-24",
+			"date":    "1880-10-24",
 			"time":    "10:00:01",
 			"decimal": -123.456,
 			"double":  -123.456,

database/gdb/gdb_z_oracle_internal_test.go

@@ -0,0 +1,49 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gdb
+
+import (
+	"github.com/gogf/gf/test/gtest"
+	"testing"
+)
+
+func Test_Oracle_parseSql(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		o := new(DriverOracle)
+		sql := `UPDATE user SET name='john'`
+		newSql := o.parseSql(sql)
+		t.Assert(newSql, sql)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		o := new(DriverOracle)
+		sql := `SELECT * FROM user`
+		newSql := o.parseSql(sql)
+		t.Assert(newSql, sql)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		o := new(DriverOracle)
+		sql := `SELECT * FROM user LIMIT 0, 10`
+		newSql := o.parseSql(sql)
+		t.Assert(newSql, `SELECT * FROM (SELECT GFORM.*, ROWNUM ROWNUM_ FROM (SELECT  * FROM user ) GFORM WHERE ROWNUM <= 10) WHERE ROWNUM_ >= 0`)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		o := new(DriverOracle)
+		sql := `SELECT * FROM user LIMIT 1`
+		newSql := o.parseSql(sql)
+		t.Assert(newSql, `SELECT * FROM (SELECT GFORM.*, ROWNUM ROWNUM_ FROM (SELECT  * FROM user ) GFORM WHERE ROWNUM <= 1) WHERE ROWNUM_ >= 0`)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		o := new(DriverOracle)
+		sql := `SELECT ENAME FROM USER_INFO WHERE ID=2 LIMIT 1`
+		newSql := o.parseSql(sql)
+		t.Assert(newSql, `SELECT * FROM (SELECT GFORM.*, ROWNUM ROWNUM_ FROM (SELECT  ENAME FROM USER_INFO WHERE ID=2 ) GFORM WHERE ROWNUM <= 1) WHERE ROWNUM_ >= 0`)
+	})
+}

database/gredis/gredis.go

@@ -15,7 +15,6 @@ package gredis
 
 import (
 	"fmt"
-	"github.com/gogf/gf/util/gconv"
 	"time"
 
 	"github.com/gogf/gf/container/gmap"
@@ -46,6 +45,8 @@ type Config struct {
 	IdleTimeout     time.Duration // Maximum idle time for connection (default is 10 seconds, not allowed to be set to 0)
 	MaxConnLifetime time.Duration // Maximum lifetime of the connection (default is 30 seconds, not allowed to be set to 0)
 	ConnectTimeout  time.Duration // Dial connection timeout.
+	TLS             bool          // Specifies the config to use when a TLS connection is dialed.
+	TLSSkipVerify   bool          // Disables server name verification when connecting over TLS
 }
 
 // Pool statistics.
@@ -102,6 +103,8 @@ func New(config Config) *Redis {
 						"tcp",
 						fmt.Sprintf("%s:%d", config.Host, config.Port),
 						redis.DialConnectTimeout(config.ConnectTimeout),
+						redis.DialUseTLS(config.TLS),
+						redis.DialTLSSkipVerify(config.TLSSkipVerify),
 					)
 					if err != nil {
 						return nil, err
@@ -163,6 +166,7 @@ func (r *Redis) Conn() *Conn {
 }
 
 // Alias of Conn, see Conn.
+// Deprecated.
 func (r *Redis) GetConn() *Conn {
 	return r.Conn()
 }
@@ -204,21 +208,27 @@ func (r *Redis) Stats() *PoolStats {
 // Do sends a command to the server and returns the received reply.
 // Do automatically get a connection from pool, and close it when the reply received.
 // It does not really "close" the connection, but drops it back to the connection pool.
-func (r *Redis) Do(command string, args ...interface{}) (interface{}, error) {
+func (r *Redis) Do(commandName string, args ...interface{}) (interface{}, error) {
 	conn := &Conn{r.pool.Get()}
 	defer conn.Close()
-	return conn.Do(command, args...)
+	return conn.Do(commandName, args...)
+}
+
+// DoWithTimeout sends a command to the server and returns the received reply.
+// The timeout overrides the read timeout set when dialing the connection.
+func (r *Redis) DoWithTimeout(timeout time.Duration, commandName string, args ...interface{}) (interface{}, error) {
+	conn := &Conn{r.pool.Get()}
+	defer conn.Close()
+	return conn.DoWithTimeout(timeout, commandName, args...)
 }
 
 // DoVar returns value from Do as gvar.Var.
-func (r *Redis) DoVar(command string, args ...interface{}) (*gvar.Var, error) {
-	v, err := r.Do(command, args...)
-	if result, ok := v.([]byte); ok {
-		return gvar.New(gconv.UnsafeBytesToStr(result)), err
-	}
-	// It treats all returned slice as string slice.
-	if result, ok := v.([]interface{}); ok {
-		return gvar.New(gconv.Strings(result)), err
-	}
-	return gvar.New(v), err
+func (r *Redis) DoVar(commandName string, args ...interface{}) (*gvar.Var, error) {
+	return resultToVar(r.Do(commandName, args...))
+}
+
+// DoVarWithTimeout returns value from Do as gvar.Var.
+// The timeout overrides the read timeout set when dialing the connection.
+func (r *Redis) DoVarWithTimeout(timeout time.Duration, commandName string, args ...interface{}) (*gvar.Var, error) {
+	return resultToVar(r.DoWithTimeout(timeout, commandName, args...))
 }

database/gredis/gredis_config.go

@@ -110,6 +110,12 @@ func ConfigFromStr(str string) (config Config, err error) {
 		if v, ok := parse["maxConnLifetime"]; ok {
 			config.MaxConnLifetime = gconv.Duration(v) * time.Second
 		}
+		if v, ok := parse["tls"]; ok {
+			config.TLS = gconv.Bool(v)
+		}
+		if v, ok := parse["skipVerify"]; ok {
+			config.TLSSkipVerify = gconv.Bool(v)
+		}
 		return
 	}
 	array, _ = gregex.MatchString(`([^:]+):*(\d*),{0,1}(\d*),{0,1}(.*)`, str)

database/gredis/gredis_conn.go

@@ -7,14 +7,19 @@
 package gredis
 
 import (
+	"errors"
 	"github.com/gogf/gf/container/gvar"
 	"github.com/gogf/gf/internal/json"
+	"github.com/gogf/gf/util/gconv"
+	"github.com/gomodule/redigo/redis"
 	"reflect"
+	"time"
 )
 
 // Do sends a command to the server and returns the received reply.
 // It uses json.Marshal for struct/slice/map type values before committing them to redis.
-func (c *Conn) Do(commandName string, args ...interface{}) (reply interface{}, err error) {
+// The timeout overrides the read timeout set when dialing the connection.
+func (c *Conn) do(timeout time.Duration, commandName string, args ...interface{}) (reply interface{}, err error) {
 	var (
 		reflectValue reflect.Value
 		reflectKind  reflect.Kind
@@ -40,17 +45,64 @@ func (c *Conn) Do(commandName string, args ...interface{}) (reply interface{}, e
 			}
 		}
 	}
+	if timeout > 0 {
+		conn, ok := c.Conn.(redis.ConnWithTimeout)
+		if !ok {
+			return gvar.New(nil), errors.New(`current connection does not support "ConnWithTimeout"`)
+		}
+		return conn.DoWithTimeout(timeout, commandName, args...)
+	}
 	return c.Conn.Do(commandName, args...)
 }
 
+// Do sends a command to the server and returns the received reply.
+// It uses json.Marshal for struct/slice/map type values before committing them to redis.
+func (c *Conn) Do(commandName string, args ...interface{}) (reply interface{}, err error) {
+	return c.do(0, commandName, args...)
+}
+
+// DoWithTimeout sends a command to the server and returns the received reply.
+// The timeout overrides the read timeout set when dialing the connection.
+func (c *Conn) DoWithTimeout(timeout time.Duration, commandName string, args ...interface{}) (reply interface{}, err error) {
+	return c.do(timeout, commandName, args...)
+}
+
 // DoVar retrieves and returns the result from command as gvar.Var.
-func (c *Conn) DoVar(command string, args ...interface{}) (*gvar.Var, error) {
-	v, err := c.Do(command, args...)
-	return gvar.New(v), err
+func (c *Conn) DoVar(commandName string, args ...interface{}) (*gvar.Var, error) {
+	return resultToVar(c.Do(commandName, args...))
+}
+
+// DoVarWithTimeout retrieves and returns the result from command as gvar.Var.
+// The timeout overrides the read timeout set when dialing the connection.
+func (c *Conn) DoVarWithTimeout(timeout time.Duration, commandName string, args ...interface{}) (*gvar.Var, error) {
+	return resultToVar(c.DoWithTimeout(timeout, commandName, args...))
 }
 
 // ReceiveVar receives a single reply as gvar.Var from the Redis server.
 func (c *Conn) ReceiveVar() (*gvar.Var, error) {
-	v, err := c.Receive()
-	return gvar.New(v), err
+	return resultToVar(c.Receive())
+}
+
+// ReceiveVarWithTimeout receives a single reply as gvar.Var from the Redis server.
+// The timeout overrides the read timeout set when dialing the connection.
+func (c *Conn) ReceiveVarWithTimeout(timeout time.Duration) (*gvar.Var, error) {
+	conn, ok := c.Conn.(redis.ConnWithTimeout)
+	if !ok {
+		return gvar.New(nil), errors.New(`current connection does not support "ConnWithTimeout"`)
+	}
+	return resultToVar(conn.ReceiveWithTimeout(timeout))
+}
+
+// resultToVar converts redis operation result to gvar.Var.
+func resultToVar(result interface{}, err error) (*gvar.Var, error) {
+	if err == nil {
+		if result, ok := result.([]byte); ok {
+			return gvar.New(gconv.UnsafeBytesToStr(result)), err
+		}
+		// It treats all returned slice as string slice.
+		if result, ok := result.([]interface{}); ok {
+			return gvar.New(gconv.Strings(result)), err
+		}
+	}
+	return gvar.New(result), err
 }

database/gredis/gredis_z_unit_conn_test.go

@@ -0,0 +1,51 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gredis_test
+
+import (
+	"github.com/gogf/gf/database/gredis"
+	"github.com/gogf/gf/test/gtest"
+	"testing"
+	"time"
+)
+
+func TestConn_DoWithTimeout(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		redis := gredis.New(config)
+		t.AssertNE(redis, nil)
+		conn := redis.Conn()
+		defer conn.Close()
+
+		_, err := conn.DoWithTimeout(time.Second, "set", "test", "123")
+		t.Assert(err, nil)
+		defer conn.DoWithTimeout(time.Second, "del", "test")
+
+		r, err := conn.DoWithTimeout(time.Second, "get", "test")
+		t.Assert(err, nil)
+		t.Assert(r, "123")
+	})
+}
+
+func TestConn_ReceiveVarWithTimeout(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		redis := gredis.New(config)
+		t.AssertNE(redis, nil)
+		conn := redis.Conn()
+		defer conn.Close()
+
+		_, err := conn.DoVarWithTimeout(time.Second, "Subscribe", "gf")
+		t.Assert(err, nil)
+
+		v, err := redis.DoVarWithTimeout(time.Second, "PUBLISH", "gf", "test")
+		t.Assert(err, nil)
+		t.Assert(v.String(), "1")
+
+		v, _ = conn.ReceiveVar()
+		t.Assert(len(v.Strings()), 3)
+		t.Assert(v.Strings()[2], "test")
+	})
+}

database/gredis/gredis_z_unit_test.go

@@ -18,7 +18,6 @@ import (
 
 	"github.com/gogf/gf/database/gredis"
 	"github.com/gogf/gf/test/gtest"
-	redis2 "github.com/gomodule/redigo/redis"
 )
 
 var (
@@ -181,28 +180,20 @@ func Test_Error(t *testing.T) {
 		t.Assert(err, nil)
 		t.Assert(v.String(), "v")
 
-		conn := redis.GetConn()
+		conn := redis.Conn()
+		defer conn.Close()
 		_, err = conn.DoVar("SET", "k", "v")
 		t.Assert(err, nil)
 
-		//v, err = conn.ReceiveVar()
-		//t.Assert(err, nil)
-		//t.Assert(v.String(), "v")
+		_, err = conn.DoVar("Subscribe", "gf")
+		t.Assert(err, nil)
 
-		psc := redis2.PubSubConn{Conn: conn}
-		psc.Subscribe("gf")
-		redis.DoVar("PUBLISH", "gf", "gf test")
-		go func() {
-			for {
-				v, _ := conn.ReceiveVar()
-				switch obj := v.Val().(type) {
-				case redis2.Message:
-					t.Assert(string(obj.Data), "gf test")
-				case redis2.Subscription:
+		_, err = redis.DoVar("PUBLISH", "gf", "test")
+		t.Assert(err, nil)
 
-				}
-			}
-		}()
+		v, _ = conn.ReceiveVar()
+		t.Assert(len(v.Strings()), 3)
+		t.Assert(v.Strings()[2], "test")
 
 		time.Sleep(time.Second)
 	})

debug/gdebug/gdebug_grid.go

@@ -0,0 +1,29 @@
+// Copyright 2019-2020 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gdebug
+
+import (
+	"regexp"
+	"runtime"
+	"strconv"
+)
+
+var (
+	// gridRegex is the regular expression object for parsing goroutine id from stack information.
+	gridRegex = regexp.MustCompile(`^\w+\s+(\d+)\s+`)
+)
+
+// GoroutineId retrieves and returns the current goroutine id from stack information.
+// Be very aware that, it is with low performance as it uses runtime.Stack function.
+// It is commonly used for debugging purpose.
+func GoroutineId() int {
+	buf := make([]byte, 26)
+	runtime.Stack(buf, false)
+	match := gridRegex.FindSubmatch(buf)
+	id, _ := strconv.Atoi(string(match[1]))
+	return id
+}

debug/gdebug/gdebug_stack.go

@@ -68,6 +68,7 @@ func StackWithFilters(filters []string, skip ...int) string {
 				file[0:len(goRootForFilter)] == goRootForFilter {
 				continue
 			}
+			// Custom filtering.
 			filtered = false
 			for _, filter := range filters {
 				if filter != "" && strings.Contains(file, filter) {

encoding/gjson/gjson.go

@@ -86,6 +86,7 @@ func (j *Json) setValue(pattern string, value interface{}, removed bool) error {
 			}
 
 		case []interface{}:
+			// A string key.
 			if !gstr.IsNumeric(array[i]) {
 				if i == length-1 {
 					*pointer = map[string]interface{}{array[i]: value}
@@ -97,23 +98,24 @@ func (j *Json) setValue(pattern string, value interface{}, removed bool) error {
 				}
 				continue
 			}
-
-			valn, err := strconv.Atoi(array[i])
+			// Numeric index.
+			valueNum, err := strconv.Atoi(array[i])
 			if err != nil {
 				return err
 			}
-			// Leaf node.
+
 			if i == length-1 {
-				if len((*pointer).([]interface{})) > valn {
+				// Leaf node.
+				if len((*pointer).([]interface{})) > valueNum {
 					if removed && value == nil {
 						// Deleting element.
 						if pparent == nil {
-							*pointer = append((*pointer).([]interface{})[:valn], (*pointer).([]interface{})[valn+1:]...)
+							*pointer = append((*pointer).([]interface{})[:valueNum], (*pointer).([]interface{})[valueNum+1:]...)
 						} else {
-							j.setPointerWithValue(pparent, array[i-1], append((*pointer).([]interface{})[:valn], (*pointer).([]interface{})[valn+1:]...))
+							j.setPointerWithValue(pparent, array[i-1], append((*pointer).([]interface{})[:valueNum], (*pointer).([]interface{})[valueNum+1:]...))
 						}
 					} else {
-						(*pointer).([]interface{})[valn] = value
+						(*pointer).([]interface{})[valueNum] = value
 					}
 				} else {
 					if removed && value == nil {
@@ -124,19 +126,33 @@ func (j *Json) setValue(pattern string, value interface{}, removed bool) error {
 						j.setPointerWithValue(pointer, array[i], value)
 					} else {
 						// It is not the root node.
-						s := make([]interface{}, valn+1)
+						s := make([]interface{}, valueNum+1)
 						copy(s, (*pointer).([]interface{}))
-						s[valn] = value
+						s[valueNum] = value
 						j.setPointerWithValue(pparent, array[i-1], s)
 					}
 				}
 			} else {
+				// Branch node.
 				if gstr.IsNumeric(array[i+1]) {
 					n, _ := strconv.Atoi(array[i+1])
-					if len((*pointer).([]interface{})) > valn {
-						(*pointer).([]interface{})[valn] = make([]interface{}, n+1)
-						pparent = pointer
-						pointer = &(*pointer).([]interface{})[valn]
+					pSlice := (*pointer).([]interface{})
+					if len(pSlice) > valueNum {
+						item := pSlice[valueNum]
+						if s, ok := item.([]interface{}); ok {
+							for i := 0; i < n-len(s); i++ {
+								s = append(s, nil)
+							}
+							pparent = pointer
+							pointer = &pSlice[valueNum]
+						} else {
+							if removed && value == nil {
+								goto done
+							}
+							var v interface{} = make([]interface{}, n+1)
+							pparent = j.setPointerWithValue(pointer, array[i], v)
+							pointer = &v
+						}
 					} else {
 						if removed && value == nil {
 							goto done
@@ -146,14 +162,26 @@ func (j *Json) setValue(pattern string, value interface{}, removed bool) error {
 						pointer = &v
 					}
 				} else {
-					v := (*pointer).([]interface{})
-					if len(v) > valn {
+					pSlice := (*pointer).([]interface{})
+					if len(pSlice) > valueNum {
 						pparent = pointer
-						pointer = &(*pointer).([]interface{})[valn]
+						pointer = &(*pointer).([]interface{})[valueNum]
 					} else {
-						var v interface{} = make(map[string]interface{})
-						pparent = j.setPointerWithValue(pointer, array[i], v)
-						pointer = &v
+						s := make([]interface{}, valueNum+1)
+						copy(s, pSlice)
+						s[valueNum] = make(map[string]interface{})
+						if pparent != nil {
+							// i > 0
+							j.setPointerWithValue(pparent, array[i-1], s)
+							pparent = pointer
+							pointer = &s[valueNum]
+						} else {
+							// i = 0
+							var v interface{} = s
+							*pointer = v
+							pparent = pointer
+							pointer = &s[valueNum]
+						}
 					}
 				}
 			}
@@ -177,19 +205,24 @@ func (j *Json) setValue(pattern string, value interface{}, removed bool) error {
 					pparent = pointer
 				}
 			} else {
-				var v interface{} = make(map[string]interface{})
+				var v1, v2 interface{}
 				if i == length-1 {
-					v = map[string]interface{}{
+					v1 = map[string]interface{}{
 						array[i]: value,
 					}
+				} else {
+					v1 = map[string]interface{}{
+						array[i]: nil,
+					}
 				}
 				if pparent != nil {
-					pparent = j.setPointerWithValue(pparent, array[i-1], v)
+					pparent = j.setPointerWithValue(pparent, array[i-1], v1)
 				} else {
-					*pointer = v
+					*pointer = v1
 					pparent = pointer
 				}
-				pointer = &v
+				v2 = v1.(map[string]interface{})[array[i]]
+				pointer = &v2
 			}
 		}
 	}

encoding/gjson/gjson_api_new_load.go

@@ -10,15 +10,15 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
-	"github.com/gogf/gf/internal/json"
 	"reflect"
 
+	"github.com/gogf/gf/internal/json"
+
 	"github.com/gogf/gf/encoding/gini"
 	"github.com/gogf/gf/encoding/gtoml"
 	"github.com/gogf/gf/encoding/gxml"
 	"github.com/gogf/gf/encoding/gyaml"
 	"github.com/gogf/gf/internal/rwmutex"
-	"github.com/gogf/gf/os/gfcache"
 	"github.com/gogf/gf/os/gfile"
 	"github.com/gogf/gf/text/gregex"
 	"github.com/gogf/gf/util/gconv"
@@ -55,8 +55,10 @@ func NewWithTag(data interface{}, tags string, safe ...bool) *Json {
 			}
 		}
 	default:
-		rv := reflect.ValueOf(data)
-		kind := rv.Kind()
+		var (
+			rv   = reflect.ValueOf(data)
+			kind = rv.Kind()
+		)
 		if kind == reflect.Ptr {
 			rv = rv.Elem()
 			kind = rv.Kind()
@@ -72,9 +74,7 @@ func NewWithTag(data interface{}, tags string, safe ...bool) *Json {
 			}
 		case reflect.Map, reflect.Struct:
 			i := interface{}(nil)
-			// Note that it uses Map function implementing the converting.
-			// Note that it here should not use MapDeep function if you really know what it means.
-			i = gconv.Map(data, tags)
+			i = gconv.MapDeep(data, tags)
 			j = &Json{
 				p:  &i,
 				c:  byte(gDEFAULT_SPLIT_CHAR),
@@ -99,7 +99,7 @@ func Load(path string, safe ...bool) (*Json, error) {
 	} else {
 		path = p
 	}
-	return doLoadContent(gfile.Ext(path), gfcache.GetBinContents(path), safe...)
+	return doLoadContent(gfile.Ext(path), gfile.GetBytesWithCache(path), safe...)
 }
 
 // LoadJson creates a Json object from given JSON format content.
@@ -189,22 +189,60 @@ func LoadContent(data interface{}, safe ...bool) (*Json, error) {
 	if len(content) == 0 {
 		return New(nil, safe...), nil
 	}
-	return doLoadContent(checkDataType(content), content, safe...)
+	return LoadContentType(checkDataType(content), content, safe...)
+}
 
+// LoadContentType creates a Json object from given type and content,
+// supporting data content type as follows:
+// JSON, XML, INI, YAML and TOML.
+func LoadContentType(dataType string, data interface{}, safe ...bool) (*Json, error) {
+	content := gconv.Bytes(data)
+	if len(content) == 0 {
+		return New(nil, safe...), nil
+	}
+	//ignore UTF8-BOM
+	if content[0] == 0xEF && content[1] == 0xBB && content[2] == 0xBF {
+		content = content[3:]
+	}
+	return doLoadContent(dataType, content, safe...)
+}
+
+// IsValidDataType checks and returns whether given <dataType> a valid data type for loading.
+func IsValidDataType(dataType string) bool {
+	if dataType == "" {
+		return false
+	}
+	if dataType[0] == '.' {
+		dataType = dataType[1:]
+	}
+	switch dataType {
+	case "json", "js", "xml", "yaml", "yml", "toml", "ini":
+		return true
+	}
+	return false
 }
 
 // checkDataType automatically checks and returns the data type for <content>.
+// Note that it uses regular expression for loose checking, you can use LoadXXX/LoadContentType
+// functions to load the content for certain content type.
 func checkDataType(content []byte) string {
 	if json.Valid(content) {
 		return "json"
 	} else if gregex.IsMatch(`^<.+>[\S\s]+<.+>$`, content) {
 		return "xml"
-	} else if gregex.IsMatch(`^[\s\t]*[\w\-]+\s*:\s*.+`, content) || gregex.IsMatch(`\n[\s\t]*[\w\-]+\s*:\s*.+`, content) {
+	} else if !gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*"""[\s\S]+"""`, content) && !gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*'''[\s\S]+'''`, content) &&
+		((gregex.IsMatch(`^[\n\r]*[\w\-\s\t]+\s*:\s*".+"`, content) || gregex.IsMatch(`^[\n\r]*[\w\-\s\t]+\s*:\s*\w+`, content)) ||
+			(gregex.IsMatch(`[\n\r]+[\w\-\s\t]+\s*:\s*".+"`, content) || gregex.IsMatch(`[\n\r]+[\w\-\s\t]+\s*:\s*\w+`, content))) {
 		return "yml"
-	} else if (gregex.IsMatch(`^[\s\t\[*\]].?*[\w\-]+\s*=\s*.+`, content) || gregex.IsMatch(`\n[\s\t\[*\]]*[\w\-]+\s*=\s*.+`, content)) && gregex.IsMatch(`\n[\s\t]*[\w\-]+\s*=*\"*.+\"`, content) == false && gregex.IsMatch(`^[\s\t]*[\w\-]+\s*=*\"*.+\"`, content) == false {
-		return "ini"
-	} else if gregex.IsMatch(`^[\s\t]*[\w\-\."]+\s*=\s*.+`, content) || gregex.IsMatch(`\n[\s\t]*[\w\-\."]+\s*=\s*.+`, content) {
+	} else if !gregex.IsMatch(`^[\s\t\n\r]*;.+`, content) &&
+		!gregex.IsMatch(`[\s\t\n\r]+;.+`, content) &&
+		!gregex.IsMatch(`[\n\r]+[\s\t\w\-]+\.[\s\t\w\-]+\s*=\s*.+`, content) &&
+		(gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*".+"`, content) || gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*\w+`, content)) {
 		return "toml"
+	} else if gregex.IsMatch(`\[[\w\.]+\]`, content) &&
+		(gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*".+"`, content) || gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*\w+`, content)) {
+		// Must contain "[xxx]" section.
+		return "ini"
 	} else {
 		return ""
 	}

encoding/gjson/gjson_z_unit_basic_test.go

@@ -419,7 +419,7 @@ func Test_Basic(t *testing.T) {
 		j = gjson.New(`[1,2,3]`)
 		err = j.Remove("0.3")
 		t.Assert(err, nil)
-		t.Assert(len(j.Get("0").([]interface{})), 3)
+		t.Assert(j.Get("0"), 1)
 
 		j = gjson.New(`[1,2,3]`)
 		err = j.Remove("0.a")

encoding/gjson/gjson_z_unit_internal_test.go

@@ -0,0 +1,133 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gjson
+
+import (
+	"github.com/gogf/gf/test/gtest"
+	"testing"
+)
+
+func Test_checkDataType(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		data := []byte(`
+bb           = """
+                   dig := dig;                         END;"""
+`)
+		t.Assert(checkDataType(data), "toml")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := []byte(`
+# 模板引擎目录
+viewpath = "/home/www/templates/"
+# MySQL数据库配置
+[redis]
+dd = 11
+[redis]
+    disk  = "127.0.0.1:6379,0"
+    cache = "127.0.0.1:6379,1"
+`)
+		t.Assert(checkDataType(data), "toml")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := []byte(`
+"gf.gvalid.rule.required"             = "The :attribute field is required"
+"gf.gvalid.rule.required-if"          = "The :attribute field is required"
+"gf.gvalid.rule.required-unless"      = "The :attribute field is required"
+"gf.gvalid.rule.required-with"        = "The :attribute field is required"
+"gf.gvalid.rule.required-with-all"    = "The :attribute field is required"
+"gf.gvalid.rule.required-without"     = "The :attribute field is required"
+"gf.gvalid.rule.required-without-all" = "The :attribute field is required"
+"gf.gvalid.rule.date"                 = "The :attribute value is not a valid date"
+"gf.gvalid.rule.date-format"          = "The :attribute value does not match the format :format"
+"gf.gvalid.rule.email"                = "The :attribute value must be a valid email address"
+"gf.gvalid.rule.phone"                = "The :attribute value must be a valid phone number"
+"gf.gvalid.rule.telephone"            = "The :attribute value must be a valid telephone number"
+"gf.gvalid.rule.passport"             = "The :attribute value is not a valid passport format"
+"gf.gvalid.rule.password"             = "The :attribute value is not a valid passport format"
+"gf.gvalid.rule.password2"            = "The :attribute value is not a valid passport format"
+"gf.gvalid.rule.password3"            = "The :attribute value is not a valid passport format"
+"gf.gvalid.rule.postcode"             = "The :attribute value is not a valid passport format"
+"gf.gvalid.rule.resident-id"          = "The :attribute value is not a valid resident id number"
+"gf.gvalid.rule.bank-card"            = "The :attribute value must be a valid bank card number"
+"gf.gvalid.rule.qq"                   = "The :attribute value must be a valid QQ number"
+"gf.gvalid.rule.ip"                   = "The :attribute value must be a valid IP address"
+"gf.gvalid.rule.ipv4"                 = "The :attribute value must be a valid IPv4 address"
+"gf.gvalid.rule.ipv6"                 = "The :attribute value must be a valid IPv6 address"
+"gf.gvalid.rule.mac"                  = "The :attribute value must be a valid MAC address"
+"gf.gvalid.rule.url"                  = "The :attribute value must be a valid URL address"
+"gf.gvalid.rule.domain"               = "The :attribute value must be a valid domain format"
+"gf.gvalid.rule.length"               = "The :attribute value length must be between :min and :max"
+"gf.gvalid.rule.min-length"           = "The :attribute value length must be equal or greater than :min"
+"gf.gvalid.rule.max-length"           = "The :attribute value length must be equal or lesser than :max"
+"gf.gvalid.rule.between"              = "The :attribute value must be between :min and :max"
+"gf.gvalid.rule.min"                  = "The :attribute value must be equal or greater than :min"
+"gf.gvalid.rule.max"                  = "The :attribute value must be equal or lesser than :max"
+"gf.gvalid.rule.json"                 = "The :attribute value must be a valid JSON string"
+"gf.gvalid.rule.xml"                  = "The :attribute value must be a valid XML string"
+"gf.gvalid.rule.array"                = "The :attribute value must be an array"
+"gf.gvalid.rule.integer"              = "The :attribute value must be an integer"
+"gf.gvalid.rule.float"                = "The :attribute value must be a float"
+"gf.gvalid.rule.boolean"              = "The :attribute value field must be true or false"
+"gf.gvalid.rule.same"                 = "The :attribute value must be the same as field :field"
+"gf.gvalid.rule.different"            = "The :attribute value must be different from field :field"
+"gf.gvalid.rule.in"                   = "The :attribute value is not in acceptable range"
+"gf.gvalid.rule.not-in"               = "The :attribute value is not in acceptable range"
+"gf.gvalid.rule.regex"                = "The :attribute value is invalid"
+`)
+		//fmt.Println(gregex.IsMatch(`^[\s\t\n\r]*[\w\-]+\s*:\s*".+"`, data))
+		//fmt.Println(gregex.IsMatch(`^[\s\t\n\r]*[\w\-]+\s*:\s*\w+`, data))
+		//fmt.Println(gregex.IsMatch(`[\s\t\n\r]+[\w\-]+\s*:\s*".+"`, data))
+		//fmt.Println(gregex.IsMatch(`[\n\r]+[\w\-\s\t]+\s*:\s*\w+`, data))
+		//fmt.Println(gregex.MatchString(`[\n\r]+[\w\-\s\t]+\s*:\s*\w+`, string(data)))
+		t.Assert(checkDataType(data), "toml")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := []byte(`
+[default]
+db.engine         = mysql
+db.max.idle.conns = 5
+db.max.open.conns = 100
+allow_ips         =
+api.key           =
+api.secret        =
+enable_tls        = false
+concurrency.queue = 500
+auth_secret       = 63358e6f3daf0e5775ec3fb4d2516b01d41530bf30960aa76972f6ce7e08552f
+ca_file           =
+cert_file         =
+key_file          =
+host_port         = 8088
+log_path          = /Users/zhaosuji/go/src/git.medlinker.com/foundations/gocron/log
+#k8s-api地址(只提供内网访问)
+k8s-inner-api = http://127.0.0.1:8081/kube/add
+conf_dir = ./config
+app_conf = ./config/app.ini
+`)
+		t.Assert(checkDataType(data), "ini")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := []byte(`
+# API Server
+[server]
+    address = ":8199"
+
+# Jenkins
+[jenkins]
+    url          = "https://jenkins-swimlane.com"
+    nodeJsStaticBuildCmdTpl = """
+npm i --registry=https://registry.npm.taobao.org
+wget http://consul.infra:8500/v1/kv/app_{{.SwimlaneName}}/{{.RepoName}}/.env.qa?raw=true -O ./env.qa
+npm run build:qa
+"""
+`)
+		t.Assert(checkDataType(data), "toml")
+	})
+}

encoding/gjson/gjson_z_unit_load_test.go

@@ -215,8 +215,7 @@ func Test_Load_Ini(t *testing.T) {
 
 ;注释
 
-[addr] 
-#注释
+[addr]
 ip = 127.0.0.1
 port=9001
 enable=true

encoding/gjson/gjson_z_unit_new_test.go

@@ -47,3 +47,53 @@ func Test_Load_NewWithTag(t *testing.T) {
 		t.Assert(j.Get("addr-json"), nil)
 	})
 }
+
+func Test_Load_New_CustomStruct(t *testing.T) {
+	type Base struct {
+		Id int
+	}
+	type User struct {
+		Base
+		Name string
+	}
+	user := new(User)
+	user.Id = 1
+	user.Name = "john"
+
+	gtest.C(t, func(t *gtest.T) {
+		j := gjson.New(user)
+		t.AssertNE(j, nil)
+
+		s, err := j.ToJsonString()
+		t.Assert(err, nil)
+		t.Assert(s == `{"Id":1,"Name":"john"}` || s == `{"Name":"john","Id":1}`, true)
+	})
+}
+
+func Test_Load_New_HierarchicalStruct(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type Me struct {
+			Name     string `json:"name"`
+			Score    int    `json:"score"`
+			Children []Me   `json:"children"`
+		}
+		me := Me{
+			Name:  "john",
+			Score: 100,
+			Children: []Me{
+				{
+					Name:  "Bean",
+					Score: 99,
+				},
+				{
+					Name:  "Sam",
+					Score: 98,
+				},
+			},
+		}
+		j := gjson.New(me)
+		t.Assert(j.Remove("children.0.score"), nil)
+		t.Assert(j.Remove("children.1.score"), nil)
+		t.Assert(j.MustToJsonString(), `{"children":[{"children":null,"name":"Bean"},{"children":null,"name":"Sam"}],"name":"john","score":100}`)
+	})
+}

encoding/gjson/gjson_z_unit_set_test.go

@@ -8,6 +8,9 @@ package gjson_test
 
 import (
 	"bytes"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/test/gtest"
+	"github.com/gogf/gf/text/gstr"
 	"testing"
 
 	"github.com/gogf/gf/encoding/gjson"
@@ -31,17 +34,13 @@ func Test_Set1(t *testing.T) {
 }
 
 func Test_Set2(t *testing.T) {
-	e := []byte(`[[null,1]]`)
-	p := gjson.New([]string{"a"})
-	p.Set("0.1", 1)
-	if c, err := p.ToJson(); err == nil {
-
-		if bytes.Compare(c, e) != 0 {
-			t.Error("expect:", string(e))
-		}
-	} else {
-		t.Error(err)
-	}
+	gtest.C(t, func(t *gtest.T) {
+		e := `[[null,1]]`
+		p := gjson.New([]string{"a"})
+		p.Set("0.1", 1)
+		s := p.MustToJsonString()
+		t.Assert(s, e)
+	})
 }
 
 func Test_Set3(t *testing.T) {
@@ -51,7 +50,6 @@ func Test_Set3(t *testing.T) {
 		"k1": "v1",
 	})
 	if c, err := p.ToJson(); err == nil {
-
 		if bytes.Compare(c, e) != 0 {
 			t.Error("expect:", string(e))
 		}
@@ -227,3 +225,107 @@ func Test_Set14(t *testing.T) {
 		t.Error(err)
 	}
 }
+
+func Test_Set15(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		j := gjson.New(nil)
+
+		t.Assert(j.Set("root.0.k1", "v1"), nil)
+		t.Assert(j.Set("root.1.k2", "v2"), nil)
+		t.Assert(j.Set("k", "v"), nil)
+
+		s, err := j.ToJsonString()
+		t.Assert(err, nil)
+		t.Assert(
+			gstr.Contains(s, `"root":[{"k1":"v1"},{"k2":"v2"}`) ||
+				gstr.Contains(s, `"root":[{"k2":"v2"},{"k1":"v1"}`),
+			true,
+		)
+		t.Assert(
+			gstr.Contains(s, `{"k":"v"`) ||
+				gstr.Contains(s, `"k":"v"}`),
+			true,
+		)
+	})
+}
+
+func Test_Set16(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		j := gjson.New(nil)
+
+		t.Assert(j.Set("processors.0.set.0value", "1"), nil)
+		t.Assert(j.Set("processors.0.set.0field", "2"), nil)
+		t.Assert(j.Set("description", "3"), nil)
+
+		s, err := j.ToJsonString()
+		t.Assert(err, nil)
+		t.Assert(
+			gstr.Contains(s, `"processors":[{"set":{"0field":"2","0value":"1"}}]`) ||
+				gstr.Contains(s, `"processors":[{"set":{"0value":"1","0field":"2"}}]`),
+			true,
+		)
+		t.Assert(
+			gstr.Contains(s, `{"description":"3"`) || gstr.Contains(s, `"description":"3"}`),
+			true,
+		)
+	})
+}
+
+func Test_Set17(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		j := gjson.New(nil)
+
+		t.Assert(j.Set("0.k1", "v1"), nil)
+		t.Assert(j.Set("1.k2", "v2"), nil)
+		// overwrite the previous slice.
+		t.Assert(j.Set("k", "v"), nil)
+
+		s, err := j.ToJsonString()
+		t.Assert(err, nil)
+		t.Assert(s, `{"k":"v"}`)
+	})
+}
+
+func Test_Set18(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		j := gjson.New(nil)
+
+		t.Assert(j.Set("0.1.k1", "v1"), nil)
+		t.Assert(j.Set("0.2.k2", "v2"), nil)
+		s, err := j.ToJsonString()
+		t.Assert(err, nil)
+		t.Assert(s, `[[null,{"k1":"v1"},{"k2":"v2"}]]`)
+	})
+}
+
+func Test_Set19(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		j := gjson.New(nil)
+
+		t.Assert(j.Set("0.1.1.k1", "v1"), nil)
+		t.Assert(j.Set("0.2.1.k2", "v2"), nil)
+		s, err := j.ToJsonString()
+		t.Assert(err, nil)
+		t.Assert(s, `[[null,[null,{"k1":"v1"}],[null,{"k2":"v2"}]]]`)
+	})
+}
+
+func Test_Set20(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		j := gjson.New(nil)
+
+		t.Assert(j.Set("k1", "v1"), nil)
+		t.Assert(j.Set("k2", g.Slice{1, 2, 3}), nil)
+		t.Assert(j.Set("k2.1", 20), nil)
+		t.Assert(j.Set("k2.2", g.Map{"k3": "v3"}), nil)
+		s, err := j.ToJsonString()
+		t.Assert(err, nil)
+		t.Assert(gstr.InArray(
+			g.SliceStr{
+				`{"k1":"v1","k2":[1,20,{"k3":"v3"}]}`,
+				`{"k2":[1,20,{"k3":"v3"}],"k1":"v1"}`,
+			},
+			s,
+		), true)
+	})
+}

encoding/gparser/gparser_api_new_load.go

@@ -10,7 +10,7 @@ import (
 	"github.com/gogf/gf/encoding/gjson"
 )
 
-// New creates a Parser object with any variable type of <data>, but <data> should be a map or
+// New creates a Parser object with any variable type of <data>, but <data> should be a map, struct or
 // slice for data access reason, or it will make no sense.
 //
 // The parameter <safe> specifies whether using this Json object in concurrent-safe context, which

errors/gerror/gerror.go

@@ -26,6 +26,12 @@ type ApiCause interface {
 	Cause() error
 }
 
+// ApiLevel is the interface for Current/Next feature.
+type ApiLevel interface {
+	Current() error
+	Next() error
+}
+
 // New creates and returns an error which is formatted from given text.
 func New(text string) error {
 	if text == "" {
@@ -120,3 +126,27 @@ func Stack(err error) string {
 	}
 	return ""
 }
+
+// Current creates and returns the current level error.
+// It returns nil if current level error is nil.
+func Current(err error) error {
+	if err == nil {
+		return nil
+	}
+	if e, ok := err.(ApiLevel); ok {
+		return e.Current()
+	}
+	return err
+}
+
+// Next returns the next level error.
+// It returns nil if current level error or the next level error is nil.
+func Next(err error) error {
+	if err == nil {
+		return nil
+	}
+	if e, ok := err.(ApiLevel); ok {
+		return e.Next()
+	}
+	return nil
+}

errors/gerror/gerror_error.go

@@ -27,6 +27,7 @@ const (
 
 var (
 	// goRootForFilter is used for stack filtering purpose.
+	// Mainly for development environment.
 	goRootForFilter = runtime.GOROOT()
 )
 
@@ -36,8 +37,11 @@ func init() {
 	}
 }
 
-// Error implements the interface of Error, it returns the error as string.
+// Error implements the interface of Error, it returns all the error as string.
 func (err *Error) Error() string {
+	if err == nil {
+		return ""
+	}
 	if err.text != "" {
 		if err.error != nil {
 			return err.text + ": " + err.error.Error()
@@ -49,6 +53,9 @@ func (err *Error) Error() string {
 
 // Cause returns the root cause error.
 func (err *Error) Cause() error {
+	if err == nil {
+		return nil
+	}
 	loop := err
 	for loop != nil {
 		if loop.error != nil {
@@ -66,8 +73,8 @@ func (err *Error) Cause() error {
 
 // Format formats the frame according to the fmt.Formatter interface.
 //
-// %v, %s   : Print the error string;
-// %-v, %-s : Print current error string;
+// %v, %s   : Print all the error string;
+// %-v, %-s : Print current level error string;
 // %+s      : Print full stack error list;
 // %+v      : Print the error string and full stack error list;
 func (err *Error) Format(s fmt.State, verb rune) {
@@ -120,6 +127,28 @@ func (err *Error) Stack() string {
 	return buffer.String()
 }
 
+// Current creates and returns the current level error.
+// It returns nil if current level error is nil.
+func (err *Error) Current() error {
+	if err == nil {
+		return nil
+	}
+	return &Error{
+		error: nil,
+		stack: err.stack,
+		text:  err.text,
+	}
+}
+
+// Next returns the next level error.
+// It returns nil if current level error or the next level error is nil.
+func (err *Error) Next() error {
+	if err == nil {
+		return nil
+	}
+	return err.error
+}
+
 // formatSubStack formats the stack for error.
 func formatSubStack(st stack, buffer *bytes.Buffer) {
 	index := 1

errors/gerror/gerror_test.go

@@ -127,3 +127,31 @@ func Test_Stack(t *testing.T) {
 		//fmt.Printf("%+v", err)
 	})
 }
+
+func Test_Current(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		err := errors.New("1")
+		err = gerror.Wrap(err, "2")
+		err = gerror.Wrap(err, "3")
+		t.Assert(err.Error(), "3: 2: 1")
+		t.Assert(gerror.Current(err).Error(), "3")
+	})
+}
+
+func Test_Next(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		err := errors.New("1")
+		err = gerror.Wrap(err, "2")
+		err = gerror.Wrap(err, "3")
+		t.Assert(err.Error(), "3: 2: 1")
+
+		err = gerror.Next(err)
+		t.Assert(err.Error(), "2: 1")
+
+		err = gerror.Next(err)
+		t.Assert(err.Error(), "1")
+
+		err = gerror.Next(err)
+		t.Assert(err, nil)
+	})
+}

frame/g/g_func.go

@@ -39,8 +39,15 @@ func Throw(exception interface{}) {
 	gutil.Throw(exception)
 }
 
-// TryCatch does the try...catch... mechanism.
-func TryCatch(try func(), catch ...func(exception interface{})) {
+// Try implements try... logistics using internal panic...recover.
+// It returns error if any exception occurs, or else it returns nil.
+func Try(try func()) (err error) {
+	return gutil.Try(try)
+}
+
+// TryCatch implements try...catch... logistics using internal panic...recover.
+// It automatically calls function <catch> if any exception occurs ans passes the exception as an error.
+func TryCatch(try func(), catch ...func(exception error)) {
 	gutil.TryCatch(try, catch...)
 }
 

frame/g/g_logger.go

@@ -10,17 +10,14 @@ import (
 	"github.com/gogf/gf/os/glog"
 )
 
-// SetDebug disables/enables debug level for logging component globally.
-func SetDebug(debug bool) {
-	glog.SetDebug(debug)
-}
-
 // SetLogLevel sets the logging level globally.
+// Deprecated, use functions of package glog or g.Log() instead.
 func SetLogLevel(level int) {
 	glog.SetLevel(level)
 }
 
 // GetLogLevel returns the global logging level.
+// Deprecated, use functions of package glog or g.Log() instead.
 func GetLogLevel() int {
 	return glog.GetLevel()
 }

frame/g/g_setting.go

@@ -6,7 +6,17 @@
 
 package g
 
-import "github.com/gogf/gf/net/ghttp"
+import (
+	"github.com/gogf/gf/internal/intlog"
+	"github.com/gogf/gf/net/ghttp"
+)
+
+// SetEnabled enables/disables the GoFrame internal logging manually.
+// Note that this function is not concurrent safe, be aware of the DATA RACE,
+// which means you should call this function in your boot but not the runtime.
+func SetDebug(enabled bool) {
+	intlog.SetEnabled(enabled)
+}
 
 // SetServerGraceful enables/disables graceful reload feature of http Web Server.
 // This feature is disabled in default.

frame/gins/gins_database.go

@@ -31,25 +31,26 @@ func Database(name ...string) gdb.DB {
 	}
 	instanceKey := fmt.Sprintf("%s.%s", gFRAME_CORE_COMPONENT_NAME_DATABASE, group)
 	db := instances.GetOrSetFuncLock(instanceKey, func() interface{} {
-		// Configuration already exists.
-		if gdb.GetConfig(group) != nil {
-			db, err := gdb.Instance(group)
-			if err != nil {
-				panic(err)
-			}
-			return db
-		}
-		var m map[string]interface{}
+		var (
+			configMap     map[string]interface{}
+			configNodeKey string
+		)
 		// It firstly searches the configuration of the instance name.
-		nodeKey, _ := gutil.MapPossibleItemByKey(Config().GetMap("."), gDATABASE_NODE_NAME)
-		if nodeKey == "" {
-			nodeKey = gDATABASE_NODE_NAME
+		if Config().Available() {
+			configNodeKey, _ = gutil.MapPossibleItemByKey(Config().GetMap("."), gDATABASE_NODE_NAME)
+			if configNodeKey == "" {
+				configNodeKey = gDATABASE_NODE_NAME
+			}
+			configMap = Config().GetMap(configNodeKey)
 		}
-		if m = Config().GetMap(nodeKey); len(m) == 0 {
+		if len(configMap) == 0 && !gdb.IsConfigured() {
 			panic(fmt.Sprintf(`database init failed: "%s" node not found, is config file or configuration missing?`, gDATABASE_NODE_NAME))
 		}
+		if len(configMap) == 0 {
+			configMap = make(map[string]interface{})
+		}
 		// Parse <m> as map-slice and adds it to gdb's global configurations.
-		for group, groupConfig := range m {
+		for g, groupConfig := range configMap {
 			cg := gdb.ConfigGroup{}
 			switch value := groupConfig.(type) {
 			case []interface{}:
@@ -64,37 +65,51 @@ func Database(name ...string) gdb.DB {
 				}
 			}
 			if len(cg) > 0 {
-				intlog.Printf("%s, %#v", group, cg)
-				gdb.SetConfigGroup(group, cg)
+				if gdb.GetConfig(group) == nil {
+					intlog.Printf("add configuration for group: %s, %#v", g, cg)
+					gdb.SetConfigGroup(g, cg)
+				} else {
+					intlog.Printf("ignore configuration as it already exists for group: %s, %#v", g, cg)
+					intlog.Printf("%s, %#v", g, cg)
+				}
 			}
 		}
 		// Parse <m> as a single node configuration,
 		// which is the default group configuration.
-		if node := parseDBConfigNode(m); node != nil {
+		if node := parseDBConfigNode(configMap); node != nil {
 			cg := gdb.ConfigGroup{}
 			if node.LinkInfo != "" || node.Host != "" {
 				cg = append(cg, *node)
 			}
+
 			if len(cg) > 0 {
-				intlog.Printf("%s, %#v", gdb.DEFAULT_GROUP_NAME, cg)
-				gdb.SetConfigGroup(gdb.DEFAULT_GROUP_NAME, cg)
+				if gdb.GetConfig(group) == nil {
+					intlog.Printf("add configuration for group: %s, %#v", gdb.DEFAULT_GROUP_NAME, cg)
+					gdb.SetConfigGroup(gdb.DEFAULT_GROUP_NAME, cg)
+				} else {
+					intlog.Printf("ignore configuration as it already exists for group: %s, %#v", gdb.DEFAULT_GROUP_NAME, cg)
+					intlog.Printf("%s, %#v", gdb.DEFAULT_GROUP_NAME, cg)
+				}
 			}
 		}
-
+		// Create a new ORM object with given configurations.
 		if db, err := gdb.New(name...); err == nil {
-			// Initialize logger for ORM.
-			var m map[string]interface{}
-			m = Config().GetMap(fmt.Sprintf("%s.%s", nodeKey, gLOGGER_NODE_NAME))
-			if len(m) == 0 {
-				m = Config().GetMap(nodeKey)
-			}
-			if len(m) > 0 {
-				if err := db.GetLogger().SetConfigWithMap(m); err != nil {
-					panic(err)
+			if Config().Available() {
+				// Initialize logger for ORM.
+				var loggerConfigMap map[string]interface{}
+				loggerConfigMap = Config().GetMap(fmt.Sprintf("%s.%s", configNodeKey, gLOGGER_NODE_NAME))
+				if len(loggerConfigMap) == 0 {
+					loggerConfigMap = Config().GetMap(configNodeKey)
+				}
+				if len(loggerConfigMap) > 0 {
+					if err := db.GetLogger().SetConfigWithMap(loggerConfigMap); err != nil {
+						panic(err)
+					}
 				}
 			}
 			return db
 		} else {
+			// It panics often because it dose not find its configuration for given group.
 			panic(err)
 		}
 		return nil

go.mod

@@ -4,8 +4,8 @@ go 1.11
 
 require (
 	github.com/BurntSushi/toml v0.3.1
-	github.com/clbanning/mxj v1.8.4
-	github.com/fsnotify/fsnotify v1.4.7
+	github.com/clbanning/mxj v1.8.5-0.20200714211355-ff02cfb8ea28
+	github.com/fsnotify/fsnotify v1.4.9
 	github.com/go-sql-driver/mysql v1.5.0
 	github.com/gomodule/redigo v2.0.0+incompatible
 	github.com/gorilla/websocket v1.4.1
@@ -15,7 +15,6 @@ require (
 	github.com/mattn/go-runewidth v0.0.9 // indirect
 	github.com/olekukonko/tablewriter v0.0.1
 	golang.org/x/net v0.0.0-20200602114024-627f9648deb9
-	golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae // indirect
 	golang.org/x/text v0.3.2
 	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
 )

i18n/gi18n/gi18n.go

@@ -32,7 +32,31 @@ func T(content string, language ...string) string {
 	return defaultManager.T(content, language...)
 }
 
-// Translate translates <content> with configured language.
+// Tf is alias of TranslateFormat for convenience.
+func Tf(format string, values ...interface{}) string {
+	return defaultManager.TranslateFormat(format, values...)
+}
+
+// Tfl is alias of TranslateFormatLang for convenience.
+func Tfl(language string, format string, values ...interface{}) string {
+	return defaultManager.TranslateFormatLang(language, format, values...)
+}
+
+// TranslateFormat translates, formats and returns the <format> with configured language
+// and given <values>.
+func TranslateFormat(format string, values ...interface{}) string {
+	return defaultManager.TranslateFormat(format, values...)
+}
+
+// TranslateFormatLang translates, formats and returns the <format> with configured language
+// and given <values>. The parameter <language> specifies custom translation language ignoring
+// configured language. If <language> is given empty string, it uses the default configured
+// language for the translation.
+func TranslateFormatLang(language string, format string, values ...interface{}) string {
+	return defaultManager.TranslateFormatLang(format, language, values...)
+}
+
+// Translate translates <content> with configured language and returns the translated content.
 // The parameter <language> specifies custom translation language ignoring configured language.
 func Translate(content string, language ...string) string {
 	return defaultManager.Translate(content, language...)

i18n/gi18n/gi18n_manager.go

@@ -124,6 +124,30 @@ func (m *Manager) T(content string, language ...string) string {
 	return m.Translate(content, language...)
 }
 
+// Tf is alias of TranslateFormat for convenience.
+func (m *Manager) Tf(format string, values ...interface{}) string {
+	return m.TranslateFormat(format, values...)
+}
+
+// Tfl is alias of TranslateFormatLang for convenience.
+func (m *Manager) Tfl(language string, format string, values ...interface{}) string {
+	return m.TranslateFormatLang(language, format, values...)
+}
+
+// TranslateFormat translates, formats and returns the <format> with configured language
+// and given <values>.
+func (m *Manager) TranslateFormat(format string, values ...interface{}) string {
+	return fmt.Sprintf(m.Translate(format), values...)
+}
+
+// TranslateFormatLang translates, formats and returns the <format> with configured language
+// and given <values>. The parameter <language> specifies custom translation language ignoring
+// configured language. If <language> is given empty string, it uses the default configured
+// language for the translation.
+func (m *Manager) TranslateFormatLang(language string, format string, values ...interface{}) string {
+	return fmt.Sprintf(m.Translate(format, language), values...)
+}
+
 // Translate translates <content> with configured language.
 // The parameter <language> specifies custom translation language ignoring configured language.
 func (m *Manager) Translate(content string, language ...string) string {
@@ -222,10 +246,10 @@ func (m *Manager) init() {
 	} else if m.options.Path != "" {
 		files, _ := gfile.ScanDirFile(m.options.Path, "*.*", true)
 		if len(files) == 0 {
-			intlog.Printf(
-				"no i18n files found in configured directory: %s",
-				m.options.Path,
-			)
+			//intlog.Printf(
+			//	"no i18n files found in configured directory: %s",
+			//	m.options.Path,
+			//)
 			return
 		}
 		var (

i18n/gi18n/gi18n_unit_test.go

@@ -73,6 +73,28 @@ func Test_Basic(t *testing.T) {
 	})
 }
 
+func Test_TranslateFormat(t *testing.T) {
+	// Tf
+	gtest.C(t, func(t *gtest.T) {
+		i18n := gi18n.New(gi18n.Options{
+			Path: gdebug.TestDataPath("i18n"),
+		})
+		i18n.SetLanguage("none")
+		t.Assert(i18n.Tf("{#hello}{#world} %d", 2020), "{#hello}{#world} 2020")
+
+		i18n.SetLanguage("ja")
+		t.Assert(i18n.Tf("{#hello}{#world} %d", 2020), "こんにちは世界 2020")
+	})
+	// Tfl
+	gtest.C(t, func(t *gtest.T) {
+		i18n := gi18n.New(gi18n.Options{
+			Path: gdebug.TestDataPath("i18n"),
+		})
+		t.Assert(i18n.Tfl("ja", "{#hello}{#world} %d", 2020), "こんにちは世界 2020")
+		t.Assert(i18n.Tfl("zh-CN", "{#hello}{#world} %d", 2020), "你好世界 2020")
+	})
+}
+
 func Test_DefaultManager(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		err := gi18n.SetPath(gdebug.TestDataPath("i18n"))

internal/empty/empty.go

@@ -69,12 +69,21 @@ func IsEmpty(value interface{}) bool {
 	default:
 		// Common interfaces checks.
 		if f, ok := value.(apiString); ok {
+			if f == nil {
+				return true
+			}
 			return f.String() == ""
 		}
 		if f, ok := value.(apiInterfaces); ok {
+			if f == nil {
+				return true
+			}
 			return len(f.Interfaces()) == 0
 		}
 		if f, ok := value.(apiMapStrAny); ok {
+			if f == nil {
+				return true
+			}
 			return len(f.MapStrAny()) == 0
 		}
 		// Finally using reflect.

internal/intlog/intlog.go

@@ -25,6 +25,7 @@ var (
 )
 
 func init() {
+	// Debugging configured.
 	if !cmdenv.Get("GF_DEBUG").IsEmpty() {
 		isGFDebug = true
 		return
@@ -32,9 +33,12 @@ func init() {
 }
 
 // SetEnabled enables/disables the internal logging manually.
-// Note that this function is not current safe, be aware of the DATA RACE.
+// Note that this function is not concurrent safe, be aware of the DATA RACE.
 func SetEnabled(enabled bool) {
-	isGFDebug = enabled
+	// If they're the same, it does not write the <isGFDebug> but only reading operation.
+	if isGFDebug != enabled {
+		isGFDebug = enabled
+	}
 }
 
 // IsEnabled checks and returns whether current process is in GF development.

internal/structs/structs_map.go

@@ -22,6 +22,21 @@ import (
 //
 // Note that it only retrieves the exported attributes with first letter up-case from struct.
 func MapField(pointer interface{}, priority []string, recursive bool) map[string]*Field {
+	// If <pointer> points to an invalid address, for example a nil variable,
+	// it here creates an empty struct using reflect feature.
+	var (
+		tempValue    reflect.Value
+		pointerValue = reflect.ValueOf(pointer)
+	)
+	for pointerValue.Kind() == reflect.Ptr {
+		tempValue = pointerValue.Elem()
+		if !tempValue.IsValid() {
+			pointer = reflect.New(pointerValue.Type().Elem()).Elem()
+			break
+		} else {
+			pointerValue = tempValue
+		}
+	}
 	var (
 		fields   []*structs.Field
 		fieldMap = make(map[string]*Field)
@@ -59,8 +74,10 @@ func MapField(pointer interface{}, priority []string, recursive bool) map[string
 			}
 		}
 		if recursive {
-			rv := reflect.ValueOf(field.Value())
-			kind := rv.Kind()
+			var (
+				rv   = reflect.ValueOf(field.Value())
+				kind = rv.Kind()
+			)
 			if kind == reflect.Ptr {
 				rv = rv.Elem()
 				kind = rv.Kind()

internal/structs/structs_tag.go

@@ -27,6 +27,21 @@ func TagFields(pointer interface{}, priority []string, recursive bool) []*Field
 // tag internally.
 // The parameter <pointer> should be type of struct/*struct.
 func doTagFields(pointer interface{}, priority []string, recursive bool, tagMap map[string]struct{}) []*Field {
+	// If <pointer> points to an invalid address, for example a nil variable,
+	// it here creates an empty struct using reflect feature.
+	var (
+		tempValue    reflect.Value
+		pointerValue = reflect.ValueOf(pointer)
+	)
+	for pointerValue.Kind() == reflect.Ptr {
+		tempValue = pointerValue.Elem()
+		if !tempValue.IsValid() {
+			pointer = reflect.New(pointerValue.Type().Elem()).Elem()
+			break
+		} else {
+			pointerValue = tempValue
+		}
+	}
 	var fields []*structs.Field
 	if v, ok := pointer.(reflect.Value); ok {
 		fields = structs.Fields(v.Interface())

internal/structs/structs_test.go

@@ -71,3 +71,20 @@ func Test_Basic(t *testing.T) {
 		t.Assert(structs.TagMapName(user2, []string{"params"}, true), g.Map{"password1": "Pass1", "password2": "Pass2"})
 	})
 }
+
+func Test_StructOfNilPointer(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id   int
+			Name string `params:"name"`
+			Pass string `my-tag1:"pass1" my-tag2:"pass2" params:"pass"`
+		}
+		var user *User
+		t.Assert(structs.TagMapName(user, []string{"params"}, true), g.Map{"name": "Name", "pass": "Pass"})
+		t.Assert(structs.TagMapName(&user, []string{"params"}, true), g.Map{"name": "Name", "pass": "Pass"})
+
+		t.Assert(structs.TagMapName(&user, []string{"params", "my-tag1"}, true), g.Map{"name": "Name", "pass": "Pass"})
+		t.Assert(structs.TagMapName(&user, []string{"my-tag1", "params"}, true), g.Map{"name": "Name", "pass1": "Pass"})
+		t.Assert(structs.TagMapName(&user, []string{"my-tag2", "params"}, true), g.Map{"name": "Name", "pass2": "Pass"})
+	})
+}

net/ghttp/ghttp_client_api.go

@@ -6,6 +6,8 @@
 
 package ghttp
 
+import "github.com/gogf/gf/container/gvar"
+
 // Get is a convenience method for sending GET request.
 // NOTE that remembers CLOSING the response object when it'll never be used.
 func Get(url string, data ...interface{}) (*ClientResponse, error) {
@@ -185,3 +187,69 @@ func TraceBytes(url string, data ...interface{}) []byte {
 func RequestBytes(method string, url string, data ...interface{}) []byte {
 	return NewClient().RequestBytes(method, url, data...)
 }
+
+// GetVar sends a GET request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et
+func GetVar(url string, data ...interface{}) *gvar.Var {
+	return RequestVar("GET", url, data...)
+}
+
+// PutVar sends a PUT request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et
+func PutVar(url string, data ...interface{}) *gvar.Var {
+	return RequestVar("PUT", url, data...)
+}
+
+// PostVar sends a POST request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et
+func PostVar(url string, data ...interface{}) *gvar.Var {
+	return RequestVar("POST", url, data...)
+}
+
+// DeleteVar sends a DELETE request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et
+func DeleteVar(url string, data ...interface{}) *gvar.Var {
+	return RequestVar("DELETE", url, data...)
+}
+
+// HeadVar sends a HEAD request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et
+func HeadVar(url string, data ...interface{}) *gvar.Var {
+	return RequestVar("HEAD", url, data...)
+}
+
+// PatchVar sends a PATCH request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et
+func PatchVar(url string, data ...interface{}) *gvar.Var {
+	return RequestVar("PATCH", url, data...)
+}
+
+// ConnectVar sends a CONNECT request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et
+func ConnectVar(url string, data ...interface{}) *gvar.Var {
+	return RequestVar("CONNECT", url, data...)
+}
+
+// OptionsVar sends a OPTIONS request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et
+func OptionsVar(url string, data ...interface{}) *gvar.Var {
+	return RequestVar("OPTIONS", url, data...)
+}
+
+// TraceVar sends a TRACE request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et
+func TraceVar(url string, data ...interface{}) *gvar.Var {
+	return RequestVar("TRACE", url, data...)
+}
+
+// RequestVar sends request using given HTTP method and data, retrieves converts the result
+// to specified pointer. It reads and closes the response object internally automatically.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et
+func RequestVar(method string, url string, data ...interface{}) *gvar.Var {
+	response, err := DoRequest(method, url, data...)
+	if err != nil {
+		return gvar.New(nil)
+	}
+	defer response.Close()
+	return gvar.New(response.ReadAll())
+}

net/ghttp/ghttp_client_chain.go

@@ -149,3 +149,14 @@ func (c *Client) Proxy(proxyURL string) *Client {
 	newClient.SetProxy(proxyURL)
 	return c
 }
+
+// RedirectLimit is a chaining function,
+// which sets the redirect limit the number of jumps for the request.
+func (c *Client) RedirectLimit(redirectLimit int) *Client {
+	newClient := c
+	if c.parent == nil {
+		newClient = c.Clone()
+	}
+	newClient.SetRedirectLimit(redirectLimit)
+	return c
+}

net/ghttp/ghttp_client_request.go

@@ -123,7 +123,7 @@ func (c *Client) DoRequest(method, url string, data ...interface{}) (resp *Clien
 			param = BuildParams(data[0])
 		}
 	}
-	req := (*http.Request)(nil)
+	var req *http.Request
 	if strings.Contains(param, "@file:") {
 		// File uploading request.
 		buffer := new(bytes.Buffer)
@@ -135,7 +135,7 @@ func (c *Client) DoRequest(method, url string, data ...interface{}) (resp *Clien
 				if !gfile.Exists(path) {
 					return nil, errors.New(fmt.Sprintf(`"%s" does not exist`, path))
 				}
-				if file, err := writer.CreateFormFile(array[0], path); err == nil {
+				if file, err := writer.CreateFormFile(array[0], gfile.Basename(path)); err == nil {
 					if f, err := os.Open(path); err == nil {
 						if _, err = io.Copy(file, f); err != nil {
 							f.Close()
@@ -227,6 +227,10 @@ func (c *Client) DoRequest(method, url string, data ...interface{}) (resp *Clien
 	req.Body = utils.NewReadCloser(reqBodyContent, false)
 	for {
 		if resp.Response, err = c.Do(req); err != nil {
+			// The response might not be nil when err != nil.
+			if resp.Response != nil {
+				resp.Response.Body.Close()
+			}
 			if c.retryCount > 0 {
 				c.retryCount--
 				time.Sleep(c.retryInterval)

net/ghttp/ghttp_client_response.go

@@ -63,6 +63,9 @@ func (r *ClientResponse) ReadAllString() string {
 
 // Close closes the response when it will never be used.
 func (r *ClientResponse) Close() error {
+	if r == nil || r.Response == nil || r.Response.Close {
+		return nil
+	}
 	r.Response.Close = true
 	return r.Response.Body.Close()
 }

net/ghttp/ghttp_client_var.go

@@ -0,0 +1,77 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp
+
+import (
+	"github.com/gogf/gf/container/gvar"
+)
+
+// GetVar sends a GET request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, etc.
+func (c *Client) GetVar(url string, data ...interface{}) *gvar.Var {
+	return c.RequestVar("GET", url, data...)
+}
+
+// PutVar sends a PUT request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, etc.
+func (c *Client) PutVar(url string, data ...interface{}) *gvar.Var {
+	return c.RequestVar("PUT", url, data...)
+}
+
+// PostVar sends a POST request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, etc.
+func (c *Client) PostVar(url string, data ...interface{}) *gvar.Var {
+	return c.RequestVar("POST", url, data...)
+}
+
+// DeleteVar sends a DELETE request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, etc.
+func (c *Client) DeleteVar(url string, data ...interface{}) *gvar.Var {
+	return c.RequestVar("DELETE", url, data...)
+}
+
+// HeadVar sends a HEAD request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, etc.
+func (c *Client) HeadVar(url string, data ...interface{}) *gvar.Var {
+	return c.RequestVar("HEAD", url, data...)
+}
+
+// PatchVar sends a PATCH request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, etc.
+func (c *Client) PatchVar(url string, data ...interface{}) *gvar.Var {
+	return c.RequestVar("PATCH", url, data...)
+}
+
+// ConnectVar sends a CONNECT request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, etc.
+func (c *Client) ConnectVar(url string, data ...interface{}) *gvar.Var {
+	return c.RequestVar("CONNECT", url, data...)
+}
+
+// OptionsVar sends a OPTIONS request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, etc.
+func (c *Client) OptionsVar(url string, data ...interface{}) *gvar.Var {
+	return c.RequestVar("OPTIONS", url, data...)
+}
+
+// TraceVar sends a TRACE request, retrieves and converts the result content to specified pointer.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, etc.
+func (c *Client) TraceVar(url string, data ...interface{}) *gvar.Var {
+	return c.RequestVar("TRACE", url, data...)
+}
+
+// RequestVar sends request using given HTTP method and data, retrieves converts the result
+// to specified pointer. It reads and closes the response object internally automatically.
+// The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, etc.
+func (c *Client) RequestVar(method string, url string, data ...interface{}) *gvar.Var {
+	response, err := c.DoRequest(method, url, data...)
+	if err != nil {
+		return gvar.New(nil)
+	}
+	defer response.Close()
+	return gvar.New(response.ReadAll())
+}

net/ghttp/ghttp_func.go

@@ -8,12 +8,17 @@ package ghttp
 
 import (
 	"github.com/gogf/gf/errors/gerror"
+	"github.com/gogf/gf/text/gstr"
 	"strings"
 
 	"github.com/gogf/gf/encoding/gurl"
 	"github.com/gogf/gf/util/gconv"
 )
 
+const (
+	fileUploadingKey = "@file:"
+)
+
 // BuildParams builds the request string for the http client. The <params> can be type of:
 // string/[]byte/map/struct/*struct.
 //
@@ -38,13 +43,22 @@ func BuildParams(params interface{}, noUrlEncode ...bool) (encodedParamStr strin
 	if len(noUrlEncode) == 1 {
 		urlEncode = !noUrlEncode[0]
 	}
+	// If there's file uploading, it ignores the url encoding.
+	if urlEncode {
+		for k, v := range m {
+			if gstr.Contains(k, fileUploadingKey) || gstr.Contains(gconv.String(v), fileUploadingKey) {
+				urlEncode = false
+				break
+			}
+		}
+	}
 	s := ""
 	for k, v := range m {
 		if len(encodedParamStr) > 0 {
 			encodedParamStr += "&"
 		}
 		s = gconv.String(v)
-		if urlEncode && len(s) > 6 && strings.Compare(s[0:6], "@file:") != 0 {
+		if urlEncode && len(s) > 6 && strings.Compare(s[0:6], fileUploadingKey) != 0 {
 			s = gurl.Encode(s)
 		}
 		encodedParamStr += k + "=" + s

net/ghttp/ghttp_request.go

@@ -9,14 +9,15 @@ package ghttp
 import (
 	"context"
 	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
 	"github.com/gogf/gf/internal/intlog"
 	"github.com/gogf/gf/os/gres"
 	"github.com/gogf/gf/os/gsession"
 	"github.com/gogf/gf/os/gview"
 	"github.com/gogf/gf/util/guid"
-	"net/http"
-	"strings"
-	"time"
 
 	"github.com/gogf/gf/os/gtime"
 	"github.com/gogf/gf/text/gregex"
@@ -126,6 +127,11 @@ func (r *Request) IsExited() bool {
 	return r.exit
 }
 
+// GetHeader retrieves and returns the header value with given <key>.
+func (r *Request) GetHeader(key string) string {
+	return r.Header.Get(key)
+}
+
 // GetHost returns current request host name, which might be a domain or an IP without port.
 func (r *Request) GetHost() string {
 	if len(r.parsedHost) == 0 {
@@ -150,6 +156,7 @@ func (r *Request) IsAjaxRequest() bool {
 }
 
 // GetClientIp returns the client ip of this request without port.
+// Note that this ip address might be modified by client header.
 func (r *Request) GetClientIp() string {
 	if len(r.clientIp) == 0 {
 		realIps := r.Header.Get("X-Forwarded-For")
@@ -173,17 +180,21 @@ func (r *Request) GetClientIp() string {
 			r.clientIp = r.Header.Get("X-Real-IP")
 		}
 		if r.clientIp == "" || strings.EqualFold("unknown", realIps) {
-			array, _ := gregex.MatchString(`(.+):(\d+)`, r.RemoteAddr)
-			if len(array) > 1 {
-				r.clientIp = array[1]
-			} else {
-				r.clientIp = r.RemoteAddr
-			}
+			r.clientIp = r.GetRemoteIp()
 		}
 	}
 	return r.clientIp
 }
 
+// GetRemoteIp returns the ip from RemoteAddr.
+func (r *Request) GetRemoteIp() string {
+	array, _ := gregex.MatchString(`(.+):(\d+)`, r.RemoteAddr)
+	if len(array) > 1 {
+		return array[1]
+	}
+	return r.RemoteAddr
+}
+
 // GetUrl returns current URL of this request.
 func (r *Request) GetUrl() string {
 	scheme := "http"
@@ -212,3 +223,13 @@ func (r *Request) GetReferer() string {
 func (r *Request) GetError() error {
 	return r.error
 }
+
+// ReloadParam is used for modifying request parameter.
+// Sometimes, we want to modify request parameters through middleware, but directly modifying Request.Body
+// is invalid, so it clears the parsed* marks to make the parameters re-parsed.
+func (r *Request) ReloadParam() {
+	r.parsedBody = false
+	r.parsedForm = false
+	r.parsedQuery = false
+	r.bodyContent = nil
+}