✨ improve clickhouse driver

fix issue #1755

.github/workflows/gf.yml

@@ -1,4 +1,4 @@
-name: GoFrame CI
+name: GoFrame Main CI
 
 
 on:
@@ -76,11 +76,18 @@ jobs:
           --health-timeout 5s
           --health-retries 10
 
+      clickhouse-server:
+        image: yandex/clickhouse-server
+        ports:
+          - 9000:9000
+          - 8123:8123
+          - 9001:9001
+
 
     # strategy set
     strategy:
       matrix:
-        go: ["1.15", "1.16", "1.17"]
+        go: ["1.16", "1.17"]
 
 
     steps:
@@ -89,7 +96,7 @@ jobs:
       with:
         timezoneLinux: "Asia/Shanghai"
 
-    - name: Checkout Repositary
+    - name: Checkout Repository
       uses: actions/checkout@v2
 
     - name: Set Up Go

.github/workflows/tag.yml

@@ -0,0 +1,30 @@
+name: GoFrame AutoCreating SubMod Tags
+
+on:
+  push:
+    # Sequence of patterns matched against refs/tags
+    tags:
+    - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+
+env:
+  TZ: Asia/Shanghai
+  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+
+jobs:
+  build:
+    name: Auto Creating Tags
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Github Code
+        uses: actions/checkout@v2
+
+      - name: Auto Creating Tags
+        run: |
+          git config --global user.email "tagrobot@goframe.org"
+          git config --global user.name  "TagRobot"
+          for file in `find contrib -name go.mod`; do
+              tag=$(dirname $file)/$GITHUB_REF_NAME
+              git tag $tag
+              git push origin $tag
+          done

.gitignore

@@ -13,7 +13,6 @@ pkg/
 bin/
 cbuild
 **/.DS_Store
-.vscode/
 .test/
 main
 gf

cmd/gf/README.MD

@@ -5,6 +5,7 @@
 
 ## 1. Install
 
+## 1) PreCompiled Binary
 You can also install `gf` tool using pre-built binaries: https://github.com/gogf/gf/releases
 
 1. `Mac` & `Linux`
@@ -19,6 +20,13 @@ You can also install `gf` tool using pre-built binaries: https://github.com/gogf
 
 3. Database `sqlite` and `oracle` are not support in `gf gen` command in default as it needs `cgo` and `gcc`, you can manually make some changes to the source codes and do the building.
 
+## 2) Manually Install
+
+ ```shell
+git clone https://github.com/gogf/gf && cd gf/cmd/gf && go install
+ ```
+
+
 ## 2. Commands
 ```html
 $ gf

cmd/gf/go.mod

@@ -3,15 +3,17 @@ module github.com/gogf/gf/cmd/gf/v2
 go 1.15
 
 require (
-	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.0.0-rc2
-	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.0.0-rc2
-	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.0.0-rc2
-	github.com/gogf/gf/v2 v2.0.0-rc
+	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.0.6
+	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.0.6
+	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.0.6
+	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.0.6
+	github.com/gogf/gf/v2 v2.0.6
 	github.com/olekukonko/tablewriter v0.0.5
 )
 
 replace (
 	github.com/gogf/gf/contrib/drivers/mssql/v2 => ../../contrib/drivers/mssql/
+	github.com/gogf/gf/contrib/drivers/oracle/v2 => ../../contrib/drivers/oracle/
 	github.com/gogf/gf/contrib/drivers/pgsql/v2 => ../../contrib/drivers/pgsql/
 	github.com/gogf/gf/contrib/drivers/sqlite/v2 => ../../contrib/drivers/sqlite/
 	github.com/gogf/gf/v2 => ../../

cmd/gf/go.sum

@@ -22,6 +22,8 @@ github.com/go-redis/redis/v8 v8.11.4/go.mod h1:2Z2wHZXdQpCDXEGzqMockDpNyYvi2l4Px
 github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
 github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
+github.com/go-test/deep v1.0.7 h1:/VSMRlnY/JSyqxQUzQLKVMAskpY/NZKFA5j2P+0pP2M=
+github.com/go-test/deep v1.0.7/go.mod h1:QV8Hv/iy04NyLBxAdO9njL0iVPN1S4d/A3NVv1V36o8=
 github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe h1:lXe2qZdvpiX5WZkZR4hgp4KJVfY3nMkvmwbVkpv1rVY=
 github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
@@ -40,18 +42,22 @@ github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
 github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
-github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
+github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grokify/html-strip-tags-go v0.0.1 h1:0fThFwLbW7P/kOiTBs03FsJSV9RM2M/Q/MOnCQxKMo0=
 github.com/grokify/html-strip-tags-go v0.0.1/go.mod h1:2Su6romC5/1VXOQMaWL2yb618ARB8iVo6/DR99A6d78=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/lib/pq v1.10.4 h1:SO9z7FRPzA03QhHKJrH5BXA6HU1rS4V2nIVrrNC1iYk=
 github.com/lib/pq v1.10.4/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/longbridgeapp/sqlparser v0.3.1 h1:iWOZWGIFgQrJRgobLXUNJdvqGRpbVXkyKUKUA5CNJBE=
+github.com/longbridgeapp/sqlparser v0.3.1/go.mod h1:GIHaUq8zvYyHLCLMJJykx1CdM6LHtkUih/QaJXySSx4=
 github.com/mattn/go-colorable v0.1.9 h1:sqDoxXbdeALODt0DAeJCVp38ps9ZogZEAXjus69YV3U=
 github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-oci8 v0.1.1 h1:aEUDxNAyDG0tv8CA3TArnDQNyc4EhnWlsfxRgDHABHM=
+github.com/mattn/go-oci8 v0.1.1/go.mod h1:wjDx6Xm9q7dFtHJvIlrI99JytznLw5wQ4R+9mNXJwGI=
 github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
 github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/mattn/go-sqlite3 v1.14.10 h1:MLn+5bFRlWMGoSRmJour3CL1w/qL96mvipqpwQW/Sfk=

cmd/gf/internal/cmd/cmd_build.go

@@ -25,7 +25,7 @@ import (
 var (
 	Build = cBuild{
 		nodeNameInConfigFile: "gfcli.build",
-		packedGoFileName:     "build_pack_data.go",
+		packedGoFileName:     "internal/packed/build_pack_data.go",
 	}
 )
 
@@ -108,20 +108,21 @@ func init() {
 }
 
 type cBuildInput struct {
-	g.Meta  `name:"build" config:"gfcli.build"`
-	File    string `name:"FILE" arg:"true"   brief:"building file path"`
-	Name    string `short:"n" name:"name"    brief:"output binary name"`
-	Version string `short:"v" name:"version" brief:"output binary version"`
-	Arch    string `short:"a" name:"arch"    brief:"output binary architecture, multiple arch separated with ','"`
-	System  string `short:"s" name:"system"  brief:"output binary system, multiple os separated with ','"`
-	Output  string `short:"o" name:"output"  brief:"output binary path, used when building single binary file"`
-	Path    string `short:"p" name:"path"    brief:"output binary directory path, default is './temp'" d:"./temp"`
-	Extra   string `short:"e" name:"extra"   brief:"extra custom \"go build\" options"`
-	Mod     string `short:"m" name:"mod"     brief:"like \"-mod\" option of \"go build\", use \"-m none\" to disable go module"`
-	Cgo     bool   `short:"c" name:"cgo"     brief:"enable or disable cgo feature, it's disabled in default" orphan:"true"`
-	VarMap  g.Map  `short:"r" name:"varMap"  brief:"custom built embedded variable into binary"`
-	Exit    bool   `name:"exit" brief:"exit building when any error occurs, default is false" orphan:"true"`
-	Pack    string `name:"pack" brief:"pack specified folder into temporary go file before building and removes it after built"`
+	g.Meta        `name:"build" config:"gfcli.build"`
+	File          string `name:"FILE" arg:"true"   brief:"building file path"`
+	Name          string `short:"n"  name:"name"    brief:"output binary name"`
+	Version       string `short:"v"  name:"version" brief:"output binary version"`
+	Arch          string `short:"a"  name:"arch"    brief:"output binary architecture, multiple arch separated with ','"`
+	System        string `short:"s"  name:"system"  brief:"output binary system, multiple os separated with ','"`
+	Output        string `short:"o"  name:"output"  brief:"output binary path, used when building single binary file"`
+	Path          string `short:"p"  name:"path"    brief:"output binary directory path, default is './temp'" d:"./temp"`
+	Extra         string `short:"e"  name:"extra"   brief:"extra custom \"go build\" options"`
+	Mod           string `short:"m"  name:"mod"     brief:"like \"-mod\" option of \"go build\", use \"-m none\" to disable go module"`
+	Cgo           bool   `short:"c"  name:"cgo"     brief:"enable or disable cgo feature, it's disabled in default" orphan:"true"`
+	VarMap        g.Map  `short:"r"  name:"varMap"  brief:"custom built embedded variable into binary"`
+	PackSrc       string `short:"ps" name:"packSrc" brief:"pack one or more folders into one go file before building"`
+	PackDst       string `short:"pd" name:"packDst" brief:"temporary go file path for pack, this go file will be automatically removed after built" d:"internal/packed/build_pack_data.go"`
+	ExitWhenError bool   `short:"ew" name:"exitWhenError" brief:"exit building when any error occurs, default is false" orphan:"true"`
 }
 type cBuildOutput struct{}
 
@@ -189,16 +190,21 @@ func (c cBuild) Index(ctx context.Context, in cBuildInput) (out *cBuildOutput, e
 		platformMap[system][arch] = true
 	}
 	// Auto packing.
-	if len(in.Pack) > 0 {
-		dataFilePath := fmt.Sprintf(`packed/%s`, c.packedGoFileName)
-		if !gfile.Exists(dataFilePath) {
+	if in.PackSrc != "" {
+		if in.PackDst == "" {
+			mlog.Fatal(`parameter "packDst" should not be empty when "packSrc" is used`)
+		}
+		if gfile.Exists(in.PackDst) && !gfile.IsFile(in.PackDst) {
+			mlog.Fatalf(`parameter "packDst" path "%s" should be type of file not directory`, in.PackDst)
+		}
+		if !gfile.Exists(in.PackDst) {
 			// Remove the go file that is automatically packed resource.
 			defer func() {
-				_ = gfile.Remove(dataFilePath)
-				mlog.Printf(`remove the automatically generated resource go file: %s`, dataFilePath)
+				_ = gfile.Remove(in.PackDst)
+				mlog.Printf(`remove the automatically generated resource go file: %s`, in.PackDst)
 			}()
 		}
-		packCmd := fmt.Sprintf(`gf pack %s %s`, in.Pack, dataFilePath)
+		packCmd := fmt.Sprintf(`gf pack %s %s`, in.PackSrc, in.PackDst)
 		mlog.Print(packCmd)
 		gproc.MustShellRun(packCmd)
 	}
@@ -261,7 +267,7 @@ func (c cBuild) Index(ctx context.Context, in cBuildInput) (out *cBuildOutput, e
 					system, arch, gstr.Trim(result),
 					`you may use command option "--debug" to enable debug info and check the details`,
 				)
-				if in.Exit {
+				if in.ExitWhenError {
 					os.Exit(1)
 				}
 			} else {

cmd/gf/internal/cmd/cmd_gen_dao.go

@@ -35,7 +35,7 @@ const (
 	cGenDaoEg         = `
 gf gen dao
 gf gen dao -l "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
-gf gen dao -p ./model -c config.yaml -g user-center -t user,user_detail,user_login
+gf gen dao -p ./model -g user-center -t user,user_detail,user_login
 gf gen dao -r user_
 `
 

cmd/gf/internal/cmd/cmd_run.go

@@ -13,6 +13,7 @@ import (
 	"github.com/gogf/gf/v2/os/gproc"
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/os/gtimer"
+	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gtag"
 )
 
@@ -149,9 +150,9 @@ func (app *cRunApp) Run() {
 	if runtime.GOOS == "windows" {
 		// Special handling for windows platform.
 		// DO NOT USE "cmd /c" command.
-		process = gproc.NewProcess(runCommand, nil)
+		process = gproc.NewProcess(outputPath, gstr.SplitAndTrim(" ", app.Args))
 	} else {
-		process = gproc.NewProcessCmd(runCommand, nil)
+		process = gproc.NewProcessCmd(outputPath, gstr.SplitAndTrim(" ", app.Args))
 	}
 	if pid, err := process.Start(); err != nil {
 		mlog.Printf("build running error: %s", err.Error())

cmd/gf/internal/consts/consts_gen_dao_template_dao.go

@@ -11,10 +11,13 @@ import (
 	"{TplImportPrefix}/internal"
 )
 
+// internal{TplTableNameCamelCase}Dao is internal type for wrapping internal DAO implements.
+type internal{TplTableNameCamelCase}Dao = *internal.{TplTableNameCamelCase}Dao
+
 // {TplTableNameCamelLowerCase}Dao is the data access object for table {TplTableName}.
 // You can define custom methods on it to extend its functionality as you wish.
 type {TplTableNameCamelLowerCase}Dao struct {
-	*internal.{TplTableNameCamelCase}Dao
+	internal{TplTableNameCamelCase}Dao
 }
 
 var (

container/garray/garray_normal_any.go

@@ -503,16 +503,25 @@ func (a *Array) Search(value interface{}) int {
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *Array) Unique() *Array {
 	a.mu.Lock()
-	for i := 0; i < len(a.array)-1; i++ {
-		for j := i + 1; j < len(a.array); {
-			if a.array[i] == a.array[j] {
-				a.array = append(a.array[:j], a.array[j+1:]...)
-			} else {
-				j++
-			}
-		}
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
 	}
-	a.mu.Unlock()
+	var (
+		ok          bool
+		temp        interface{}
+		uniqueSet   = make(map[interface{}]struct{})
+		uniqueArray = make([]interface{}, 0, len(a.array))
+	)
+	for i := 0; i < len(a.array); i++ {
+		temp = a.array[i]
+		if _, ok = uniqueSet[temp]; ok {
+			continue
+		}
+		uniqueSet[temp] = struct{}{}
+		uniqueArray = append(uniqueArray, temp)
+	}
+	a.array = uniqueArray
 	return a
 }
 
@@ -711,6 +720,9 @@ func (a *Array) IteratorDesc(f func(k int, v interface{}) bool) {
 
 // String returns current array as a string, which implements like json.Marshal does.
 func (a *Array) String() string {
+	if a == nil {
+		return ""
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)

container/garray/garray_normal_int.go

@@ -514,16 +514,25 @@ func (a *IntArray) Search(value int) int {
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *IntArray) Unique() *IntArray {
 	a.mu.Lock()
-	for i := 0; i < len(a.array)-1; i++ {
-		for j := i + 1; j < len(a.array); {
-			if a.array[i] == a.array[j] {
-				a.array = append(a.array[:j], a.array[j+1:]...)
-			} else {
-				j++
-			}
-		}
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
 	}
-	a.mu.Unlock()
+	var (
+		ok          bool
+		temp        int
+		uniqueSet   = make(map[int]struct{})
+		uniqueArray = make([]int, 0, len(a.array))
+	)
+	for i := 0; i < len(a.array); i++ {
+		temp = a.array[i]
+		if _, ok = uniqueSet[temp]; ok {
+			continue
+		}
+		uniqueSet[temp] = struct{}{}
+		uniqueArray = append(uniqueArray, temp)
+	}
+	a.array = uniqueArray
 	return a
 }
 
@@ -722,6 +731,9 @@ func (a *IntArray) IteratorDesc(f func(k int, v int) bool) {
 
 // String returns current array as a string, which implements like json.Marshal does.
 func (a *IntArray) String() string {
+	if a == nil {
+		return ""
+	}
 	return "[" + a.Join(",") + "]"
 }
 

container/garray/garray_normal_str.go

@@ -516,16 +516,25 @@ func (a *StrArray) Search(value string) int {
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *StrArray) Unique() *StrArray {
 	a.mu.Lock()
-	for i := 0; i < len(a.array)-1; i++ {
-		for j := i + 1; j < len(a.array); {
-			if a.array[i] == a.array[j] {
-				a.array = append(a.array[:j], a.array[j+1:]...)
-			} else {
-				j++
-			}
-		}
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
 	}
-	a.mu.Unlock()
+	var (
+		ok          bool
+		temp        string
+		uniqueSet   = make(map[string]struct{})
+		uniqueArray = make([]string, 0, len(a.array))
+	)
+	for i := 0; i < len(a.array); i++ {
+		temp = a.array[i]
+		if _, ok = uniqueSet[temp]; ok {
+			continue
+		}
+		uniqueSet[temp] = struct{}{}
+		uniqueArray = append(uniqueArray, temp)
+	}
+	a.array = uniqueArray
 	return a
 }
 
@@ -724,6 +733,9 @@ func (a *StrArray) IteratorDesc(f func(k int, v string) bool) {
 
 // String returns current array as a string, which implements like json.Marshal does.
 func (a *StrArray) String() string {
+	if a == nil {
+		return ""
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)

container/garray/garray_sorted_any.go

@@ -36,9 +36,9 @@ type SortedArray struct {
 // NewSortedArray creates and returns an empty sorted array.
 // The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.
 // The parameter `comparator` used to compare values to sort in array,
-// if it returns value < 0, means v1 < v2; the v1 will be inserted before v2;
-// if it returns value = 0, means v1 = v2; the v1 will be replaced by v2;
-// if it returns value > 0, means v1 > v2; the v1 will be inserted after v2;
+// if it returns value < 0, means `a` < `b`; the `a` will be inserted before `b`;
+// if it returns value = 0, means `a` = `b`; the `a` will be replaced by     `b`;
+// if it returns value > 0, means `a` > `b`; the `a` will be inserted after  `b`;
 func NewSortedArray(comparator func(a, b interface{}) int, safe ...bool) *SortedArray {
 	return NewSortedArraySize(0, comparator, safe...)
 }
@@ -653,6 +653,9 @@ func (a *SortedArray) IteratorDesc(f func(k int, v interface{}) bool) {
 
 // String returns current array as a string, which implements like json.Marshal does.
 func (a *SortedArray) String() string {
+	if a == nil {
+		return ""
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)

container/garray/garray_sorted_int.go

@@ -646,6 +646,9 @@ func (a *SortedIntArray) IteratorDesc(f func(k int, v int) bool) {
 
 // String returns current array as a string, which implements like json.Marshal does.
 func (a *SortedIntArray) String() string {
+	if a == nil {
+		return ""
+	}
 	return "[" + a.Join(",") + "]"
 }
 

container/garray/garray_sorted_str.go

@@ -648,6 +648,9 @@ func (a *SortedStrArray) IteratorDesc(f func(k int, v string) bool) {
 
 // String returns current array as a string, which implements like json.Marshal does.
 func (a *SortedStrArray) String() string {
+	if a == nil {
+		return ""
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)

container/glist/glist.go

@@ -503,6 +503,9 @@ func (l *List) Join(glue string) string {
 
 // String returns current list as a string.
 func (l *List) String() string {
+	if l == nil {
+		return ""
+	}
 	return "[" + l.Join(",") + "]"
 }
 

container/gmap/gmap_hash_any_any_map.go

@@ -456,6 +456,9 @@ func (m *AnyAnyMap) Merge(other *AnyAnyMap) {
 
 // String returns the map as a string.
 func (m *AnyAnyMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }

container/gmap/gmap_hash_int_any_map.go

@@ -455,6 +455,9 @@ func (m *IntAnyMap) Merge(other *IntAnyMap) {
 
 // String returns the map as a string.
 func (m *IntAnyMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }

container/gmap/gmap_hash_int_int_map.go

@@ -426,6 +426,9 @@ func (m *IntIntMap) Merge(other *IntIntMap) {
 
 // String returns the map as a string.
 func (m *IntIntMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }

container/gmap/gmap_hash_int_str_map.go

@@ -426,6 +426,9 @@ func (m *IntStrMap) Merge(other *IntStrMap) {
 
 // String returns the map as a string.
 func (m *IntStrMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }

container/gmap/gmap_hash_str_any_map.go

@@ -451,6 +451,9 @@ func (m *StrAnyMap) Merge(other *StrAnyMap) {
 
 // String returns the map as a string.
 func (m *StrAnyMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }

container/gmap/gmap_hash_str_int_map.go

@@ -430,6 +430,9 @@ func (m *StrIntMap) Merge(other *StrIntMap) {
 
 // String returns the map as a string.
 func (m *StrIntMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }

container/gmap/gmap_hash_str_str_map.go

@@ -429,6 +429,9 @@ func (m *StrStrMap) Merge(other *StrStrMap) {
 
 // String returns the map as a string.
 func (m *StrStrMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }

container/gmap/gmap_list_map.go

@@ -521,6 +521,9 @@ func (m *ListMap) Merge(other *ListMap) {
 
 // String returns the map as a string.
 func (m *ListMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }

container/gset/gset_any_set.go

@@ -223,6 +223,9 @@ func (set *Set) Join(glue string) string {
 
 // String returns items as a string, which implements like json.Marshal does.
 func (set *Set) String() string {
+	if set == nil {
+		return ""
+	}
 	set.mu.RLock()
 	defer set.mu.RUnlock()
 	var (

container/gset/gset_int_set.go

@@ -204,6 +204,9 @@ func (set *IntSet) Join(glue string) string {
 
 // String returns items as a string, which implements like json.Marshal does.
 func (set *IntSet) String() string {
+	if set == nil {
+		return ""
+	}
 	return "[" + set.Join(",") + "]"
 }
 

container/gset/gset_str_set.go

@@ -218,6 +218,9 @@ func (set *StrSet) Join(glue string) string {
 
 // String returns items as a string, which implements like json.Marshal does.
 func (set *StrSet) String() string {
+	if set == nil {
+		return ""
+	}
 	set.mu.RLock()
 	defer set.mu.RUnlock()
 	var (

container/gtree/gtree_avltree.go

@@ -399,6 +399,9 @@ func (tree *AVLTree) Replace(data map[interface{}]interface{}) {
 
 // String returns a string representation of container
 func (tree *AVLTree) String() string {
+	if tree == nil {
+		return ""
+	}
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
 	str := ""

container/gtree/gtree_btree.go

@@ -367,6 +367,9 @@ func (tree *BTree) Right() *BTreeEntry {
 
 // String returns a string representation of container (for debugging purposes)
 func (tree *BTree) String() string {
+	if tree == nil {
+		return ""
+	}
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
 	var buffer bytes.Buffer

container/gtree/gtree_redblacktree.go

@@ -623,6 +623,9 @@ func (tree *RedBlackTree) Replace(data map[interface{}]interface{}) {
 
 // String returns a string representation of container.
 func (tree *RedBlackTree) String() string {
+	if tree == nil {
+		return ""
+	}
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
 	str := ""

contrib/drivers/README.md

@@ -14,9 +14,11 @@ import _ "github.com/gogf/gf/contrib/drivers/pgsql/v2"
 
 # Supported Drivers
 
-## MySQL
+## MySQL/MariaDB/TiDB
 
-BuiltIn supported, nothing todo.
+```
+import _ "github.com/gogf/gf/contrib/drivers/mysql/v2"
+```
 
 ## SQLite
 ```
@@ -50,6 +52,15 @@ Note:
 - It does not support `Save/Replace` features.
 - It does not support `LastInsertId`.
 
+## ClickHouse
+```
+import _ "github.com/gogf/gf/contrib/drivers/clickhouse/v2"
+```
+Note:
+- It does not support `InsertIgnore/InsertGetId` features.
+- It does not support `Transaction` feature.
+- It does not support `RowsAffected` feature.
+
 # Custom Drivers
 
 It's quick and easy, please refer to current driver source. 

contrib/drivers/clickhouse/clickhouse.go

@@ -8,5 +8,363 @@
 package clickhouse
 
 import (
-	_ "github.com/ClickHouse/clickhouse-go"
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"github.com/ClickHouse/clickhouse-go/v2"
+	"github.com/longbridgeapp/sqlparser"
+	"net/url"
+	"strings"
+
+	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
 )
+
+// Driver is the driver for postgresql database.
+type Driver struct {
+	*gdb.Core
+}
+
+var (
+	// tableFieldsMap caches the table information retrieved from database.
+	tableFieldsMap             = gmap.New(true)
+	errUnsupportedInsertIgnore = errors.New("unsupported method:InsertIgnore")
+	errUnsupportedInsertGetId  = errors.New("unsupported method:InsertGetId")
+	errUnsupportedReplace      = errors.New("unsupported method:Replace")
+	errUnsupportedBegin        = errors.New("unsupported method:Begin")
+	errUnsupportedTransaction  = errors.New("unsupported method:Transaction")
+	errNotCondition            = errors.New("there should be WHERE condition statement for UPDATE/DELETE operation")
+	errNotAssignment           = errors.New("there should be WHERE condition statement for Assignment operation")
+)
+
+func init() {
+	if err := gdb.Register(`clickhouse`, New()); err != nil {
+		panic(err)
+	}
+}
+
+// New create and returns a driver that implements gdb.Driver, which supports operations for clickhouse.
+func New() gdb.Driver {
+	return &Driver{}
+}
+
+// New creates and returns a database object for clickhouse.
+// It implements the interface of gdb.Driver for extra database driver installation.
+func (d *Driver) New(core *gdb.Core, node *gdb.ConfigNode) (gdb.DB, error) {
+	return &Driver{
+		Core: core,
+	}, nil
+}
+
+// Open creates and returns an underlying sql.DB object for clickhouse.
+func (d *Driver) Open(config *gdb.ConfigNode) (*sql.DB, error) {
+	var (
+		source string
+		driver = "clickhouse"
+	)
+	if config.Link != "" {
+		source = config.Link
+	} else if config.Pass != "" {
+		source = fmt.Sprintf(
+			"clickhouse://%s:%s@%s:%s/%s?charset=%s&debug=%t",
+			config.User, url.PathEscape(config.Pass), config.Host, config.Port, config.Name, config.Charset, config.Debug)
+	} else {
+		source = fmt.Sprintf(
+			"clickhouse://%s@%s:%s/%s?charset=%s&debug=%t",
+			config.User, config.Host, config.Port, config.Name, config.Charset, config.Debug)
+	}
+	db, err := sql.Open(driver, source)
+	if err != nil {
+		return nil, err
+	}
+
+	return db, nil
+}
+
+// Tables retrieves and returns the tables of current schema.
+// It's mainly used in cli tool chain for automatically generating the models.
+func (d *Driver) Tables(ctx context.Context, schema ...string) (tables []string, err error) {
+	var result gdb.Result
+	link, err := d.SlaveLink(schema...)
+	if err != nil {
+		return nil, err
+	}
+	query := fmt.Sprintf("select name from `system`.tables where database = '%s'", d.GetConfig().Name)
+	result, err = d.DoSelect(ctx, link, query)
+	if err != nil {
+		return
+	}
+	for _, m := range result {
+		tables = append(tables, m["name"].String())
+	}
+	return
+}
+
+// TableFields retrieves and returns the fields' information of specified table of current schema.
+// Also see DriverMysql.TableFields.
+func (d *Driver) TableFields(
+	ctx context.Context, table string, schema ...string,
+) (fields map[string]*gdb.TableField, err error) {
+	charL, charR := d.GetChars()
+	table = gstr.Trim(table, charL+charR)
+	if gstr.Contains(table, " ") {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "function TableFields supports only single table operations")
+	}
+	useSchema := d.GetSchema()
+	if len(schema) > 0 && schema[0] != "" {
+		useSchema = schema[0]
+	}
+	v := tableFieldsMap.GetOrSetFuncLock(
+		fmt.Sprintf(`clickhouse_table_fields_%s_%s@group:%s`, table, useSchema, d.GetGroup()),
+		func() interface{} {
+			var (
+				result gdb.Result
+				link   gdb.Link
+			)
+			if link, err = d.SlaveLink(useSchema); err != nil {
+				return nil
+			}
+			getColumnsSql := fmt.Sprintf("select name,position,default_expression,comment,type from `system`.columns c where database = '%s' and `table` = '%s'", d.GetConfig().Name, table)
+			result, err = d.DoSelect(ctx, link, getColumnsSql)
+			if err != nil {
+				return nil
+			}
+			fields = make(map[string]*gdb.TableField)
+			for _, m := range result {
+				var (
+					isNull    = false
+					fieldType = m["type"].String()
+				)
+				// in clickhouse , filed type like is Nullable(int)
+				fieldsResult, _ := gregex.MatchString(`^Nullable\((.*?)\)`, fieldType)
+				if len(fieldsResult) == 2 {
+					isNull = true
+					fieldType = fieldsResult[1]
+				}
+				fields[m["name"].String()] = &gdb.TableField{
+					Index:   m["position"].Int(),
+					Name:    m["name"].String(),
+					Default: m["default_expression"].Val(),
+					Comment: m["comment"].String(),
+					//Key:     m["Key"].String(),
+					Type: fieldType,
+					Null: isNull,
+				}
+			}
+			return fields
+		},
+	)
+	if v != nil {
+		fields = v.(map[string]*gdb.TableField)
+	}
+	return
+}
+
+// FilteredLink retrieves and returns filtered `linkInfo` that can be using for
+// logging or tracing purpose.
+func (d *Driver) FilteredLink() string {
+	linkInfo := d.GetConfig().Link
+	if linkInfo == "" {
+		return ""
+	}
+	s, _ := gregex.ReplaceString(
+		`(.+?):(.+)@tcp(.+)`,
+		`$1:xxx@tcp$3`,
+		linkInfo,
+	)
+	return s
+}
+
+// PingMaster pings the master node to check authentication or keeps the connection alive.
+func (d *Driver) PingMaster() error {
+	conn, err := d.Master()
+	if err != nil {
+		return err
+	}
+	return d.ping(conn)
+}
+
+// PingSlave pings the slave node to check authentication or keeps the connection alive.
+func (d *Driver) PingSlave() error {
+	conn, err := d.Slave()
+	if err != nil {
+		return err
+	}
+	return d.ping(conn)
+}
+
+// ping Returns the Clickhouse specific error.
+func (d *Driver) ping(conn *sql.DB) error {
+	err := conn.Ping()
+	if exception, ok := err.(*clickhouse.Exception); ok {
+		return errors.New(fmt.Sprintf("[%d]%s", exception.Code, exception.Message))
+	}
+	return err
+}
+
+// DoFilter handles the sql before posts it to database.
+func (d *Driver) DoFilter(
+	ctx context.Context, link gdb.Link, originSql string, args []interface{},
+) (newSql string, newArgs []interface{}, err error) {
+	if len(args) == 0 {
+		return originSql, args, nil
+	}
+	var index int
+	// Convert placeholder char '?' to string "$x".
+	originSql, _ = gregex.ReplaceStringFunc(`\?`, originSql, func(s string) string {
+		index++
+		return fmt.Sprintf(`$%d`, index)
+	})
+	// replace STD SQL to Clickhouse SQL grammar
+	parsedStmt, err := sqlparser.NewParser(strings.NewReader(originSql)).ParseStatement()
+	if err != nil {
+		return "", nil, err
+	}
+	switch stmt := parsedStmt.(type) {
+	case *sqlparser.UpdateStatement:
+		// MySQL eg: UPDATE visits SET xxx
+		// Clickhouse eg: ALTER TABLE visits UPDATE xxx
+		newSql, err = d.doFilterUpdate(stmt)
+		if err != nil {
+			return originSql, args, err
+		}
+		return newSql, args, nil
+	case *sqlparser.DeleteStatement:
+		// MySQL eg: DELETE FROM VISIT
+		// Clickhouse eg: ALTER TABLE VISIT DELETE WHERE filter_expr
+		newSql, err = d.doFilterDelete(stmt)
+		if err != nil {
+			return originSql, args, err
+		}
+		return newSql, args, nil
+	}
+	return originSql, args, nil
+}
+
+func (d *Driver) doFilterDelete(stmt *sqlparser.DeleteStatement) (string, error) {
+	if stmt.Condition == nil {
+		return "", errNotCondition
+	}
+	var (
+		condition = stmt.Condition.String()
+		tableName = stmt.TableName
+	)
+	newSql := fmt.Sprintf("ALTER TABLE %s DELETE WHERE %s", tableName, condition)
+	return newSql, nil
+}
+
+func (d *Driver) doFilterUpdate(stmt *sqlparser.UpdateStatement) (string, error) {
+	if stmt.Condition == nil {
+		return "", errNotCondition
+	}
+	if len(stmt.Assignments) == 0 {
+		return "", errNotAssignment
+	}
+	var (
+		condition   = stmt.Condition.String()
+		assignment  string
+		tableName   = stmt.TableName
+		assignments = []string{}
+	)
+	for _, item := range stmt.Assignments {
+		assignments = append(assignments, item.String())
+	}
+	assignment = strings.Join(assignments, ",")
+	newSql := fmt.Sprintf("ALTER TABLE %s UPDATE %s WHERE %s", tableName, assignment, condition)
+	return newSql, nil
+}
+
+// DoCommit commits current sql and arguments to underlying sql driver.
+func (d *Driver) DoCommit(ctx context.Context, in gdb.DoCommitInput) (out gdb.DoCommitOutput, err error) {
+	ctx = d.InjectIgnoreResult(ctx)
+	return d.Core.DoCommit(ctx, in)
+}
+
+func (d *Driver) DoInsert(
+	ctx context.Context, link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
+) (result sql.Result, err error) {
+	var (
+		keys        []string // Field names.
+		valueHolder = make([]string, 0)
+	)
+	// Handle the field names and placeholders.
+	for k := range list[0] {
+		keys = append(keys, k)
+		valueHolder = append(valueHolder, "?")
+	}
+	// Prepare the batch result pointer.
+	var (
+		charL, charR = d.Core.GetChars()
+		keysStr      = charL + strings.Join(keys, charR+","+charL) + charR
+		holderStr    = strings.Join(valueHolder, ",")
+		tx           = &gdb.TX{}
+		stdSqlResult sql.Result
+		stmt         *gdb.Stmt
+	)
+	tx, err = d.Core.Begin(ctx)
+	if err != nil {
+		return
+	}
+	stmt, err = tx.Prepare(fmt.Sprintf(
+		"INSERT INTO %s(%s) VALUES (%s)",
+		d.QuotePrefixTableName(table), keysStr,
+		holderStr,
+	))
+	if err != nil {
+		return
+	}
+	for i := 0; i < len(list); i++ {
+		params := make([]interface{}, 0) // Values that will be committed to underlying database driver.
+		for _, k := range keys {
+			params = append(params, list[i][k])
+		}
+		// Prepare is allowed to execute only once in a transaction opened by clickhouse
+		stdSqlResult, err = stmt.ExecContext(ctx, params...)
+		if err != nil {
+			return stdSqlResult, err
+		}
+	}
+	return stdSqlResult, tx.Commit()
+}
+
+// ConvertDataForRecord converting for any data that will be inserted into table/collection as a record.
+func (d *Driver) ConvertDataForRecord(ctx context.Context, value interface{}) map[string]interface{} {
+	// Clickhouse does not need to preprocess the value and can be inserted directly
+	// So it is not processed here
+	return gconv.Map(value, gdb.OrmTagForStruct)
+}
+
+func (d *Driver) ConvertDataForRecordValue(ctx context.Context, value interface{}) interface{} {
+	// Clickhouse does not need to preprocess the value and can be inserted directly
+	// So it is not processed here
+	return value
+}
+
+// InsertIgnore Other queries for modifying data parts are not supported: REPLACE, MERGE, UPSERT, INSERT UPDATE.
+func (d *Driver) InsertIgnore(ctx context.Context, table string, data interface{}, batch ...int) (sql.Result, error) {
+	return nil, errUnsupportedInsertIgnore
+}
+
+// InsertAndGetId Other queries for modifying data parts are not supported: REPLACE, MERGE, UPSERT, INSERT UPDATE.
+func (d *Driver) InsertAndGetId(ctx context.Context, table string, data interface{}, batch ...int) (int64, error) {
+	return 0, errUnsupportedInsertGetId
+}
+
+// Replace Other queries for modifying data parts are not supported: REPLACE, MERGE, UPSERT, INSERT UPDATE.
+func (d *Driver) Replace(ctx context.Context, table string, data interface{}, batch ...int) (sql.Result, error) {
+	return nil, errUnsupportedReplace
+}
+
+func (d *Driver) Begin(ctx context.Context) (tx *gdb.TX, err error) {
+	return nil, errUnsupportedBegin
+}
+
+func (d *Driver) Transaction(ctx context.Context, f func(ctx context.Context, tx *gdb.TX) error) error {
+	return errUnsupportedTransaction
+}

contrib/drivers/clickhouse/clickhouse_test.go

@@ -0,0 +1,436 @@
+package clickhouse
+
+import (
+	"context"
+	"fmt"
+	"github.com/google/uuid"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/grand"
+)
+
+const (
+	sqlVisitsDDL = `
+CREATE TABLE IF NOT EXISTS visits (
+id UInt64,
+duration Float64,
+url String,
+created DateTime
+) ENGINE = MergeTree()
+PRIMARY KEY id
+ORDER BY id
+`
+	dimSqlDDL = `
+CREATE TABLE IF NOT EXISTS dim (
+"code" String COMMENT '编码',
+"translation" String COMMENT '译文',
+"superior" UInt64 COMMENT '上级ID',
+"row_number" UInt16 COMMENT '行号',
+"is_active" UInt8 COMMENT '是否激活',
+"is_preset" UInt8 COMMENT '是否预置',
+"category" String COMMENT '类别',
+"tree_path" Array(String) COMMENT '树路径',
+"id" UInt64 COMMENT '代理主键ID',
+"scd" UInt64 COMMENT '缓慢变化维ID',
+"version" UInt64 COMMENT 'Merge版本ID',
+"sign" Int8 COMMENT '标识位',
+"created_by" UInt64 COMMENT '创建者ID',
+"created_at" DateTime64(3,'Asia/Shanghai') COMMENT '创建时间',
+"updated_by" UInt64 COMMENT '最后修改者ID',
+"updated_at" DateTime64(3,'Asia/Shanghai') COMMENT '最后修改时间',
+"updated_tick" UInt16 COMMENT '累计修改次数'
+) ENGINE = ReplacingMergeTree("version")
+ORDER BY ("id","scd")
+COMMENT '会计准则';
+`
+	dimSqlDML = `
+insert into dim (code, translation, superior, row_number, is_active, is_preset, category, tree_path, id, scd, version, sign, created_by, created_at, updated_by, updated_at, updated_tick)
+values  ('CN', '{"zh_CN":"中国大陆会计准则","en_US":"Chinese mainland accounting legislation"}', 0, 1, 1, 1, 1, '[''CN'']', 607972403489804288, 0, 0, 0, 607536279118155777, '2017-09-06 00:00:00', 607536279118155777, '2017-09-06 00:00:00', 0),
+        ('HK', '{"zh_CN":"中国香港会计准则","en_US":"Chinese Hong Kong accounting legislation"}', 0, 2, 1, 1, 1, '[''HK'']', 607972558544834566, 0, 0, 0, 607536279118155777, '2017-09-06 00:00:00', 607536279118155777, '2017-09-06 00:00:00', 0);
+`
+	factSqlDDL = `
+CREATE TABLE IF NOT EXISTS fact (
+"adjustment_level" UInt64 COMMENT '调整层ID',
+"data_version" UInt64 COMMENT '数据版本ID',
+"accounting_legislation" UInt64 COMMENT '会计准则ID',
+"fiscal_year" UInt16 COMMENT '会计年度',
+"fiscal_period" UInt8 COMMENT '会计期间',
+"fiscal_year_period" UInt32 COMMENT '会计年度期间',
+"legal_entity" UInt64 COMMENT '法人主体ID',
+"cost_center" UInt64 COMMENT '成本中心ID',
+"legal_entity_partner" UInt64 COMMENT '内部关联方ID',
+"financial_posting" UInt64 COMMENT '凭证头ID',
+"line" UInt16 COMMENT '行号',
+"general_ledger_account" UInt64 COMMENT '总账科目ID',
+"debit" Decimal64(9) COMMENT '借方金额',
+"credit" Decimal64(9) COMMENT '贷方金额',
+"transaction_currency" UInt64 COMMENT '交易币种ID',
+"debit_tc" Decimal64(9) COMMENT '借方金额（交易币种）',
+"credit_tc" Decimal64(9) COMMENT '贷方金额（交易币种）',
+"posting_date" Date32 COMMENT '过账日期',
+"gc_year" UInt16 COMMENT '公历年',
+"gc_quarter" UInt8 COMMENT '公历季',
+"gc_month" UInt8 COMMENT '公历月',
+"gc_week" UInt8 COMMENT '公历周',
+"raw_info" String COMMENT '源信息',
+"summary" String COMMENT '摘要',
+"id" UInt64 COMMENT '代理主键ID',
+"version" UInt64 COMMENT 'Merge版本ID',
+"sign" Int8 COMMENT '标识位'
+) ENGINE = ReplacingMergeTree("version")
+ORDER BY ("adjustment_level","data_version","legal_entity","fiscal_year","fiscal_period","financial_posting","line")
+PARTITION BY ("adjustment_level","data_version","legal_entity","fiscal_year","fiscal_period")
+COMMENT '数据主表';
+`
+	factSqlDML = `
+insert into fact (adjustment_level, data_version, accounting_legislation, fiscal_year, fiscal_period, fiscal_year_period, legal_entity, cost_center, legal_entity_partner, financial_posting, line, general_ledger_account, debit, credit, transaction_currency, debit_tc, credit_tc, posting_date, gc_year, gc_quarter, gc_month, gc_week, raw_info, summary, id, version, sign)
+values  (607970943242866688, 607973669943119880, 607972403489804288, 2022, 3, 202203, 607974511316307985, 0, 607976190010986520, 607996702456025136, 1, 607985607569838111, 8674.39, 0, 607974898261823505, 8674.39, 0, '2022-03-05', 2022, 1, 3, 11, '{}', '摘要', 607992882741121073, 0, 0),
+        (607970943242866688, 607973669943119880, 607972403489804288, 2022, 4, 202204, 607974511316307985, 0, 607976190010986520, 607993586419503145, 1, 607985607569838111, 9999.88, 0, 607974898261823505, 9999.88, 0, '2022-04-10', 2022, 2, 4, 18, '{}', '摘要', 607996939140599857, 0, 0);
+`
+	expmSqlDDL = `
+		CREATE TABLE IF NOT EXISTS data_type (
+			  Col1 UInt8
+			, Col2 String
+			, Col3 FixedString(3)
+			, Col4 UUID
+			, Col5 Map(String, UInt8)
+			, Col6 Array(String)
+			, Col7 Tuple(String, UInt8, Array(Map(String, String)))
+			, Col8 DateTime
+		) ENGINE = MergeTree()
+		PRIMARY KEY Col4
+		ORDER BY Col4
+`
+)
+
+func clickhouseConfigDB() gdb.DB {
+	connect, err := gdb.New(gdb.ConfigNode{
+		Host: "127.0.0.1",
+		Port: "9000",
+		User: "default",
+		Name: "default",
+		Type: "clickhouse",
+	})
+	gtest.AssertNil(err)
+	gtest.AssertNE(connect, nil)
+	return connect
+}
+
+func createClickhouseTableVisits(connect gdb.DB) error {
+	_, err := connect.Exec(context.Background(), sqlVisitsDDL)
+	return err
+}
+
+func createClickhouseTableDim(connect gdb.DB) error {
+	_, err := connect.Exec(context.Background(), dimSqlDDL)
+	return err
+}
+
+func createClickhouseTableFact(connect gdb.DB) error {
+	_, err := connect.Exec(context.Background(), factSqlDDL)
+	return err
+}
+
+func createClickhouseExampleTable(connect gdb.DB) error {
+	_, err := connect.Exec(context.Background(), expmSqlDDL)
+	return err
+}
+
+func dropClickhouseTableVisits(conn gdb.DB) {
+	sqlStr := fmt.Sprintf("DROP TABLE IF EXISTS `visits`")
+	_, _ = conn.Exec(context.Background(), sqlStr)
+}
+
+func dropClickhouseTableDim(conn gdb.DB) {
+	sqlStr := fmt.Sprintf("DROP TABLE IF EXISTS `dim`")
+	_, _ = conn.Exec(context.Background(), sqlStr)
+}
+
+func dropClickhouseTableFact(conn gdb.DB) {
+	sqlStr := fmt.Sprintf("DROP TABLE IF EXISTS `fact`")
+	_, _ = conn.Exec(context.Background(), sqlStr)
+}
+
+func dropClickhouseExampleTable(conn gdb.DB) {
+	sqlStr := fmt.Sprintf("DROP TABLE IF EXISTS `data_type`")
+	_, _ = conn.Exec(context.Background(), sqlStr)
+}
+
+func TestDriverClickhouse_Create(t *testing.T) {
+	gtest.AssertNil(createClickhouseTableVisits(clickhouseConfigDB()))
+}
+
+func TestDriverClickhouse_New(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertNE(connect, nil)
+	gtest.AssertNil(connect.PingMaster())
+	gtest.AssertNil(connect.PingSlave())
+}
+
+func TestDriverClickhouse_OpenLink_Ping(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertNE(connect, nil)
+	gtest.AssertNil(connect.PingMaster())
+}
+
+func TestDriverClickhouse_Tables(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertEQ(createClickhouseTableVisits(connect), nil)
+	defer dropClickhouseTableVisits(connect)
+	tables, err := connect.Tables(context.Background())
+	gtest.AssertNil(err)
+	gtest.AssertNE(len(tables), 0)
+}
+
+func TestDriverClickhouse_TableFields_Use_Config(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertNil(createClickhouseTableVisits(connect))
+	defer dropClickhouseTableVisits(connect)
+	field, err := connect.TableFields(context.Background(), "visits")
+	gtest.AssertNil(err)
+	gtest.AssertEQ(len(field), 4)
+	gtest.AssertNQ(field, nil)
+}
+
+func TestDriverClickhouse_TableFields_Use_Link(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertNil(createClickhouseTableVisits(connect))
+	defer dropClickhouseTableVisits(connect)
+	field, err := connect.TableFields(context.Background(), "visits")
+	gtest.AssertNil(err)
+	gtest.AssertEQ(len(field), 4)
+	gtest.AssertNQ(field, nil)
+}
+
+func TestDriverClickhouse_Transaction(t *testing.T) {
+	connect := clickhouseConfigDB()
+	defer dropClickhouseTableVisits(connect)
+	gtest.AssertNE(connect.Transaction(context.Background(), func(ctx context.Context, tx *gdb.TX) error {
+		return nil
+	}), nil)
+}
+
+func TestDriverClickhouse_InsertIgnore(t *testing.T) {
+	connect := clickhouseConfigDB()
+	_, err := connect.InsertIgnore(context.Background(), "", nil)
+	gtest.AssertEQ(err, errUnsupportedInsertIgnore)
+}
+
+func TestDriverClickhouse_InsertAndGetId(t *testing.T) {
+	connect := clickhouseConfigDB()
+	_, err := connect.InsertAndGetId(context.Background(), "", nil)
+	gtest.AssertEQ(err, errUnsupportedInsertGetId)
+}
+
+func TestDriverClickhouse_InsertOne(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertEQ(createClickhouseTableVisits(connect), nil)
+	defer dropClickhouseTableVisits(connect)
+	_, err := connect.Model("visits").Data(g.Map{
+		"duration": float64(grand.Intn(999)),
+		"url":      gconv.String(grand.Intn(999)),
+		"created":  time.Now(),
+	}).Insert()
+	gtest.AssertNil(err)
+}
+
+func TestDriverClickhouse_InsertMany(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertEQ(createClickhouseTableVisits(connect), nil)
+	defer dropClickhouseTableVisits(connect)
+	tx, err := connect.Begin(context.Background())
+	gtest.AssertEQ(err, errUnsupportedBegin)
+	gtest.AssertNil(tx)
+}
+
+func TestDriverClickhouse_Insert(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertEQ(createClickhouseTableVisits(connect), nil)
+	defer dropClickhouseTableVisits(connect)
+	type insertItem struct {
+		Id       uint64    `orm:"id"`
+		Duration float64   `orm:"duration"`
+		Url      string    `orm:"url"`
+		Created  time.Time `orm:"created"`
+	}
+	var (
+		insertUrl = "https://goframe.org"
+		total     = 0
+		item      = insertItem{
+			Duration: 1,
+			Url:      insertUrl,
+			Created:  time.Now(),
+		}
+	)
+	_, err := connect.Model("visits").Data(item).Insert()
+	gtest.AssertNil(err)
+	_, err = connect.Model("visits").Data(item).Save()
+	gtest.AssertNil(err)
+	total, err = connect.Model("visits").Count()
+	gtest.AssertNil(err)
+	gtest.AssertEQ(total, 2)
+	var list []*insertItem
+	for i := 0; i < 50; i++ {
+		list = append(list, &insertItem{
+			Duration: float64(grand.Intn(999)),
+			Url:      insertUrl,
+			Created:  time.Now(),
+		})
+	}
+	_, err = connect.Model("visits").Data(list).Insert()
+	gtest.AssertNil(err)
+	_, err = connect.Model("visits").Data(list).Save()
+	gtest.AssertNil(err)
+	total, err = connect.Model("visits").Count()
+	gtest.AssertNil(err)
+	gtest.AssertEQ(total, 102)
+}
+
+func TestDriverClickhouse_Insert_Use_Exec(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertEQ(createClickhouseTableFact(connect), nil)
+	defer dropClickhouseTableFact(connect)
+	_, err := connect.Exec(context.Background(), factSqlDML)
+	gtest.AssertNil(err)
+}
+
+func TestDriverClickhouse_Delete(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertEQ(createClickhouseTableVisits(connect), nil)
+	defer dropClickhouseTableVisits(connect)
+	_, err := connect.Model("visits").Where("created >", "2021-01-01 00:00:00").Delete()
+	gtest.AssertNil(err)
+}
+
+func TestDriverClickhouse_Update(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertEQ(createClickhouseTableVisits(connect), nil)
+	defer dropClickhouseTableVisits(connect)
+	_, err := connect.Model("visits").Where("created > ", "2021-01-01 15:15:15").Data(g.Map{
+		"created": time.Now().Format("2006-01-02 15:04:05"),
+	}).Update()
+	gtest.AssertNil(err)
+}
+
+func TestDriverClickhouse_Replace(t *testing.T) {
+	connect := clickhouseConfigDB()
+	_, err := connect.Replace(context.Background(), "", nil)
+	gtest.AssertEQ(err, errUnsupportedReplace)
+}
+
+func TestDriverClickhouse_DoFilter(t *testing.T) {
+	rawSQL := "select * from visits where 1 = 1"
+	this := Driver{}
+	replaceSQL, _, err := this.DoFilter(nil, nil, rawSQL, []interface{}{1})
+	gtest.AssertNil(err)
+	gtest.AssertEQ(rawSQL, replaceSQL)
+
+	// this SQL can't run ,clickhouse will report an error because there is no WHERE statement
+	rawSQL = "update visit set url = '1'"
+	replaceSQL, _, err = this.DoFilter(nil, nil, rawSQL, []interface{}{1})
+	gtest.AssertEQ(err, errNotCondition)
+
+	// this SQL can't run ,clickhouse will report an error because there is no WHERE statement
+	rawSQL = "delete from visit"
+	replaceSQL, _, err = this.DoFilter(nil, nil, rawSQL, []interface{}{1})
+	gtest.AssertEQ(err, errNotCondition)
+
+	rawSQL = "update visit set url = '1' where url = '0'"
+	replaceSQL, _, err = this.DoFilter(nil, nil, rawSQL, []interface{}{1})
+	gtest.AssertNil(err)
+	gtest.AssertEQ(replaceSQL, "ALTER TABLE visit UPDATE url = '1' WHERE url = '0'")
+
+	rawSQL = "delete from visit where url='0'"
+	replaceSQL, _, err = this.DoFilter(nil, nil, rawSQL, []interface{}{1})
+	gtest.AssertNil(err)
+	gtest.AssertEQ(replaceSQL, "ALTER TABLE visit DELETE WHERE url = '0'")
+}
+
+func TestDriverClickhouse_Select(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertNil(createClickhouseTableVisits(connect))
+	defer dropClickhouseTableVisits(connect)
+	_, err := connect.Model("visits").Data(g.Map{
+		"url":      "goframe.org",
+		"duration": float64(1),
+	}).Insert()
+	gtest.AssertNil(err)
+	temp, err := connect.Model("visits").Where("url", "goframe.org").Where("duration >= ", 1).One()
+	gtest.AssertNil(err)
+	gtest.AssertEQ(temp.IsEmpty(), false)
+	_, err = connect.Model("visits").Data(g.Map{
+		"url":      "goframe.org",
+		"duration": float64(2),
+	}).Insert()
+	gtest.AssertNil(err)
+	data, err := connect.Model("visits").Where("url", "goframe.org").Where("duration >= ", 1).All()
+	gtest.AssertNil(err)
+	gtest.AssertEQ(len(data), 2)
+}
+
+func TestDriverClickhouse_Exec_OPTIMIZE(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertNil(createClickhouseTableVisits(connect))
+	defer dropClickhouseTableVisits(connect)
+	sqlStr := "OPTIMIZE table visits"
+	_, err := connect.Exec(context.Background(), sqlStr)
+	gtest.AssertNil(err)
+}
+
+func TestDriverClickhouse_ExecInsert(t *testing.T) {
+	connect := clickhouseConfigDB()
+	gtest.AssertEQ(createClickhouseTableDim(connect), nil)
+	defer dropClickhouseTableDim(connect)
+	_, err := connect.Exec(context.Background(), dimSqlDML)
+	gtest.AssertNil(err)
+}
+
+func TestDriverClickhouse_BatchInsert(t *testing.T) {
+	// example from
+	// https://github.com/ClickHouse/clickhouse-go/blob/v2/examples/std/batch/main.go
+	connect := clickhouseConfigDB()
+	gtest.AssertNil(createClickhouseExampleTable(connect))
+	defer dropClickhouseExampleTable(connect)
+	insertData := []g.Map{}
+	for i := 0; i < 10000; i++ {
+		insertData = append(insertData, g.Map{
+			"Col1": uint8(42),
+			"Col2": "ClickHouse",
+			"Col3": "Inc",
+			"Col4": uuid.New(),
+			"Col5": map[string]uint8{"key": 1},             // Map(String, UInt8)
+			"Col6": []string{"Q", "W", "E", "R", "T", "Y"}, // Array(String)
+			"Col7": []interface{}{ // Tuple(String, UInt8, Array(Map(String, String)))
+				"String Value", uint8(5), []map[string]string{
+					map[string]string{"key": "value"},
+					map[string]string{"key": "value"},
+					map[string]string{"key": "value"},
+				},
+			},
+			"Col8": time.Now(),
+		})
+	}
+	_, err := connect.Model("data_type").Data(insertData).Insert()
+	gtest.AssertNil(err)
+	count, err := connect.Model("data_type").Where("Col2", "ClickHouse").Where("Col3", "Inc").Count()
+	gtest.AssertNil(err)
+	gtest.AssertEQ(count, 10000)
+}
+
+func TestDriverClickhouse_Open(t *testing.T) {
+	// link
+	// DSM
+	// clickhouse://username:password@host1:9000,host2:9000/database?dial_timeout=200ms&max_execution_time=60
+	link := "clickhouse://default@127.0.0.1:9000,127.0.0.1:9000/default?dial_timeout=200ms&max_execution_time=60"
+	db, err := gdb.New(gdb.ConfigNode{
+		Link: link,
+		Type: "clickhouse",
+	})
+	gtest.AssertNil(err)
+	gtest.AssertNil(db.PingMaster())
+}

contrib/drivers/clickhouse/go.mod

@@ -3,11 +3,10 @@ module github.com/gogf/gf/contrib/drivers/clickhouse/v2
 go 1.15
 
 require (
-	github.com/ClickHouse/clickhouse-go v1.5.2
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/kr/pretty v0.1.0 // indirect
-	github.com/stretchr/testify v1.7.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
+	github.com/ClickHouse/clickhouse-go/v2 v2.0.12
+	github.com/gogf/gf/v2 v2.0.0
+	github.com/google/uuid v1.3.0
+	github.com/longbridgeapp/sqlparser v0.3.1
 )
 
+replace github.com/gogf/gf/v2 => ../../../

contrib/drivers/clickhouse/go.sum

@@ -1,32 +1,201 @@
-github.com/ClickHouse/clickhouse-go v1.5.2 h1:yXgaOZ8WEHrd+okvZXjzulSt1zS33nM4ujfx9lVncl8=
-github.com/ClickHouse/clickhouse-go v1.5.2/go.mod h1:EaI/sW7Azgz9UATzd5ZdZHRUhHgv5+JMS9NSr2smCJI=
-github.com/bkaradzic/go-lz4 v1.0.0 h1:RXc4wYsyz985CkXXeX04y4VnZFGG8Rd43pRaHsOXAKk=
+github.com/BurntSushi/toml v0.4.1 h1:GaI7EiDXDRfa8VshkTj7Fym7ha+y8/XxIgD2okUIjLw=
+github.com/BurntSushi/toml v0.4.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
+github.com/ClickHouse/clickhouse-go v1.5.3 h1:Vok8zUb/wlqc9u8oEqQzBMBRDoFd8NxPRqgYEqMnV88=
+github.com/ClickHouse/clickhouse-go v1.5.3/go.mod h1:EaI/sW7Azgz9UATzd5ZdZHRUhHgv5+JMS9NSr2smCJI=
+github.com/ClickHouse/clickhouse-go/v2 v2.0.12 h1:Nbl/NZwoM6LGJm7smNBgvtdr/rxjlIssSW3eG/Nmb9E=
+github.com/ClickHouse/clickhouse-go/v2 v2.0.12/go.mod h1:u4RoNQLLM2W6hNSPYrIESLJqaWSInZVmfM+MlaAhXcg=
+github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg=
 github.com/bkaradzic/go-lz4 v1.0.0/go.mod h1:0YdlkowM3VswSROI7qDxhRvJ3sLhlFrRRwjwegp5jy4=
-github.com/cloudflare/golz4 v0.0.0-20150217214814-ef862a3cdc58 h1:F1EaeKL/ta07PY/k9Os/UFtwERei2/XzGemhpGnBKNg=
+github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
+github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/clbanning/mxj/v2 v2.5.5 h1:oT81vUeEiQQ/DcHbzSytRngP6Ky9O+L+0Bw0zSJag9E=
+github.com/clbanning/mxj/v2 v2.5.5/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/cloudflare/golz4 v0.0.0-20150217214814-ef862a3cdc58/go.mod h1:EOBUe0h4xcZ5GoxqC5SDxFQ8gwyZPKQoEzownBlhI80=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
+github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
+github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/fsnotify/fsnotify v1.5.1 h1:mZcQUHVQUQWoPXXtuf9yuEXKudkV2sx1E06UadKWpgI=
+github.com/fsnotify/fsnotify v1.5.1/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU=
+github.com/go-logr/logr v1.2.2 h1:ahHml/yUpnlb96Rp8HCvtYVPY8ZYpxq3g7UYchIYwbs=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-ole/go-ole v1.2.4/go.mod h1:XCwSNxSkXRo4vlyPy93sltvi/qJq0jqQhjqQNIwKuxM=
+github.com/go-redis/redis/v8 v8.11.4 h1:kHoYkfZP6+pe04aFTnhDH6GDROa5yJdHJVNxV3F46Tg=
+github.com/go-redis/redis/v8 v8.11.4/go.mod h1:2Z2wHZXdQpCDXEGzqMockDpNyYvi2l4Pxt6RJr792+w=
 github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
+github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
+github.com/go-test/deep v1.0.7 h1:/VSMRlnY/JSyqxQUzQLKVMAskpY/NZKFA5j2P+0pP2M=
+github.com/go-test/deep v1.0.7/go.mod h1:QV8Hv/iy04NyLBxAdO9njL0iVPN1S4d/A3NVv1V36o8=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o=
+github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/handlers v1.4.2/go.mod h1:Qkdc/uu4tH4g6mTK6auzZ766c4CA0Ng8+o/OAirnOIQ=
+github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
+github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/grokify/html-strip-tags-go v0.0.1 h1:0fThFwLbW7P/kOiTBs03FsJSV9RM2M/Q/MOnCQxKMo0=
+github.com/grokify/html-strip-tags-go v0.0.1/go.mod h1:2Su6romC5/1VXOQMaWL2yb618ARB8iVo6/DR99A6d78=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/jmoiron/sqlx v1.2.0/go.mod h1:1FEQNm3xlJgrMD+FBdI9+xvCksHtbpVBBw5dYhBSsks=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/longbridgeapp/sqlparser v0.3.1 h1:iWOZWGIFgQrJRgobLXUNJdvqGRpbVXkyKUKUA5CNJBE=
+github.com/longbridgeapp/sqlparser v0.3.1/go.mod h1:GIHaUq8zvYyHLCLMJJykx1CdM6LHtkUih/QaJXySSx4=
+github.com/mattn/go-colorable v0.1.9 h1:sqDoxXbdeALODt0DAeJCVp38ps9ZogZEAXjus69YV3U=
+github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
+github.com/mkevac/debugcharts v0.0.0-20191222103121-ae1c48aa8615/go.mod h1:Ad7oeElCZqA1Ufj0U9/liOF4BtVepxRcTvr2ey7zTvM=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
+github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc=
+github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/onsi/gomega v1.16.0 h1:6gjqkI8iiRHMvdccRJM8rVKjCWk6ZIm6FTm3ddIe4/c=
+github.com/onsi/gomega v1.16.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
+github.com/paulmach/orb v0.4.0 h1:ilp1MQjRapLJ1+qcays1nZpe0mvkCY+b8JU/qBKRZ1A=
+github.com/paulmach/orb v0.4.0/go.mod h1:FkcWtplUAIVqAuhAOV2d3rpbnQyliDOjOcLW9dUrfdU=
+github.com/paulmach/protoscan v0.2.1-0.20210522164731-4e53c6875432/go.mod h1:2sV+uZ/oQh66m4XJVZm5iqUZ62BN88Ex1E+TTS0nLzI=
 github.com/pierrec/lz4 v2.0.5+incompatible h1:2xWsjqPFWcplujydGg4WmhC/6fZqK42wMM8aXeqhl0I=
 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
+github.com/pierrec/lz4/v4 v4.1.14 h1:+fL8AQEZtz/ijeNnpduH0bROTu0O3NZAlPjQxGn8LwE=
+github.com/pierrec/lz4/v4 v4.1.14/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/shirou/gopsutil v2.19.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
+github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4/go.mod h1:qsXQc7+bwAM3Q1u/4XEfrquwF8Lw7D7y5cD8CuHnfIc=
+github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8=
+github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.4.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+go.opentelemetry.io/otel v1.0.0/go.mod h1:AjRVh9A5/5DE7S+mZtTR6t8vpKKryam+0lREnfmS4cg=
+go.opentelemetry.io/otel v1.4.1 h1:QbINgGDDcoQUoMJa2mMaWno49lja9sHwp6aoa2n3a4g=
+go.opentelemetry.io/otel v1.4.1/go.mod h1:StM6F/0fSwpd8dKWDCdRr7uRvEPYdW0hBSlbdTiUde4=
+go.opentelemetry.io/otel/sdk v1.0.0 h1:BNPMYUONPNbLneMttKSjQhOTlFLOD9U22HNG1KrIN2Y=
+go.opentelemetry.io/otel/sdk v1.0.0/go.mod h1:PCrDHlSy5x1kjezSdL37PhbFUMjrsLRshJ2zCzeXwbM=
+go.opentelemetry.io/otel/trace v1.0.0/go.mod h1:PXTWqayeFUlJV1YDNhsJYB184+IvAH814St6o6ajzIs=
+go.opentelemetry.io/otel/trace v1.4.1 h1:O+16qcdTrT7zxv2J6GejTPFinSwA++cYerC5iSiF8EQ=
+go.opentelemetry.io/otel/trace v1.4.1/go.mod h1:iYEVbroFCNut9QkwEczV9vMRPHNKSSwYZjulEtsmhFc=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
+golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2 h1:CIJ76btIcR3eFI5EgSo6k1qKw9KJexJuRLI9G7Hp5wE=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191220220014-0732a990476f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211110154304-99a53858aa08 h1:WecRHqgE09JBkh/584XIE6PMz5KKE/vER4izNUi30AQ=
+golang.org/x/sys v0.0.0-20211110154304-99a53858aa08/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2 h1:GLw7MR8AfAG2GmGcmVgObFOHXYypgGjnGno25RDwn3Y=
+golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2/go.mod h1:EFNZuWvGYxIRUEX+K8UmCFwYmZjqcrnq15ZuVldZkZ0=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.7/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

contrib/drivers/mssql/go.mod

@@ -4,7 +4,7 @@ go 1.15
 
 require (
 	github.com/denisenkom/go-mssqldb v0.11.0
-	github.com/gogf/gf/v2 v2.0.0-rc
+	github.com/gogf/gf/v2 v2.0.0
 )
 
 replace github.com/gogf/gf/v2 => ../../../

contrib/drivers/mssql/mssql.go

@@ -223,7 +223,7 @@ func (d *Driver) Tables(ctx context.Context, schema ...string) (tables []string,
 		return nil, err
 	}
 
-	result, err = d.DoGetAll(ctx, link, `SELECT NAME FROM SYSOBJECTS WHERE XTYPE='U' AND STATUS >= 0 ORDER BY NAME`)
+	result, err = d.DoSelect(ctx, link, `SELECT NAME FROM SYSOBJECTS WHERE XTYPE='U' AND STATUS >= 0 ORDER BY NAME`)
 	if err != nil {
 		return
 	}
@@ -289,7 +289,7 @@ ORDER BY a.id,a.colorder`,
 				table,
 			)
 			structureSql, _ = gregex.ReplaceString(`[\n\r\s]+`, " ", gstr.Trim(structureSql))
-			result, err = d.DoGetAll(ctx, link, structureSql)
+			result, err = d.DoSelect(ctx, link, structureSql)
 			if err != nil {
 				return nil
 			}

contrib/drivers/mysql/go.mod

@@ -2,6 +2,6 @@ module github.com/gogf/gf/contrib/drivers/mysql/v2
 
 go 1.15
 
-require github.com/gogf/gf/v2 v2.0.0-rc
+require github.com/gogf/gf/v2 v2.0.0
 
 replace github.com/gogf/gf/v2 => ../../../

contrib/drivers/oracle/go.mod

@@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/drivers/oracle/v2
 go 1.15
 
 require (
-	github.com/gogf/gf/v2 v2.0.0-rc
+	github.com/gogf/gf/v2 v2.0.0
 	github.com/mattn/go-oci8 v0.1.1
 )
 

contrib/drivers/oracle/oracle.go

@@ -194,7 +194,7 @@ func (d *Driver) parseSql(sql string) string {
 // Note that it ignores the parameter `schema` in oracle database, as it is not necessary.
 func (d *Driver) Tables(ctx context.Context, schema ...string) (tables []string, err error) {
 	var result gdb.Result
-	result, err = d.DoGetAll(ctx, nil, "SELECT TABLE_NAME FROM USER_TABLES ORDER BY TABLE_NAME")
+	result, err = d.DoSelect(ctx, nil, "SELECT TABLE_NAME FROM USER_TABLES ORDER BY TABLE_NAME")
 	if err != nil {
 		return
 	}
@@ -245,7 +245,7 @@ FROM USER_TAB_COLUMNS WHERE TABLE_NAME = '%s' ORDER BY COLUMN_ID`,
 				return nil
 			}
 			structureSql, _ = gregex.ReplaceString(`[\n\r\s]+`, " ", gstr.Trim(structureSql))
-			result, err = d.DoGetAll(ctx, link, structureSql)
+			result, err = d.DoSelect(ctx, link, structureSql)
 			if err != nil {
 				return nil
 			}

contrib/drivers/pgsql/go.mod

@@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/drivers/pgsql/v2
 go 1.15
 
 require (
-	github.com/gogf/gf/v2 v2.0.0-rc
+	github.com/gogf/gf/v2 v2.0.0
 	github.com/lib/pq v1.10.4
 )
 

contrib/drivers/pgsql/pgsql.go

@@ -142,7 +142,7 @@ func (d *Driver) Tables(ctx context.Context, schema ...string) (tables []string,
 			schema[0],
 		)
 	}
-	result, err = d.DoGetAll(ctx, link, query)
+	result, err = d.DoSelect(ctx, link, query)
 	if err != nil {
 		return
 	}
@@ -198,7 +198,7 @@ ORDER BY a.attnum`,
 				return nil
 			}
 			structureSql, _ = gregex.ReplaceString(`[\n\r\s]+`, " ", gstr.Trim(structureSql))
-			result, err = d.DoGetAll(ctx, link, structureSql)
+			result, err = d.DoSelect(ctx, link, structureSql)
 			if err != nil {
 				return nil
 			}

contrib/drivers/sqlite/go.mod

@@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/drivers/sqlite/v2
 go 1.15
 
 require (
-	github.com/gogf/gf/v2 v2.0.0-rc
+	github.com/gogf/gf/v2 v2.0.0
 	github.com/mattn/go-sqlite3 v1.14.10
 )
 

contrib/drivers/sqlite/sqlite.go

@@ -106,7 +106,7 @@ func (d *Driver) Tables(ctx context.Context, schema ...string) (tables []string,
 		return nil, err
 	}
 
-	result, err = d.DoGetAll(ctx, link, `SELECT NAME FROM SQLITE_MASTER WHERE TYPE='table' ORDER BY NAME`)
+	result, err = d.DoSelect(ctx, link, `SELECT NAME FROM SQLITE_MASTER WHERE TYPE='table' ORDER BY NAME`)
 	if err != nil {
 		return
 	}
@@ -141,7 +141,7 @@ func (d *Driver) TableFields(ctx context.Context, table string, schema ...string
 			if link, err = d.SlaveLink(useSchema); err != nil {
 				return nil
 			}
-			result, err = d.DoGetAll(ctx, link, fmt.Sprintf(`PRAGMA TABLE_INFO(%s)`, table))
+			result, err = d.DoSelect(ctx, link, fmt.Sprintf(`PRAGMA TABLE_INFO(%s)`, table))
 			if err != nil {
 				return nil
 			}

contrib/registry/etcd/go.mod

@@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/registry/etcd/v2
 go 1.15
 
 require (
-	github.com/gogf/gf/v2 v2.0.0-rc2
+	github.com/gogf/gf/v2 v2.0.0
 	go.etcd.io/etcd/client/v3 v3.5.1
 )
 

contrib/trace/jaeger/go.mod

@@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/trace/jaeger/v2
 go 1.15
 
 require (
-	github.com/gogf/gf/v2 v2.0.0-rc2
+	github.com/gogf/gf/v2 v2.0.0
 	go.opentelemetry.io/otel/exporters/jaeger v1.3.0
 	go.opentelemetry.io/otel/sdk v1.3.0
 )

database/gdb/gdb.go

@@ -20,6 +20,7 @@ import (
 	"github.com/gogf/gf/v2/internal/intlog"
 	"github.com/gogf/gf/v2/os/gcache"
 	"github.com/gogf/gf/v2/os/gcmd"
+	"github.com/gogf/gf/v2/os/gctx"
 	"github.com/gogf/gf/v2/os/glog"
 	"github.com/gogf/gf/v2/util/grand"
 )
@@ -94,15 +95,18 @@ type DB interface {
 	// Internal APIs for CURD, which can be overwritten by custom CURD implements.
 	// ===========================================================================
 
-	DoGetAll(ctx context.Context, link Link, sql string, args ...interface{}) (result Result, err error)                                           // See Core.DoGetAll.
+	DoSelect(ctx context.Context, link Link, sql string, args ...interface{}) (result Result, err error)                                           // See Core.DoSelect.
 	DoInsert(ctx context.Context, link Link, table string, data List, option DoInsertOption) (result sql.Result, err error)                        // See Core.DoInsert.
 	DoUpdate(ctx context.Context, link Link, table string, data interface{}, condition string, args ...interface{}) (result sql.Result, err error) // See Core.DoUpdate.
 	DoDelete(ctx context.Context, link Link, table string, condition string, args ...interface{}) (result sql.Result, err error)                   // See Core.DoDelete.
-	DoQuery(ctx context.Context, link Link, sql string, args ...interface{}) (result Result, err error)                                            // See Core.DoQuery.
-	DoExec(ctx context.Context, link Link, sql string, args ...interface{}) (result sql.Result, err error)                                         // See Core.DoExec.
-	DoFilter(ctx context.Context, link Link, sql string, args []interface{}) (newSql string, newArgs []interface{}, err error)                     // See Core.DoFilter.
-	DoCommit(ctx context.Context, in DoCommitInput) (out DoCommitOutput, err error)                                                                // See Core.DoCommit.
-	DoPrepare(ctx context.Context, link Link, sql string) (*Stmt, error)                                                                           // See Core.DoPrepare.
+
+	DoQuery(ctx context.Context, link Link, sql string, args ...interface{}) (result Result, err error)    // See Core.DoQuery.
+	DoExec(ctx context.Context, link Link, sql string, args ...interface{}) (result sql.Result, err error) // See Core.DoExec.
+
+	DoFilter(ctx context.Context, link Link, sql string, args []interface{}) (newSql string, newArgs []interface{}, err error) // See Core.DoFilter.
+	DoCommit(ctx context.Context, in DoCommitInput) (out DoCommitOutput, err error)                                            // See Core.DoCommit.
+
+	DoPrepare(ctx context.Context, link Link, sql string) (*Stmt, error) // See Core.DoPrepare.
 
 	// ===========================================================================
 	// Query APIs for convenience purpose.
@@ -211,13 +215,12 @@ type Driver interface {
 }
 
 // Link is a common database function wrapper interface.
+// Note that, any operation using `Link` will have no SQL logging.
 type Link interface {
-	Query(sql string, args ...interface{}) (*sql.Rows, error)
-	Exec(sql string, args ...interface{}) (sql.Result, error)
-	Prepare(sql string) (*sql.Stmt, error)
 	QueryContext(ctx context.Context, sql string, args ...interface{}) (*sql.Rows, error)
 	ExecContext(ctx context.Context, sql string, args ...interface{}) (sql.Result, error)
 	PrepareContext(ctx context.Context, sql string) (*sql.Stmt, error)
+	IsOnMaster() bool
 	IsTransaction() bool
 }
 
@@ -237,10 +240,10 @@ type Sql struct {
 
 // DoInsertOption is the input struct for function DoInsert.
 type DoInsertOption struct {
-	OnDuplicateStr string
-	OnDuplicateMap map[string]interface{}
-	InsertOption   int // Insert operation.
-	BatchCount     int // Batch count for batch inserting.
+	OnDuplicateStr string                 // Custom string for `on duplicated` statement.
+	OnDuplicateMap map[string]interface{} // Custom key-value map from `OnDuplicateEx` function for `on duplicated` statement.
+	InsertOption   int                    // Insert operation in constant value.
+	BatchCount     int                    // Batch count for batch inserting.
 }
 
 // TableField is the struct for table field.
@@ -277,16 +280,16 @@ const (
 	queryTypeCount          = 1
 	unionTypeNormal         = 0
 	unionTypeAll            = 1
-	defaultBatchNumber      = 10               // Per count for batch insert/replace/save.
 	defaultMaxIdleConnCount = 10               // Max idle connection count in pool.
 	defaultMaxOpenConnCount = 0                // Max open connection count in pool. Default is no limit.
 	defaultMaxConnLifeTime  = 30 * time.Second // Max lifetime for per connection in pool in seconds.
 	ctxTimeoutTypeExec      = iota
 	ctxTimeoutTypeQuery
 	ctxTimeoutTypePrepare
-	commandEnvKeyForDryRun = "gf.gdb.dryrun"
-	modelForDaoSuffix      = `ForDao`
-	dbRoleSlave            = `slave`
+	commandEnvKeyForDryRun             = "gf.gdb.dryrun"
+	modelForDaoSuffix                  = `ForDao`
+	dbRoleSlave                        = `slave`
+	contextKeyForDB        gctx.StrKey = `DBInContext`
 )
 
 const (
@@ -518,8 +521,11 @@ func getConfigNodeByWeight(cg ConfigGroup) *ConfigNode {
 // The parameter `master` specifies whether retrieves master node connection if
 // master-slave nodes are configured.
 func (c *Core) getSqlDb(master bool, schema ...string) (sqlDb *sql.DB, err error) {
+	var (
+		ctx  = c.db.GetCtx()
+		node *ConfigNode
+	)
 	// Load balance.
-	var node *ConfigNode
 	if c.group != "" {
 		node, err = getConfigNodeByGroup(c.group, master)
 		if err != nil {
@@ -545,20 +551,12 @@ func (c *Core) getSqlDb(master bool, schema ...string) (sqlDb *sql.DB, err error
 	}
 	// Cache the underlying connection pool object by node.
 	v := c.links.GetOrSetFuncLock(node.String(), func() interface{} {
-		intlog.Printf(
-			c.db.GetCtx(),
-			`open new connection, master:%#v, config:%#v, node:%#v`,
-			master, c.config, node,
-		)
+		intlog.Printf(ctx, `open new connection, master:%#v, config:%#v, node:%#v`, master, c.config, node)
 		defer func() {
 			if err != nil {
-				intlog.Printf(c.db.GetCtx(), `open new connection failed: %v, %#v`, err, node)
+				intlog.Printf(ctx, `open new connection failed: %v, %#v`, err, node)
 			} else {
-				intlog.Printf(
-					c.db.GetCtx(),
-					`open new connection success, master:%#v, config:%#v, node:%#v`,
-					master, c.config, node,
-				)
+				intlog.Printf(ctx, `open new connection success, master:%#v, config:%#v, node:%#v`, master, c.config, node)
 			}
 		}()
 

database/gdb/gdb_core.go

@@ -45,7 +45,6 @@ func (c *Core) Ctx(ctx context.Context) DB {
 		configNode = c.db.GetConfig()
 	)
 	*newCore = *c
-	newCore.ctx = ctx
 	// It creates a new DB object, which is commonly a wrapper for object `Core`.
 	newCore.db, err = driverMap[configNode.Type].New(newCore, configNode)
 	if err != nil {
@@ -53,22 +52,25 @@ func (c *Core) Ctx(ctx context.Context) DB {
 		// Do not let it continue.
 		panic(err)
 	}
+	newCore.ctx = WithDB(ctx, newCore.db)
+	newCore.ctx = c.InjectInternalCtxData(newCore.ctx)
 	return newCore.db
 }
 
 // GetCtx returns the context for current DB.
 // It returns `context.Background()` is there's no context previously set.
 func (c *Core) GetCtx() context.Context {
-	if c.ctx != nil {
-		return c.ctx
+	ctx := c.ctx
+	if ctx == nil {
+		ctx = context.TODO()
 	}
-	return context.TODO()
+	return c.InjectInternalCtxData(ctx)
 }
 
 // GetCtxTimeout returns the context and cancel function for specified timeout type.
-func (c *Core) GetCtxTimeout(timeoutType int, ctx context.Context) (context.Context, context.CancelFunc) {
+func (c *Core) GetCtxTimeout(ctx context.Context, timeoutType int) (context.Context, context.CancelFunc) {
 	if ctx == nil {
-		ctx = c.GetCtx()
+		ctx = c.db.GetCtx()
 	} else {
 		ctx = context.WithValue(ctx, "WrappedByGetCtxTimeout", nil)
 	}
@@ -145,11 +147,11 @@ func (c *Core) Slave(schema ...string) (*sql.DB, error) {
 
 // GetAll queries and returns data records from database.
 func (c *Core) GetAll(ctx context.Context, sql string, args ...interface{}) (Result, error) {
-	return c.db.DoGetAll(ctx, nil, sql, args...)
+	return c.db.DoSelect(ctx, nil, sql, args...)
 }
 
-// DoGetAll queries and returns data records from database.
-func (c *Core) DoGetAll(ctx context.Context, link Link, sql string, args ...interface{}) (result Result, err error) {
+// DoSelect queries and returns data records from database.
+func (c *Core) DoSelect(ctx context.Context, link Link, sql string, args ...interface{}) (result Result, err error) {
 	return c.db.DoQuery(ctx, link, sql, args...)
 }
 
@@ -168,7 +170,7 @@ func (c *Core) GetOne(ctx context.Context, sql string, args ...interface{}) (Rec
 // GetArray queries and returns data values as slice from database.
 // Note that if there are multiple columns in the result, it returns just one column values randomly.
 func (c *Core) GetArray(ctx context.Context, sql string, args ...interface{}) ([]Value, error) {
-	all, err := c.db.DoGetAll(ctx, nil, sql, args...)
+	all, err := c.db.DoSelect(ctx, nil, sql, args...)
 	if err != nil {
 		return nil, err
 	}
@@ -240,7 +242,7 @@ func (c *Core) GetValue(ctx context.Context, sql string, args ...interface{}) (V
 
 // GetCount queries and returns the count from database.
 func (c *Core) GetCount(ctx context.Context, sql string, args ...interface{}) (int, error) {
-	// If the query fields do not contains function "COUNT",
+	// If the query fields do not contain function "COUNT",
 	// it replaces the sql string and adds the "COUNT" function to the fields.
 	if !gregex.IsMatchString(`(?i)SELECT\s+COUNT\(.+\)\s+FROM`, sql) {
 		sql, _ = gregex.ReplaceString(`(?i)(SELECT)\s+(.+)\s+(FROM)`, `$1 COUNT($2) $3`, sql)
@@ -254,15 +256,17 @@ func (c *Core) GetCount(ctx context.Context, sql string, args ...interface{}) (i
 
 // Union does "(SELECT xxx FROM xxx) UNION (SELECT xxx FROM xxx) ..." statement.
 func (c *Core) Union(unions ...*Model) *Model {
-	return c.doUnion(unionTypeNormal, unions...)
+	var ctx = c.db.GetCtx()
+	return c.doUnion(ctx, unionTypeNormal, unions...)
 }
 
 // UnionAll does "(SELECT xxx FROM xxx) UNION ALL (SELECT xxx FROM xxx) ..." statement.
 func (c *Core) UnionAll(unions ...*Model) *Model {
-	return c.doUnion(unionTypeAll, unions...)
+	var ctx = c.db.GetCtx()
+	return c.doUnion(ctx, unionTypeAll, unions...)
 }
 
-func (c *Core) doUnion(unionType int, unions ...*Model) *Model {
+func (c *Core) doUnion(ctx context.Context, unionType int, unions ...*Model) *Model {
 	var (
 		unionTypeStr   string
 		composedSqlStr string
@@ -274,7 +278,7 @@ func (c *Core) doUnion(unionType int, unions ...*Model) *Model {
 		unionTypeStr = "UNION"
 	}
 	for _, v := range unions {
-		sqlWithHolder, holderArgs := v.getFormattedSqlAndArgs(queryTypeNormal, false)
+		sqlWithHolder, holderArgs := v.getFormattedSqlAndArgs(ctx, queryTypeNormal, false)
 		if composedSqlStr == "" {
 			composedSqlStr += fmt.Sprintf(`(%s)`, sqlWithHolder)
 		} else {
@@ -287,10 +291,11 @@ func (c *Core) doUnion(unionType int, unions ...*Model) *Model {
 
 // PingMaster pings the master node to check authentication or keeps the connection alive.
 func (c *Core) PingMaster() error {
+	var ctx = c.db.GetCtx()
 	if master, err := c.db.Master(); err != nil {
 		return err
 	} else {
-		if err = master.PingContext(c.GetCtx()); err != nil {
+		if err = master.PingContext(ctx); err != nil {
 			err = gerror.WrapCode(gcode.CodeDbOperationError, err, `master.Ping failed`)
 		}
 		return err
@@ -299,10 +304,11 @@ func (c *Core) PingMaster() error {
 
 // PingSlave pings the slave node to check authentication or keeps the connection alive.
 func (c *Core) PingSlave() error {
+	var ctx = c.db.GetCtx()
 	if slave, err := c.db.Slave(); err != nil {
 		return err
 	} else {
-		if err = slave.PingContext(c.GetCtx()); err != nil {
+		if err = slave.PingContext(ctx); err != nil {
 			err = gerror.WrapCode(gcode.CodeDbOperationError, err, `slave.Ping failed`)
 		}
 		return err
@@ -661,21 +667,22 @@ func (c *Core) writeSqlToLogger(ctx context.Context, sql *Sql) {
 
 // HasTable determine whether the table name exists in the database.
 func (c *Core) HasTable(name string) (bool, error) {
-	result, err := c.GetCache().GetOrSetFuncLock(
-		c.GetCtx(),
-		fmt.Sprintf(`HasTable: %s`, name),
-		func(ctx context.Context) (interface{}, error) {
-			tableList, err := c.db.Tables(ctx)
-			if err != nil {
-				return false, err
+	var (
+		ctx      = c.db.GetCtx()
+		cacheKey = fmt.Sprintf(`HasTable: %s`, name)
+	)
+	result, err := c.GetCache().GetOrSetFuncLock(ctx, cacheKey, func(ctx context.Context) (interface{}, error) {
+		tableList, err := c.db.Tables(ctx)
+		if err != nil {
+			return false, err
+		}
+		for _, table := range tableList {
+			if table == name {
+				return true, nil
 			}
-			for _, table := range tableList {
-				if table == name {
-					return true, nil
-				}
-			}
-			return false, nil
-		}, 0,
+		}
+		return false, nil
+	}, 0,
 	)
 	if err != nil {
 		return false, err

database/gdb/gdb_core_ctx.go

@@ -0,0 +1,66 @@
+// Copyright GoFrame Author(https://goframe.org). 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 (
+	"context"
+
+	"github.com/gogf/gf/v2/os/gctx"
+)
+
+// internalCtxData stores data in ctx for internal usage purpose.
+type internalCtxData struct {
+	// Operation DB.
+	DB DB
+
+	// The first column in result response from database server.
+	// This attribute is used for Value/Count selection statement purpose,
+	// which is to avoid HOOK handler that might modify the result columns
+	// that can confuse the Value/Count selection statement logic.
+	FirstResultColumn string
+}
+
+const (
+	internalCtxDataKeyInCtx gctx.StrKey = "InternalCtxData"
+
+	// `ignoreResultKeyInCtx` is a mark for some db drivers that do not support `RowsAffected` function,
+	// for example: `clickhouse`. The `clickhouse` does not support fetching insert/update results,
+	// but returns errors when execute `RowsAffected`. It here ignores the calling of `RowsAffected`
+	// to avoid triggering errors, rather than ignoring errors after they are triggered.
+	ignoreResultKeyInCtx gctx.StrKey = "IgnoreResult"
+)
+
+func (c *Core) InjectInternalCtxData(ctx context.Context) context.Context {
+	// If the internal data is already injected, it does nothing.
+	if ctx.Value(internalCtxDataKeyInCtx) != nil {
+		return ctx
+	}
+	return context.WithValue(ctx, internalCtxDataKeyInCtx, &internalCtxData{
+		DB: c.db,
+	})
+}
+
+func (c *Core) GetInternalCtxDataFromCtx(ctx context.Context) *internalCtxData {
+	if v := ctx.Value(internalCtxDataKeyInCtx); v != nil {
+		return v.(*internalCtxData)
+	}
+	return nil
+}
+
+func (c *Core) InjectIgnoreResult(ctx context.Context) context.Context {
+	if ctx.Value(ignoreResultKeyInCtx) != nil {
+		return ctx
+	}
+	return context.WithValue(ctx, ignoreResultKeyInCtx, true)
+}
+
+func (c *Core) GetIgnoreResultFromCtx(ctx context.Context) bool {
+	if ctx.Value(ignoreResultKeyInCtx) != nil {
+		return true
+	}
+	return false
+}

database/gdb/gdb_core_link.go

@@ -12,7 +12,8 @@ import (
 
 // dbLink is used to implement interface Link for DB.
 type dbLink struct {
-	*sql.DB
+	*sql.DB         // Underlying DB object.
+	isOnMaster bool // isOnMaster marks whether current link is operated on master node.
 }
 
 // txLink is used to implement interface Link for TX.
@@ -21,11 +22,22 @@ type txLink struct {
 }
 
 // IsTransaction returns if current Link is a transaction.
-func (*dbLink) IsTransaction() bool {
+func (l *dbLink) IsTransaction() bool {
 	return false
 }
 
+// IsOnMaster checks and returns whether current link is operated on master node.
+func (l *dbLink) IsOnMaster() bool {
+	return l.isOnMaster
+}
+
 // IsTransaction returns if current Link is a transaction.
-func (*txLink) IsTransaction() bool {
+func (l *txLink) IsTransaction() bool {
+	return true
+}
+
+// IsOnMaster checks and returns whether current link is operated on master node.
+// Note that, transaction operation is always operated on master node.
+func (l *txLink) IsOnMaster() bool {
 	return true
 }

database/gdb/gdb_core_sharding.go

@@ -0,0 +1,245 @@
+// Copyright GoFrame Author(https://goframe.org). 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 (
+	"context"
+	"strings"
+
+	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/longbridgeapp/sqlparser"
+)
+
+// ShardingInput is input parameters for custom sharding handler.
+type ShardingInput struct {
+	Table         string           // Current operation table name.
+	Schema        string           // Current operation schema, usually empty string which means uses default schema from configuration.
+	OperationData map[string]Value // Accurate readonly key-value data pairs from INSERT/UPDATE statement.
+	ConditionData map[string]Value // Accurate readonly key-value condition pairs from SELECT/UPDATE/DELETE statement.
+}
+
+// ShardingOutput is output parameters for custom sharding handler.
+type ShardingOutput struct {
+	Table  string // New table name for current operation. Use empty string for no changes of table name.
+	Schema string // New schema name for current operation. Use empty string for using default schema from configuration.
+}
+
+// ShardingHandler is a custom function for custom sharding table and schema for DB operation.
+type ShardingHandler func(ctx context.Context, in ShardingInput) (out *ShardingOutput, err error)
+
+const (
+	ctxKeyForShardingHandler gctx.StrKey = "ShardingHandler"
+)
+
+// Sharding creates and returns a new model with sharding handler.
+func (m *Model) Sharding(handler ShardingHandler) *Model {
+	var (
+		ctx   = m.GetCtx()
+		model = m.getModel()
+	)
+	model.shardingHandler = handler
+	// Inject sharding handler into context.
+	model = model.Ctx(model.injectShardingInputCaller(ctx))
+	return model
+}
+
+// injectShardingInputCaller injects custom sharding handler into context.
+func (m *Model) injectShardingInputCaller(ctx context.Context) context.Context {
+	if m.shardingHandler == nil {
+		return ctx
+	}
+	if ctx.Value(ctxKeyForShardingHandler) != nil {
+		return ctx
+	}
+	return context.WithValue(ctx, ctxKeyForShardingHandler, m.shardingHandler)
+}
+
+type callShardingHandlerFromCtxInput struct {
+	Sql          string
+	FormattedSql string
+}
+
+type callShardingHandlerFromCtxOutput struct {
+	Sql             string
+	Table           string
+	Schema          string
+	ParsedSqlOutput *parseFormattedSqlOutput
+}
+
+func (c *Core) callShardingHandlerFromCtx(
+	ctx context.Context, in callShardingHandlerFromCtxInput,
+) (out *callShardingHandlerFromCtxOutput, err error) {
+	var (
+		newSql          = in.Sql
+		ctxValue        interface{}
+		shardingHandler ShardingHandler
+		ok              bool
+	)
+	// If no sharding handler, it does nothing.
+	if ctxValue = ctx.Value(ctxKeyForShardingHandler); ctxValue == nil {
+		return nil, nil
+	}
+	if shardingHandler, ok = ctxValue.(ShardingHandler); !ok {
+		return nil, nil
+	}
+	parsedOut, err := c.parseFormattedSql(in.FormattedSql)
+	if err != nil {
+		return nil, err
+	}
+	var shardingIn = ShardingInput{
+		Table:         parsedOut.Table,
+		Schema:        c.db.GetSchema(),
+		OperationData: parsedOut.OperationData,
+		ConditionData: parsedOut.ConditionData,
+	}
+	shardingOut, err := shardingHandler(ctx, shardingIn)
+	if err != nil {
+		return nil, gerror.Wrap(err, `calling sharding handler failed`)
+	}
+	if shardingOut.Table != shardingIn.Table || shardingOut.Schema != shardingIn.Schema {
+		if shardingOut.Table != shardingIn.Table {
+			newSql, err = c.formatSqlWithNewTable(in.Sql, shardingOut.Table)
+			if err != nil {
+				return nil, err
+			}
+		}
+		out = &callShardingHandlerFromCtxOutput{
+			Sql:             newSql,
+			Table:           shardingOut.Table,
+			Schema:          shardingOut.Schema,
+			ParsedSqlOutput: parsedOut,
+		}
+		return out, nil
+	}
+	return nil, nil
+}
+
+// formatSqlWithNewTable modifies given `sql` and returns a sql with new table name `table`.
+func (c *Core) formatSqlWithNewTable(sql, table string) (newSql string, err error) {
+	parsedStmt, err := sqlparser.NewParser(strings.NewReader(sql)).ParseStatement()
+	if err != nil {
+		return "", gerror.Wrapf(err, `parse failed for SQL: %s`, sql)
+	}
+	newTable := &sqlparser.TableName{Name: &sqlparser.Ident{Name: table}}
+	switch stmt := parsedStmt.(type) {
+	case *sqlparser.SelectStatement:
+		stmt.FromItems = newTable
+		return stmt.String(), nil
+	case *sqlparser.InsertStatement:
+		stmt.TableName = newTable
+		return stmt.String(), nil
+	case *sqlparser.UpdateStatement:
+		stmt.TableName = newTable
+		return stmt.String(), nil
+	case *sqlparser.DeleteStatement:
+		stmt.TableName = newTable
+		return stmt.String(), nil
+	default:
+		return "", gerror.Wrapf(err, `unsupported SQL: %s`, sql)
+	}
+}
+
+type parseFormattedSqlOutput struct {
+	Table          string
+	OperationData  map[string]Value
+	ConditionData  map[string]Value
+	ParsedStmt     sqlparser.Statement
+	SelectedFields []string
+}
+
+func (c *Core) parseFormattedSql(formattedSql string) (*parseFormattedSqlOutput, error) {
+	var (
+		condition sqlparser.Expr
+		err       error
+		out       = &parseFormattedSqlOutput{
+			SelectedFields: make([]string, 0),
+			OperationData:  make(map[string]Value),
+			ConditionData:  make(map[string]Value),
+		}
+	)
+	out.ParsedStmt, err = sqlparser.NewParser(strings.NewReader(formattedSql)).ParseStatement()
+	if err != nil {
+		return nil, gerror.Wrapf(err, `parse failed for SQL: %s`, formattedSql)
+	}
+	switch stmt := out.ParsedStmt.(type) {
+	case *sqlparser.SelectStatement:
+		if stmt.FromItems != nil {
+			table, ok := stmt.FromItems.(*sqlparser.TableName)
+			if !ok {
+				return nil, gerror.Newf(
+					`invalid table name "%s" in SQL: %s`,
+					stmt.FromItems.String(), formattedSql,
+				)
+			}
+			out.Table = table.TableName()
+		}
+		condition = stmt.Condition
+		if stmt.Columns != nil {
+			for _, column := range *stmt.Columns {
+				if column.Alias != nil {
+					out.SelectedFields = append(out.SelectedFields, column.Alias.Name)
+				} else if column.Expr != nil {
+					out.SelectedFields = append(out.SelectedFields, column.Expr.String())
+				}
+			}
+		}
+
+	case *sqlparser.InsertStatement:
+		out.Table = stmt.TableName.TableName()
+		if len(stmt.Expressions) > 0 && len(stmt.ColumnNames) > 0 {
+			names := make([]string, len(stmt.ColumnNames))
+			for i, ident := range stmt.ColumnNames {
+				names[i] = ident.Name
+			}
+			// It just uses the first item.
+			for i, expr := range stmt.Expressions[0].Exprs {
+				c.injectDataByExpr(out.OperationData, names[i], expr)
+			}
+		}
+	case *sqlparser.UpdateStatement:
+		out.Table = stmt.TableName.TableName()
+		condition = stmt.Condition
+		if len(stmt.Assignments) > 0 {
+			for _, assignment := range stmt.Assignments {
+				if len(assignment.Columns) > 0 {
+					c.injectDataByExpr(out.OperationData, assignment.Columns[0].Name, assignment.Expr)
+				}
+			}
+		}
+	case *sqlparser.DeleteStatement:
+		out.Table = stmt.TableName.TableName()
+		condition = stmt.Condition
+
+	default:
+		return nil, gerror.Wrapf(err, `unsupported SQL: %s`, formattedSql)
+	}
+
+	err = sqlparser.Walk(sqlparser.VisitFunc(func(node sqlparser.Node) error {
+		if n, ok := node.(*sqlparser.BinaryExpr); ok {
+			if x, ok := n.X.(*sqlparser.Ident); ok {
+				if n.Op == sqlparser.EQ {
+					c.injectDataByExpr(out.ConditionData, x.Name, n.Y)
+				}
+			}
+		}
+		return nil
+	}), condition)
+	return out, err
+}
+
+func (c *Core) injectDataByExpr(data map[string]Value, name string, expr sqlparser.Expr) {
+	switch exprImp := expr.(type) {
+	case *sqlparser.StringLit:
+		data[name] = gvar.New(exprImp.Value)
+	case *sqlparser.NumberLit:
+		data[name] = gvar.New(exprImp.Value)
+	default:
+		data[name] = gvar.New(exprImp.String())
+	}
+}

database/gdb/gdb_core_transaction.go

@@ -71,7 +71,7 @@ func (c *Core) doBeginCtx(ctx context.Context) (*TX, error) {
 func (c *Core) Transaction(ctx context.Context, f func(ctx context.Context, tx *TX) error) (err error) {
 	var tx *TX
 	if ctx == nil {
-		ctx = c.GetCtx()
+		ctx = c.db.GetCtx()
 	}
 	// Check transaction object from context.
 	tx = TXFromCtx(ctx, c.db.GetGroup())
@@ -158,6 +158,9 @@ func (tx *TX) transactionKeyForNestedPoint() string {
 // Ctx sets the context for current transaction.
 func (tx *TX) Ctx(ctx context.Context) *TX {
 	tx.ctx = ctx
+	if tx.ctx != nil {
+		tx.ctx = tx.db.GetCore().InjectInternalCtxData(tx.ctx)
+	}
 	return tx
 }
 

database/gdb/gdb_core_underlying.go

@@ -11,6 +11,9 @@ import (
 	"context"
 	"database/sql"
 
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/trace"
+
 	"github.com/gogf/gf/v2"
 	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/errors/gcode"
@@ -18,8 +21,6 @@ import (
 	"github.com/gogf/gf/v2/internal/intlog"
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/util/guid"
-	"go.opentelemetry.io/otel"
-	"go.opentelemetry.io/otel/trace"
 )
 
 // Query commits one query SQL to underlying driver and returns the execution result.
@@ -127,8 +128,45 @@ func (c *Core) DoFilter(ctx context.Context, link Link, sql string, args []inter
 	return sql, args, nil
 }
 
+type sqlParsingHandlerInput struct {
+	DoCommitInput
+	FormattedSql string
+}
+
+type sqlParsingHandlerOutput struct {
+	DoCommitInput
+}
+
+func (c *Core) sqlParsingHandler(ctx context.Context, in sqlParsingHandlerInput) (out *sqlParsingHandlerOutput, err error) {
+	var shardingOut *callShardingHandlerFromCtxOutput
+	// Sharding handling.
+	shardingOut, err = c.callShardingHandlerFromCtx(ctx, callShardingHandlerFromCtxInput{
+		Sql:          in.Sql,
+		FormattedSql: in.FormattedSql,
+	})
+	if err != nil {
+		return
+	}
+	if shardingOut != nil {
+		if shardingOut.Sql != "" {
+			in.Sql = shardingOut.Sql
+		}
+		// If schema changes, it here creates and uses a new DB link operation object.
+		if shardingOut.Schema != c.db.GetSchema() {
+			in.Link, err = c.db.GetCore().GetLink(ctx, in.Link.IsOnMaster(), shardingOut.Schema)
+		}
+	}
+	out = &sqlParsingHandlerOutput{
+		DoCommitInput: in.DoCommitInput,
+	}
+	return
+}
+
 // DoCommit commits current sql and arguments to underlying sql driver.
 func (c *Core) DoCommit(ctx context.Context, in DoCommitInput) (out DoCommitOutput, err error) {
+	// Inject internal data into ctx, especially for transaction creating.
+	ctx = c.InjectInternalCtxData(ctx)
+
 	var (
 		sqlTx                *sql.Tx
 		sqlStmt              *sql.Stmt
@@ -138,9 +176,22 @@ func (c *Core) DoCommit(ctx context.Context, in DoCommitInput) (out DoCommitOutp
 		stmtSqlRow           *sql.Row
 		rowsAffected         int64
 		cancelFuncForTimeout context.CancelFunc
+		formattedSql         = FormatSqlWithArgs(in.Sql, in.Args)
 		timestampMilli1      = gtime.TimestampMilli()
 	)
 
+	// SQL parser handler.
+	sqlParsingHandlerOut, err := c.sqlParsingHandler(ctx, sqlParsingHandlerInput{
+		DoCommitInput: in,
+		FormattedSql:  formattedSql,
+	})
+	if err != nil {
+		return
+	}
+	if sqlParsingHandlerOut != nil {
+		in = sqlParsingHandlerOut.DoCommitInput
+	}
+
 	// Trace span start.
 	tr := otel.GetTracerProvider().Tracer(traceInstrumentName, trace.WithInstrumentationVersion(gf.VERSION))
 	ctx, span := tr.Start(ctx, in.Type, trace.WithSpanKind(trace.SpanKindInternal))
@@ -184,7 +235,7 @@ func (c *Core) DoCommit(ctx context.Context, in DoCommitInput) (out DoCommitOutp
 		out.RawResult = sqlStmt
 
 	case SqlTypeStmtExecContext:
-		ctx, cancelFuncForTimeout = c.GetCtxTimeout(ctxTimeoutTypeExec, ctx)
+		ctx, cancelFuncForTimeout = c.GetCtxTimeout(ctx, ctxTimeoutTypeExec)
 		defer cancelFuncForTimeout()
 		if c.db.GetDryRun() {
 			sqlResult = new(SqlResult)
@@ -194,13 +245,13 @@ func (c *Core) DoCommit(ctx context.Context, in DoCommitInput) (out DoCommitOutp
 		out.RawResult = sqlResult
 
 	case SqlTypeStmtQueryContext:
-		ctx, cancelFuncForTimeout = c.GetCtxTimeout(ctxTimeoutTypeQuery, ctx)
+		ctx, cancelFuncForTimeout = c.GetCtxTimeout(ctx, ctxTimeoutTypeQuery)
 		defer cancelFuncForTimeout()
 		stmtSqlRows, err = in.Stmt.QueryContext(ctx, in.Args...)
 		out.RawResult = stmtSqlRows
 
 	case SqlTypeStmtQueryRowContext:
-		ctx, cancelFuncForTimeout = c.GetCtxTimeout(ctxTimeoutTypeQuery, ctx)
+		ctx, cancelFuncForTimeout = c.GetCtxTimeout(ctx, ctxTimeoutTypeQuery)
 		defer cancelFuncForTimeout()
 		stmtSqlRow = in.Stmt.QueryRowContext(ctx, in.Args...)
 		out.RawResult = stmtSqlRow
@@ -210,7 +261,7 @@ func (c *Core) DoCommit(ctx context.Context, in DoCommitInput) (out DoCommitOutp
 	}
 	// Result handling.
 	switch {
-	case sqlResult != nil:
+	case sqlResult != nil && !c.GetIgnoreResultFromCtx(ctx):
 		rowsAffected, err = sqlResult.RowsAffected()
 		out.Result = sqlResult
 
@@ -232,7 +283,7 @@ func (c *Core) DoCommit(ctx context.Context, in DoCommitInput) (out DoCommitOutp
 			Sql:           in.Sql,
 			Type:          in.Type,
 			Args:          in.Args,
-			Format:        FormatSqlWithArgs(in.Sql, in.Args),
+			Format:        formattedSql,
 			Error:         err,
 			Start:         timestampMilli1,
 			End:           timestampMilli2,
@@ -349,6 +400,11 @@ func (c *Core) RowsToResult(ctx context.Context, rows *sql.Rows) (Result, error)
 		columnTypes[k] = v.DatabaseTypeName()
 		columnNames[k] = v.Name()
 	}
+	if len(columnNames) > 0 {
+		if internalData := c.GetInternalCtxDataFromCtx(ctx); internalData != nil {
+			internalData.FirstResultColumn = columnNames[0]
+		}
+	}
 	var (
 		values   = make([]interface{}, len(columnNames))
 		result   = make(Result, 0)

database/gdb/gdb_core_utility.go

@@ -8,12 +8,60 @@
 package gdb
 
 import (
+	"context"
+
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/text/gregex"
 	"github.com/gogf/gf/v2/text/gstr"
 )
 
+// WithDB injects given db object into context and returns a new context.
+func WithDB(ctx context.Context, db DB) context.Context {
+	if db == nil {
+		return ctx
+	}
+	dbCtx := db.GetCtx()
+	if ctxDb := DBFromCtx(dbCtx); ctxDb != nil {
+		return dbCtx
+	}
+	ctx = context.WithValue(ctx, contextKeyForDB, db)
+	return ctx
+}
+
+// DBFromCtx retrieves and returns DB object from context.
+func DBFromCtx(ctx context.Context) DB {
+	if ctx == nil {
+		return nil
+	}
+	v := ctx.Value(contextKeyForDB)
+	if v != nil {
+		return v.(DB)
+	}
+	return nil
+}
+
+// GetLink creates and returns the underlying database link object with transaction checks.
+// The parameter `master` specifies whether using the master node if master-slave configured.
+func (c *Core) GetLink(ctx context.Context, master bool, schema string) (Link, error) {
+	tx := TXFromCtx(ctx, c.db.GetGroup())
+	if tx != nil {
+		return &txLink{tx.tx}, nil
+	}
+	if master {
+		link, err := c.db.GetCore().MasterLink(schema)
+		if err != nil {
+			return nil, err
+		}
+		return link, nil
+	}
+	link, err := c.db.GetCore().SlaveLink(schema)
+	if err != nil {
+		return nil, err
+	}
+	return link, nil
+}
+
 // MasterLink acts like function Master but with additional `schema` parameter specifying
 // the schema for the connection. It is defined for internal usage.
 // Also see Master.
@@ -22,7 +70,10 @@ func (c *Core) MasterLink(schema ...string) (Link, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &dbLink{db}, nil
+	return &dbLink{
+		DB:         db,
+		isOnMaster: true,
+	}, nil
 }
 
 // SlaveLink acts like function Slave but with additional `schema` parameter specifying
@@ -33,7 +84,10 @@ func (c *Core) SlaveLink(schema ...string) (Link, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &dbLink{db}, nil
+	return &dbLink{
+		DB:         db,
+		isOnMaster: false,
+	}, nil
 }
 
 // QuoteWord checks given string `s` a word,
@@ -96,11 +150,12 @@ func (c *Core) Tables(schema ...string) (tables []string, err error) {
 //
 // It does nothing in default.
 func (c *Core) TableFields(table string, schema ...string) (fields map[string]*TableField, err error) {
+	var ctx = c.db.GetCtx()
 	// It does nothing if given table is empty, especially in sub-query.
 	if table == "" {
 		return map[string]*TableField{}, nil
 	}
-	return c.db.TableFields(c.GetCtx(), table, schema...)
+	return c.db.TableFields(ctx, table, schema...)
 }
 
 // HasField determine whether the field exists in the table.

database/gdb/gdb_driver_mysql.go

@@ -38,6 +38,7 @@ func (d *DriverMysql) New(core *Core, node *ConfigNode) (DB, error) {
 // Note that it converts time.Time argument to local timezone in default.
 func (d *DriverMysql) Open(config *ConfigNode) (db *sql.DB, err error) {
 	var (
+		ctx                  = d.GetCtx()
 		source               string
 		underlyingDriverName = "mysql"
 	)
@@ -56,7 +57,7 @@ func (d *DriverMysql) Open(config *ConfigNode) (db *sql.DB, err error) {
 			source = fmt.Sprintf("%s&loc=%s", source, url.QueryEscape(config.Timezone))
 		}
 	}
-	intlog.Printf(d.GetCtx(), "Open: %s", source)
+	intlog.Printf(ctx, "Open: %s", source)
 	if db, err = sql.Open(underlyingDriverName, source); err != nil {
 		err = gerror.WrapCodef(
 			gcode.CodeDbOperationError, err,
@@ -100,7 +101,7 @@ func (d *DriverMysql) Tables(ctx context.Context, schema ...string) (tables []st
 	if err != nil {
 		return nil, err
 	}
-	result, err = d.DoGetAll(ctx, link, `SHOW TABLES`)
+	result, err = d.DoSelect(ctx, link, `SHOW TABLES`)
 	if err != nil {
 		return
 	}
@@ -147,7 +148,7 @@ func (d *DriverMysql) TableFields(ctx context.Context, table string, schema ...s
 			if link, err = d.SlaveLink(useSchema); err != nil {
 				return nil
 			}
-			result, err = d.DoGetAll(
+			result, err = d.DoSelect(
 				ctx, link,
 				fmt.Sprintf(`SHOW FULL COLUMNS FROM %s`, d.QuoteWord(table)),
 			)

database/gdb/gdb_func.go

@@ -8,6 +8,7 @@ package gdb
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"reflect"
 	"regexp"
@@ -180,12 +181,12 @@ func DataToMapDeep(value interface{}) map[string]interface{} {
 	return m
 }
 
-// doHandleTableName adds prefix string and quote chars for the table. It handles table string like:
+// doHandleTableName adds prefix string and quote chars for table name. It handles table string like:
 // "user", "user u", "user,user_detail", "user u, user_detail ut", "user as u, user_detail as ut",
 // "user.user u", "`user`.`user` u".
 //
-// Note that, this will automatically checks the table prefix whether already added, if true it does
-// nothing to the table name, or else adds the prefix to the table name.
+// Note that, this will automatically check the table prefix whether already added, if true it does
+// nothing to the table name, or else adds the prefix to the table name and returns new table name with prefix.
 func doHandleTableName(table, prefix, charLeft, charRight string) string {
 	var (
 		index  = 0
@@ -364,7 +365,7 @@ func isKeyValueCanBeOmitEmpty(omitEmpty bool, whereType string, key, value inter
 }
 
 // formatWhereHolder formats where statement and its arguments for `Where` and `Having` statements.
-func formatWhereHolder(db DB, in formatWhereHolderInput) (newWhere string, newArgs []interface{}) {
+func formatWhereHolder(ctx context.Context, db DB, in formatWhereHolderInput) (newWhere string, newArgs []interface{}) {
 	var (
 		buffer      = bytes.NewBuffer(nil)
 		reflectInfo = reflection.OriginValueAndKind(in.Where)
@@ -393,7 +394,7 @@ func formatWhereHolder(db DB, in formatWhereHolderInput) (newWhere string, newAr
 		}
 
 	case reflect.Struct:
-		// If the `where` parameter is DO struct, it then adds `OmitNil` option for this condition,
+		// If the `where` parameter is `DO` struct, it then adds `OmitNil` option for this condition,
 		// which will filter all nil parameters in `where`.
 		if isDoStruct(in.Where) {
 			in.OmitNil = true
@@ -523,7 +524,9 @@ func formatWhereHolder(db DB, in formatWhereHolderInput) (newWhere string, newAr
 				whereStr, _ = gregex.ReplaceStringFunc(`(\?)`, whereStr, func(s string) string {
 					index++
 					if i+len(newArgs) == index {
-						sqlWithHolder, holderArgs := model.getFormattedSqlAndArgs(queryTypeNormal, false)
+						sqlWithHolder, holderArgs := model.getFormattedSqlAndArgs(
+							ctx, queryTypeNormal, false,
+						)
 						newArgs = append(newArgs, holderArgs...)
 						// Automatically adding the brackets.
 						return "(" + sqlWithHolder + ")"

database/gdb/gdb_model.go

@@ -17,37 +17,39 @@ import (
 
 // Model is core struct implementing the DAO for ORM.
 type Model struct {
-	db            DB                 // Underlying DB interface.
-	tx            *TX                // Underlying TX interface.
-	rawSql        string             // rawSql is the raw SQL string which marks a raw SQL based Model not a table based Model.
-	schema        string             // Custom database schema.
-	linkType      int                // Mark for operation on master or slave.
-	tablesInit    string             // Table names when model initialization.
-	tables        string             // Operation table names, which can be more than one table names and aliases, like: "user", "user u", "user u, user_detail ud".
-	fields        string             // Operation fields, multiple fields joined using char ','.
-	fieldsEx      string             // Excluded operation fields, multiple fields joined using char ','.
-	withArray     []interface{}      // Arguments for With feature.
-	withAll       bool               // Enable model association operations on all objects that have "with" tag in the struct.
-	extraArgs     []interface{}      // Extra custom arguments for sql, which are prepended to the arguments before sql committed to underlying driver.
-	whereHolder   []ModelWhereHolder // Condition strings for where operation.
-	groupBy       string             // Used for "group by" statement.
-	orderBy       string             // Used for "order by" statement.
-	having        []interface{}      // Used for "having..." statement.
-	start         int                // Used for "select ... start, limit ..." statement.
-	limit         int                // Used for "select ... start, limit ..." statement.
-	option        int                // Option for extra operation features.
-	offset        int                // Offset statement for some databases grammar.
-	data          interface{}        // Data for operation, which can be type of map/[]map/struct/*struct/string, etc.
-	batch         int                // Batch number for batch Insert/Replace/Save operations.
-	filter        bool               // Filter data and where key-value pairs according to the fields of the table.
-	distinct      string             // Force the query to only return distinct results.
-	lockInfo      string             // Lock for update or in shared lock.
-	cacheEnabled  bool               // Enable sql result cache feature, which is mainly for indicating cache duration(especially 0) usage.
-	cacheOption   CacheOption        // Cache option for query statement.
-	unscoped      bool               // Disables soft deleting features when select/delete operations.
-	safe          bool               // If true, it clones and returns a new model object whenever operation done; or else it changes the attribute of current model.
-	onDuplicate   interface{}        // onDuplicate is used for ON "DUPLICATE KEY UPDATE" statement.
-	onDuplicateEx interface{}        // onDuplicateEx is used for excluding some columns ON "DUPLICATE KEY UPDATE" statement.
+	db              DB                 // Underlying DB interface.
+	tx              *TX                // Underlying TX interface.
+	rawSql          string             // rawSql is the raw SQL string which marks a raw SQL based Model not a table based Model.
+	schema          string             // Custom database schema.
+	linkType        int                // Mark for operation on master or slave.
+	tablesInit      string             // Table names when model initialization.
+	tables          string             // Operation table names, which can be more than one table names and aliases, like: "user", "user u", "user u, user_detail ud".
+	fields          string             // Operation fields, multiple fields joined using char ','.
+	fieldsEx        string             // Excluded operation fields, multiple fields joined using char ','.
+	withArray       []interface{}      // Arguments for With feature.
+	withAll         bool               // Enable model association operations on all objects that have "with" tag in the struct.
+	extraArgs       []interface{}      // Extra custom arguments for sql, which are prepended to the arguments before sql committed to underlying driver.
+	whereHolder     []ModelWhereHolder // Condition strings for where operation.
+	groupBy         string             // Used for "group by" statement.
+	orderBy         string             // Used for "order by" statement.
+	having          []interface{}      // Used for "having..." statement.
+	start           int                // Used for "select ... start, limit ..." statement.
+	limit           int                // Used for "select ... start, limit ..." statement.
+	option          int                // Option for extra operation features.
+	offset          int                // Offset statement for some databases grammar.
+	data            interface{}        // Data for operation, which can be type of map/[]map/struct/*struct/string, etc.
+	batch           int                // Batch number for batch Insert/Replace/Save operations.
+	filter          bool               // Filter data and where key-value pairs according to the fields of the table.
+	distinct        string             // Force the query to only return distinct results.
+	lockInfo        string             // Lock for update or in shared lock.
+	cacheEnabled    bool               // Enable sql result cache feature, which is mainly for indicating cache duration(especially 0) usage.
+	cacheOption     CacheOption        // Cache option for query statement.
+	hookHandler     HookHandler        // Hook functions for model hook feature.
+	shardingHandler ShardingHandler    // Custom sharding handler for sharding feature.
+	unscoped        bool               // Disables soft deleting features when select/delete operations.
+	safe            bool               // If true, it clones and returns a new model object whenever operation done; or else it changes the attribute of current model.
+	onDuplicate     interface{}        // onDuplicate is used for ON "DUPLICATE KEY UPDATE" statement.
+	onDuplicateEx   interface{}        // onDuplicateEx is used for excluding some columns ON "DUPLICATE KEY UPDATE" statement.
 }
 
 // ModelHandler is a function that handles given Model and returns a new Model that is custom modified.
@@ -91,6 +93,7 @@ const (
 //    db.Model("? AS a, ? AS b", subQuery1, subQuery2)
 func (c *Core) Model(tableNameQueryOrStruct ...interface{}) *Model {
 	var (
+		ctx       = c.db.GetCtx()
 		tableStr  string
 		tableName string
 		extraArgs []interface{}
@@ -103,7 +106,7 @@ func (c *Core) Model(tableNameQueryOrStruct ...interface{}) *Model {
 				Where: conditionStr,
 				Args:  tableNameQueryOrStruct[1:],
 			}
-			tableStr, extraArgs = formatWhereHolder(c.db, formatWhereHolderInput{
+			tableStr, extraArgs = formatWhereHolder(ctx, c.db, formatWhereHolderInput{
 				ModelWhereHolder: whereHolder,
 				OmitNil:          false,
 				OmitEmpty:        false,
@@ -264,6 +267,7 @@ func (m *Model) Clone() *Model {
 	} else {
 		newModel = m.db.Model(m.tablesInit)
 	}
+	// Basic attributes copy.
 	*newModel = *m
 	// Shallow copy slice attributes.
 	if n := len(m.extraArgs); n > 0 {

database/gdb/gdb_model_cache.go

@@ -7,9 +7,14 @@
 package gdb
 
 import (
+	"context"
+	"fmt"
 	"time"
 
+	"github.com/gogf/gf/v2/crypto/gmd5"
 	"github.com/gogf/gf/v2/internal/intlog"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 type CacheOption struct {
@@ -29,6 +34,12 @@ type CacheOption struct {
 	Force bool
 }
 
+// selectCacheItem is the cache item for SELECT statement result.
+type selectCacheItem struct {
+	Result            Result // Sql result of SELECT statement.
+	FirstResultColumn string // The first column name of result, for Value/Count functions.
+}
+
 // Cache sets the cache feature for the model. It caches the result of the sql, which means
 // if there's another same sql request, it just reads and returns the result from cache, it
 // but not committed and executed into the database.
@@ -42,14 +53,88 @@ func (m *Model) Cache(option CacheOption) *Model {
 	return model
 }
 
-// checkAndRemoveCache checks and removes the cache in insert/update/delete statement if
+// checkAndRemoveSelectCache checks and removes the cache in insert/update/delete statement if
 // cache feature is enabled.
-func (m *Model) checkAndRemoveCache() {
+func (m *Model) checkAndRemoveSelectCache(ctx context.Context) {
 	if m.cacheEnabled && m.cacheOption.Duration < 0 && len(m.cacheOption.Name) > 0 {
-		ctx := m.GetCtx()
-		_, err := m.db.GetCache().Remove(ctx, m.cacheOption.Name)
-		if err != nil {
+		if _, err := m.db.GetCache().Remove(ctx, m.cacheOption.Name); err != nil {
 			intlog.Errorf(ctx, `%+v`, err)
 		}
 	}
 }
+
+func (m *Model) getSelectResultFromCache(ctx context.Context, sql string, args ...interface{}) (result Result, err error) {
+	if !m.cacheEnabled || m.tx != nil {
+		return
+	}
+	var (
+		ok        bool
+		cacheItem *selectCacheItem
+		cacheKey  = m.makeSelectCacheKey(sql, args...)
+		cacheObj  = m.db.GetCache()
+	)
+	defer func() {
+		if cacheItem != nil {
+			if internalData := m.db.GetCore().GetInternalCtxDataFromCtx(ctx); internalData != nil {
+				if internalData.FirstResultColumn == "" {
+					internalData.FirstResultColumn = cacheItem.FirstResultColumn
+				}
+			}
+		}
+	}()
+	if v, _ := cacheObj.Get(ctx, cacheKey); !v.IsNil() {
+		if cacheItem, ok = v.Val().(*selectCacheItem); ok {
+			// In-memory cache.
+			return cacheItem.Result, nil
+		} else {
+			// Other cache, it needs conversion.
+			if err = json.UnmarshalUseNumber(v.Bytes(), &cacheItem); err != nil {
+				return nil, err
+			}
+			return cacheItem.Result, nil
+		}
+	}
+	return
+}
+
+func (m *Model) saveSelectResultToCache(ctx context.Context, result Result, sql string, args ...interface{}) (err error) {
+	if !m.cacheEnabled || m.tx != nil {
+		return
+	}
+	var (
+		cacheKey = m.makeSelectCacheKey(sql, args...)
+		cacheObj = m.db.GetCache()
+	)
+	if m.cacheOption.Duration < 0 {
+		if _, errCache := cacheObj.Remove(ctx, cacheKey); errCache != nil {
+			intlog.Errorf(ctx, `%+v`, errCache)
+		}
+	} else {
+		// In case of Cache Penetration.
+		if result.IsEmpty() && m.cacheOption.Force {
+			result = Result{}
+		}
+		var cacheItem = &selectCacheItem{
+			Result: result,
+		}
+		if internalData := m.db.GetCore().GetInternalCtxDataFromCtx(ctx); internalData != nil {
+			cacheItem.FirstResultColumn = internalData.FirstResultColumn
+		}
+		if errCache := cacheObj.Set(ctx, cacheKey, cacheItem, m.cacheOption.Duration); errCache != nil {
+			intlog.Errorf(ctx, `%+v`, errCache)
+		}
+	}
+	return nil
+}
+
+func (m *Model) makeSelectCacheKey(sql string, args ...interface{}) string {
+	var cacheKey = m.cacheOption.Name
+	if len(cacheKey) == 0 {
+		cacheKey = fmt.Sprintf(
+			`GCache@Schema(%s):%s`,
+			m.db.GetSchema(),
+			gmd5.MustEncryptString(sql+", @PARAMS:"+gconv.String(args)),
+		)
+	}
+	return cacheKey
+}

database/gdb/gdb_model_delete.go

@@ -20,32 +20,55 @@ import (
 // The optional parameter `where` is the same as the parameter of Model.Where function,
 // see Model.Where.
 func (m *Model) Delete(where ...interface{}) (result sql.Result, err error) {
+	var ctx = m.GetCtx()
 	if len(where) > 0 {
 		return m.Where(where[0], where[1:]...).Delete()
 	}
 	defer func() {
 		if err == nil {
-			m.checkAndRemoveCache()
+			m.checkAndRemoveSelectCache(ctx)
 		}
 	}()
 	var (
 		fieldNameDelete                               = m.getSoftFieldNameDeleted()
-		conditionWhere, conditionExtra, conditionArgs = m.formatCondition(false, false)
+		conditionWhere, conditionExtra, conditionArgs = m.formatCondition(ctx, false, false)
 	)
 	// Soft deleting.
 	if !m.unscoped && fieldNameDelete != "" {
-		return m.db.DoUpdate(
-			m.GetCtx(),
-			m.getLink(true),
-			m.tables,
-			fmt.Sprintf(`%s=?`, m.db.GetCore().QuoteString(fieldNameDelete)),
-			conditionWhere+conditionExtra,
-			append([]interface{}{gtime.Now().String()}, conditionArgs...),
-		)
+		in := &HookUpdateInput{
+			internalParamHookUpdate: internalParamHookUpdate{
+				internalParamHook: internalParamHook{
+					link:  m.getLink(true),
+					model: m,
+				},
+				handler: m.hookHandler.Update,
+			},
+			Table:     m.tables,
+			Data:      fmt.Sprintf(`%s=?`, m.db.GetCore().QuoteString(fieldNameDelete)),
+			Condition: conditionWhere + conditionExtra,
+			Args:      append([]interface{}{gtime.Now().String()}, conditionArgs...),
+		}
+		return in.Next(ctx)
 	}
 	conditionStr := conditionWhere + conditionExtra
 	if !gstr.ContainsI(conditionStr, " WHERE ") {
-		return nil, gerror.NewCode(gcode.CodeMissingParameter, "there should be WHERE condition statement for DELETE operation")
+		return nil, gerror.NewCode(
+			gcode.CodeMissingParameter,
+			"there should be WHERE condition statement for DELETE operation",
+		)
 	}
-	return m.db.DoDelete(m.GetCtx(), m.getLink(true), m.tables, conditionStr, conditionArgs...)
+
+	in := &HookDeleteInput{
+		internalParamHookDelete: internalParamHookDelete{
+			internalParamHook: internalParamHook{
+				link:  m.getLink(true),
+				model: m,
+			},
+			handler: m.hookHandler.Delete,
+		},
+		Table:     m.tables,
+		Condition: conditionStr,
+		Args:      conditionArgs,
+	}
+	return in.Next(ctx)
 }

database/gdb/gdb_model_fields.go

@@ -43,12 +43,12 @@ func (m *Model) Fields(fieldNamesOrMapStruct ...interface{}) *Model {
 			return m.appendFieldsByStr(gstr.Join(
 				m.mappingAndFilterToTableFields([]string{r}, false), ",",
 			))
-
 		case []string:
 			return m.appendFieldsByStr(gstr.Join(
 				m.mappingAndFilterToTableFields(r, true), ",",
 			))
-
+		case Raw, *Raw:
+			return m.appendFieldsByStr(gconv.String(structOrMap))
 		default:
 			return m.appendFieldsByStr(gstr.Join(
 				m.mappingAndFilterToTableFields(getFieldsFromStructOrMap(structOrMap), true), ",",
@@ -92,6 +92,8 @@ func (m *Model) FieldsEx(fieldNamesOrMapStruct ...interface{}) *Model {
 			model.fieldsEx = gstr.Join(m.mappingAndFilterToTableFields([]string{r}, false), ",")
 		case []string:
 			model.fieldsEx = gstr.Join(m.mappingAndFilterToTableFields(r, true), ",")
+		case Raw, *Raw:
+			model.fieldsEx = gconv.String(fieldNamesOrMapStruct[0])
 		default:
 			model.fieldsEx = gstr.Join(m.mappingAndFilterToTableFields(getFieldsFromStructOrMap(r), true), ",")
 		}

database/gdb/gdb_model_hook.go

@@ -0,0 +1,159 @@
+// Copyright GoFrame Author(https://goframe.org). 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 (
+	"context"
+	"database/sql"
+
+	"github.com/gogf/gf/v2/text/gstr"
+)
+
+type (
+	HookFuncSelect func(ctx context.Context, in *HookSelectInput) (result Result, err error)
+	HookFuncInsert func(ctx context.Context, in *HookInsertInput) (result sql.Result, err error)
+	HookFuncUpdate func(ctx context.Context, in *HookUpdateInput) (result sql.Result, err error)
+	HookFuncDelete func(ctx context.Context, in *HookDeleteInput) (result sql.Result, err error)
+)
+
+// HookHandler manages all supported hook functions for Model.
+type HookHandler struct {
+	Select HookFuncSelect
+	Insert HookFuncInsert
+	Update HookFuncUpdate
+	Delete HookFuncDelete
+}
+
+// internalParamHook manages all internal parameters for hook operations.
+// The `internal` obviously means you cannot access these parameters outside this package.
+type internalParamHook struct {
+	link          Link   // Connection object from third party sql driver.
+	model         *Model // Underlying Model object.
+	handlerCalled bool   // Simple mark for custom handler called, in case of recursive calling.
+	removedWhere  bool   // Removed mark for condition string that was removed `WHERE` prefix.
+}
+
+type internalParamHookSelect struct {
+	internalParamHook
+	handler HookFuncSelect
+}
+
+type internalParamHookInsert struct {
+	internalParamHook
+	handler HookFuncInsert
+}
+
+type internalParamHookUpdate struct {
+	internalParamHook
+	handler HookFuncUpdate
+}
+
+type internalParamHookDelete struct {
+	internalParamHook
+	handler HookFuncDelete
+}
+
+// HookSelectInput holds the parameters for select hook operation.
+// Note that, COUNT statement will also be hooked by this feature,
+// which is usually not be interesting for upper business hook handler.
+type HookSelectInput struct {
+	internalParamHookSelect
+	Table string
+	Sql   string
+	Args  []interface{}
+}
+
+// HookInsertInput holds the parameters for insert hook operation.
+type HookInsertInput struct {
+	internalParamHookInsert
+	Table  string
+	Data   List
+	Option DoInsertOption
+}
+
+// HookUpdateInput holds the parameters for update hook operation.
+type HookUpdateInput struct {
+	internalParamHookUpdate
+	Table     string
+	Data      interface{} // Data can be type of: map[string]interface{}/string. You can use type assertion on `Data`.
+	Condition string
+	Args      []interface{}
+}
+
+// HookDeleteInput holds the parameters for delete hook operation.
+type HookDeleteInput struct {
+	internalParamHookDelete
+	Table     string
+	Condition string
+	Args      []interface{}
+}
+
+const (
+	whereKeyInCondition = " WHERE "
+)
+
+// IsTransaction checks and returns whether current operation is during transaction.
+func (h *internalParamHook) IsTransaction() bool {
+	return h.link.IsTransaction()
+}
+
+// Next calls the next hook handler.
+func (h *HookSelectInput) Next(ctx context.Context) (result Result, err error) {
+	if h.handler != nil && !h.handlerCalled {
+		h.handlerCalled = true
+		return h.handler(ctx, h)
+	}
+	return h.model.db.DoSelect(ctx, h.link, h.Sql, h.Args...)
+}
+
+// Next calls the next hook handler.
+func (h *HookInsertInput) Next(ctx context.Context) (result sql.Result, err error) {
+	if h.handler != nil && !h.handlerCalled {
+		h.handlerCalled = true
+		return h.handler(ctx, h)
+	}
+	return h.model.db.DoInsert(ctx, h.link, h.Table, h.Data, h.Option)
+}
+
+// Next calls the next hook handler.
+func (h *HookUpdateInput) Next(ctx context.Context) (result sql.Result, err error) {
+	if h.handler != nil && !h.handlerCalled {
+		h.handlerCalled = true
+		if gstr.HasPrefix(h.Condition, whereKeyInCondition) {
+			h.removedWhere = true
+			h.Condition = gstr.TrimLeftStr(h.Condition, whereKeyInCondition)
+		}
+		return h.handler(ctx, h)
+	}
+	if h.removedWhere {
+		h.Condition = whereKeyInCondition + h.Condition
+	}
+	return h.model.db.DoUpdate(ctx, h.link, h.Table, h.Data, h.Condition, h.Args...)
+}
+
+// Next calls the next hook handler.
+func (h *HookDeleteInput) Next(ctx context.Context) (result sql.Result, err error) {
+	if h.handler != nil && !h.handlerCalled {
+		h.handlerCalled = true
+		if gstr.HasPrefix(h.Condition, whereKeyInCondition) {
+			h.removedWhere = true
+			h.Condition = gstr.TrimLeftStr(h.Condition, whereKeyInCondition)
+		}
+		return h.handler(ctx, h)
+	}
+	if h.removedWhere {
+		h.Condition = whereKeyInCondition + h.Condition
+	}
+	return h.model.db.DoDelete(ctx, h.link, h.Table, h.Condition, h.Args...)
+}
+
+// Hook sets the hook functions for current model.
+func (m *Model) Hook(hook HookHandler) *Model {
+	model := m.getModel()
+	model.hookHandler = hook
+	return model
+}

database/gdb/gdb_model_insert.go

@@ -7,6 +7,7 @@
 package gdb
 
 import (
+	"context"
 	"database/sql"
 	"reflect"
 
@@ -38,7 +39,10 @@ func (m *Model) Batch(batch int) *Model {
 // Data(g.Map{"uid": 10000, "name":"john"})
 // Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"}).
 func (m *Model) Data(data ...interface{}) *Model {
-	model := m.getModel()
+	var (
+		ctx   = m.GetCtx()
+		model = m.getModel()
+	)
 	if len(data) > 1 {
 		if s := gconv.String(data[0]); gstr.Contains(s, "?") {
 			model.data = s
@@ -83,7 +87,7 @@ func (m *Model) Data(data ...interface{}) *Model {
 				}
 				list := make(List, reflectInfo.OriginValue.Len())
 				for i := 0; i < reflectInfo.OriginValue.Len(); i++ {
-					list[i] = m.db.ConvertDataForRecord(m.GetCtx(), reflectInfo.OriginValue.Index(i).Interface())
+					list[i] = m.db.ConvertDataForRecord(ctx, reflectInfo.OriginValue.Index(i).Interface())
 				}
 				model.data = list
 
@@ -100,15 +104,15 @@ func (m *Model) Data(data ...interface{}) *Model {
 						list  = make(List, len(array))
 					)
 					for i := 0; i < len(array); i++ {
-						list[i] = m.db.ConvertDataForRecord(m.GetCtx(), array[i])
+						list[i] = m.db.ConvertDataForRecord(ctx, array[i])
 					}
 					model.data = list
 				} else {
-					model.data = m.db.ConvertDataForRecord(m.GetCtx(), data[0])
+					model.data = m.db.ConvertDataForRecord(ctx, data[0])
 				}
 
 			case reflect.Map:
-				model.data = m.db.ConvertDataForRecord(m.GetCtx(), data[0])
+				model.data = m.db.ConvertDataForRecord(ctx, data[0])
 
 			default:
 				model.data = data[0]
@@ -140,7 +144,7 @@ func (m *Model) OnDuplicate(onDuplicate ...interface{}) *Model {
 	return model
 }
 
-// OnDuplicateEx sets the excluding columns for operations when columns conflicts occurs.
+// OnDuplicateEx sets the excluding columns for operations when columns conflict occurs.
 // In MySQL, this is used for "ON DUPLICATE KEY UPDATE" statement.
 // The parameter `onDuplicateEx` can be type of string/map/slice.
 // Example:
@@ -164,18 +168,20 @@ func (m *Model) OnDuplicateEx(onDuplicateEx ...interface{}) *Model {
 // The optional parameter `data` is the same as the parameter of Model.Data function,
 // see Model.Data.
 func (m *Model) Insert(data ...interface{}) (result sql.Result, err error) {
+	var ctx = m.GetCtx()
 	if len(data) > 0 {
 		return m.Data(data...).Insert()
 	}
-	return m.doInsertWithOption(InsertOptionDefault)
+	return m.doInsertWithOption(ctx, InsertOptionDefault)
 }
 
 // InsertAndGetId performs action Insert and returns the last insert id that automatically generated.
 func (m *Model) InsertAndGetId(data ...interface{}) (lastInsertId int64, err error) {
+	var ctx = m.GetCtx()
 	if len(data) > 0 {
 		return m.Data(data...).InsertAndGetId()
 	}
-	result, err := m.doInsertWithOption(InsertOptionDefault)
+	result, err := m.doInsertWithOption(ctx, InsertOptionDefault)
 	if err != nil {
 		return 0, err
 	}
@@ -186,20 +192,22 @@ func (m *Model) InsertAndGetId(data ...interface{}) (lastInsertId int64, err err
 // The optional parameter `data` is the same as the parameter of Model.Data function,
 // see Model.Data.
 func (m *Model) InsertIgnore(data ...interface{}) (result sql.Result, err error) {
+	var ctx = m.GetCtx()
 	if len(data) > 0 {
 		return m.Data(data...).InsertIgnore()
 	}
-	return m.doInsertWithOption(InsertOptionIgnore)
+	return m.doInsertWithOption(ctx, InsertOptionIgnore)
 }
 
 // Replace does "REPLACE INTO ..." statement for the model.
 // The optional parameter `data` is the same as the parameter of Model.Data function,
 // see Model.Data.
 func (m *Model) Replace(data ...interface{}) (result sql.Result, err error) {
+	var ctx = m.GetCtx()
 	if len(data) > 0 {
 		return m.Data(data...).Replace()
 	}
-	return m.doInsertWithOption(InsertOptionReplace)
+	return m.doInsertWithOption(ctx, InsertOptionReplace)
 }
 
 // Save does "INSERT INTO ... ON DUPLICATE KEY UPDATE..." statement for the model.
@@ -209,17 +217,18 @@ func (m *Model) Replace(data ...interface{}) (result sql.Result, err error) {
 // It updates the record if there's primary or unique index in the saving data,
 // or else it inserts a new record into the table.
 func (m *Model) Save(data ...interface{}) (result sql.Result, err error) {
+	var ctx = m.GetCtx()
 	if len(data) > 0 {
 		return m.Data(data...).Save()
 	}
-	return m.doInsertWithOption(InsertOptionSave)
+	return m.doInsertWithOption(ctx, InsertOptionSave)
 }
 
 // doInsertWithOption inserts data with option parameter.
-func (m *Model) doInsertWithOption(insertOption int) (result sql.Result, err error) {
+func (m *Model) doInsertWithOption(ctx context.Context, insertOption int) (result sql.Result, err error) {
 	defer func() {
 		if err == nil {
-			m.checkAndRemoveCache()
+			m.checkAndRemoveSelectCache(ctx)
 		}
 	}()
 	if m.data == nil {
@@ -246,11 +255,11 @@ func (m *Model) doInsertWithOption(insertOption int) (result sql.Result, err err
 	case List:
 		list = value
 		for i, v := range list {
-			list[i] = m.db.ConvertDataForRecord(m.GetCtx(), v)
+			list[i] = m.db.ConvertDataForRecord(ctx, v)
 		}
 
 	case Map:
-		list = List{m.db.ConvertDataForRecord(m.GetCtx(), value)}
+		list = List{m.db.ConvertDataForRecord(ctx, value)}
 
 	default:
 		reflectInfo := reflection.OriginValueAndKind(newData)
@@ -259,21 +268,21 @@ func (m *Model) doInsertWithOption(insertOption int) (result sql.Result, err err
 		case reflect.Slice, reflect.Array:
 			list = make(List, reflectInfo.OriginValue.Len())
 			for i := 0; i < reflectInfo.OriginValue.Len(); i++ {
-				list[i] = m.db.ConvertDataForRecord(m.GetCtx(), reflectInfo.OriginValue.Index(i).Interface())
+				list[i] = m.db.ConvertDataForRecord(ctx, reflectInfo.OriginValue.Index(i).Interface())
 			}
 
 		case reflect.Map:
-			list = List{m.db.ConvertDataForRecord(m.GetCtx(), value)}
+			list = List{m.db.ConvertDataForRecord(ctx, value)}
 
 		case reflect.Struct:
 			if v, ok := value.(iInterfaces); ok {
 				array := v.Interfaces()
 				list = make(List, len(array))
 				for i := 0; i < len(array); i++ {
-					list[i] = m.db.ConvertDataForRecord(m.GetCtx(), array[i])
+					list[i] = m.db.ConvertDataForRecord(ctx, array[i])
 				}
 			} else {
-				list = List{m.db.ConvertDataForRecord(m.GetCtx(), value)}
+				list = List{m.db.ConvertDataForRecord(ctx, value)}
 			}
 
 		default:
@@ -310,7 +319,20 @@ func (m *Model) doInsertWithOption(insertOption int) (result sql.Result, err err
 	if err != nil {
 		return result, err
 	}
-	return m.db.DoInsert(m.GetCtx(), m.getLink(true), m.tables, list, doInsertOption)
+
+	in := &HookInsertInput{
+		internalParamHookInsert: internalParamHookInsert{
+			internalParamHook: internalParamHook{
+				link:  m.getLink(true),
+				model: m,
+			},
+			handler: m.hookHandler.Insert,
+		},
+		Table:  m.tables,
+		Data:   list,
+		Option: doInsertOption,
+	}
+	return in.Next(ctx)
 }
 
 func (m *Model) formatDoInsertOption(insertOption int, columnNames []string) (option DoInsertOption, err error) {
@@ -406,9 +428,5 @@ func (m *Model) formatOnDuplicateExKeys(onDuplicateEx interface{}) ([]string, er
 }
 
 func (m *Model) getBatch() int {
-	batch := defaultBatchNumber
-	if m.batch > 0 {
-		batch = m.batch
-	}
-	return batch
+	return m.batch
 }

database/gdb/gdb_model_select.go

@@ -7,16 +7,14 @@
 package gdb
 
 import (
+	"context"
 	"fmt"
 	"reflect"
 
 	"github.com/gogf/gf/v2/container/gset"
 	"github.com/gogf/gf/v2/container/gvar"
-	"github.com/gogf/gf/v2/crypto/gmd5"
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/intlog"
-	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/reflection"
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
@@ -29,7 +27,8 @@ import (
 // The optional parameter `where` is the same as the parameter of Model.Where function,
 // see Model.Where.
 func (m *Model) All(where ...interface{}) (Result, error) {
-	return m.doGetAll(false, where...)
+	var ctx = m.GetCtx()
+	return m.doGetAll(ctx, false, where...)
 }
 
 // doGetAll does "SELECT FROM ..." statement for the model.
@@ -39,20 +38,24 @@ func (m *Model) All(where ...interface{}) (Result, error) {
 // The parameter `limit1` specifies whether limits querying only one record if m.limit is not set.
 // The optional parameter `where` is the same as the parameter of Model.Where function,
 // see Model.Where.
-func (m *Model) doGetAll(limit1 bool, where ...interface{}) (Result, error) {
+func (m *Model) doGetAll(ctx context.Context, limit1 bool, where ...interface{}) (Result, error) {
 	if len(where) > 0 {
 		return m.Where(where[0], where[1:]...).All()
 	}
-	sqlWithHolder, holderArgs := m.getFormattedSqlAndArgs(queryTypeNormal, limit1)
-	return m.doGetAllBySql(sqlWithHolder, holderArgs...)
+	sqlWithHolder, holderArgs := m.getFormattedSqlAndArgs(ctx, queryTypeNormal, limit1)
+	return m.doGetAllBySql(ctx, queryTypeNormal, sqlWithHolder, holderArgs...)
 }
 
 // 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, containing special chars.
+		if gstr.ContainsAny(m.fields, "()") {
+			return m.fields
+		}
 		// No filtering.
-		if !gstr.Contains(m.fields, ".") && !gstr.Contains(m.fields, " ") {
+		if !gstr.ContainsAny(m.fields, ". ") {
 			return m.db.GetCore().QuoteString(m.fields)
 		}
 		return m.fields
@@ -130,10 +133,11 @@ func (m *Model) Chunk(size int, handler ChunkHandler) {
 // The optional parameter `where` is the same as the parameter of Model.Where function,
 // see Model.Where.
 func (m *Model) One(where ...interface{}) (Record, error) {
+	var ctx = m.GetCtx()
 	if len(where) > 0 {
 		return m.Where(where[0], where[1:]...).One()
 	}
-	all, err := m.doGetAll(true)
+	all, err := m.doGetAll(ctx, true)
 	if err != nil {
 		return nil, err
 	}
@@ -150,6 +154,7 @@ func (m *Model) One(where ...interface{}) (Record, error) {
 // and fieldsAndWhere[1:] is treated as where condition fields.
 // Also see Model.Fields and Model.Where functions.
 func (m *Model) Value(fieldsAndWhere ...interface{}) (Value, error) {
+	var ctx = m.GetCtx()
 	if len(fieldsAndWhere) > 0 {
 		if len(fieldsAndWhere) > 2 {
 			return m.Fields(gconv.String(fieldsAndWhere[0])).Where(fieldsAndWhere[1], fieldsAndWhere[2:]...).Value()
@@ -159,14 +164,26 @@ func (m *Model) Value(fieldsAndWhere ...interface{}) (Value, error) {
 			return m.Fields(gconv.String(fieldsAndWhere[0])).Value()
 		}
 	}
-	one, err := m.One()
-	if err != nil {
-		return gvar.New(nil), err
+	var (
+		all Result
+		err error
+	)
+	if all, err = m.doGetAll(ctx, true); err != nil {
+		return nil, err
 	}
-	for _, v := range one {
-		return v, nil
+	if len(all) == 0 {
+		return gvar.New(nil), nil
 	}
-	return gvar.New(nil), nil
+	if internalData := m.db.GetCore().GetInternalCtxDataFromCtx(ctx); internalData != nil {
+		record := all[0]
+		if v, ok := record[internalData.FirstResultColumn]; ok {
+			return v, nil
+		}
+	}
+	return nil, gerror.NewCode(
+		gcode.CodeInternalError,
+		`query value error: the internal context data is missing. there's internal issue should be fixed`,
+	)
 }
 
 // Array queries and returns data values as slice from database.
@@ -362,20 +379,28 @@ func (m *Model) ScanList(structSlicePointer interface{}, bindToAttrName string,
 // The optional parameter `where` is the same as the parameter of Model.Where function,
 // see Model.Where.
 func (m *Model) Count(where ...interface{}) (int, error) {
+	var ctx = m.GetCtx()
 	if len(where) > 0 {
 		return m.Where(where[0], where[1:]...).Count()
 	}
 	var (
-		sqlWithHolder, holderArgs = m.getFormattedSqlAndArgs(queryTypeCount, false)
-		list, err                 = m.doGetAllBySql(sqlWithHolder, holderArgs...)
+		sqlWithHolder, holderArgs = m.getFormattedSqlAndArgs(ctx, queryTypeCount, false)
+		all, err                  = m.doGetAllBySql(ctx, queryTypeCount, sqlWithHolder, holderArgs...)
 	)
 	if err != nil {
 		return 0, err
 	}
-	if len(list) > 0 {
-		for _, v := range list[0] {
-			return v.Int(), nil
+	if len(all) > 0 {
+		if internalData := m.db.GetCore().GetInternalCtxDataFromCtx(ctx); internalData != nil {
+			record := all[0]
+			if v, ok := record[internalData.FirstResultColumn]; ok {
+				return v.Int(), nil
+			}
 		}
+		return 0, gerror.NewCode(
+			gcode.CodeInternalError,
+			`query count error: the internal context data is missing. there's internal issue should be fixed`,
+		)
 	}
 	return 0, nil
 }
@@ -502,81 +527,54 @@ func (m *Model) Having(having interface{}, args ...interface{}) *Model {
 }
 
 // doGetAllBySql does the select statement on the database.
-func (m *Model) doGetAllBySql(sql string, args ...interface{}) (result Result, err error) {
-	var (
-		ok       bool
-		ctx      = m.GetCtx()
-		cacheKey = ""
-		cacheObj = m.db.GetCache()
-	)
-	// Retrieve from cache.
-	if m.cacheEnabled && m.tx == nil {
-		cacheKey = m.cacheOption.Name
-		if len(cacheKey) == 0 {
-			cacheKey = fmt.Sprintf(
-				`GCache@Schema(%s):%s`,
-				m.db.GetSchema(),
-				gmd5.MustEncryptString(sql+", @PARAMS:"+gconv.String(args)),
-			)
-		}
-		if v, _ := cacheObj.Get(ctx, cacheKey); !v.IsNil() {
-			if result, ok = v.Val().(Result); ok {
-				// In-memory cache.
-				return result, nil
-			}
-			// Other cache, it needs conversion.
-			if err = json.UnmarshalUseNumber(v.Bytes(), &result); err != nil {
-				return nil, err
-			} else {
-				return result, nil
-			}
-		}
+func (m *Model) doGetAllBySql(ctx context.Context, queryType int, sql string, args ...interface{}) (result Result, err error) {
+	if result, err = m.getSelectResultFromCache(ctx, sql, args...); err != nil || result != nil {
+		return
 	}
-	result, err = m.db.DoGetAll(
-		m.GetCtx(), m.getLink(false), sql, m.mergeArguments(args)...,
-	)
-	// Cache the result.
-	if cacheKey != "" && err == nil {
-		if m.cacheOption.Duration < 0 {
-			if _, err = cacheObj.Remove(ctx, cacheKey); err != nil {
-				intlog.Errorf(m.GetCtx(), `%+v`, err)
-			}
-		} else {
-			// In case of Cache Penetration.
-			if result.IsEmpty() && m.cacheOption.Force {
-				result = Result{}
-			}
-			if err = cacheObj.Set(ctx, cacheKey, result, m.cacheOption.Duration); err != nil {
-				intlog.Errorf(m.GetCtx(), `%+v`, err)
-			}
-		}
+
+	in := &HookSelectInput{
+		internalParamHookSelect: internalParamHookSelect{
+			internalParamHook: internalParamHook{
+				link:  m.getLink(false),
+				model: m,
+			},
+			handler: m.hookHandler.Select,
+		},
+		Table: m.tables,
+		Sql:   sql,
+		Args:  m.mergeArguments(args),
 	}
-	return result, err
+	if result, err = in.Next(ctx); err != nil {
+		return
+	}
+
+	err = m.saveSelectResultToCache(ctx, result, sql, args...)
+	return
 }
 
-func (m *Model) getFormattedSqlAndArgs(queryType int, limit1 bool) (sqlWithHolder string, holderArgs []interface{}) {
+func (m *Model) getFormattedSqlAndArgs(ctx context.Context, queryType int, limit1 bool) (sqlWithHolder string, holderArgs []interface{}) {
 	switch queryType {
 	case queryTypeCount:
-		countFields := "COUNT(1)"
+		queryFields := "COUNT(1)"
 		if m.fields != "" && m.fields != "*" {
 			// DO NOT quote the m.fields here, in case of fields like:
 			// DISTINCT t.user_id uid
-			countFields = fmt.Sprintf(`COUNT(%s%s)`, m.distinct, m.fields)
+			queryFields = fmt.Sprintf(`COUNT(%s%s)`, m.distinct, m.fields)
 		}
 		// Raw SQL Model.
 		if m.rawSql != "" {
-			sqlWithHolder = fmt.Sprintf("SELECT %s FROM (%s) AS T", countFields, m.rawSql)
+			sqlWithHolder = fmt.Sprintf("SELECT %s FROM (%s) AS T", queryFields, m.rawSql)
 			return sqlWithHolder, nil
 		}
-		conditionWhere, conditionExtra, conditionArgs := m.formatCondition(false, true)
-		sqlWithHolder = fmt.Sprintf("SELECT %s FROM %s%s", countFields, m.tables, conditionWhere+conditionExtra)
+		conditionWhere, conditionExtra, conditionArgs := m.formatCondition(ctx, false, true)
+		sqlWithHolder = fmt.Sprintf("SELECT %s FROM %s%s", queryFields, m.tables, conditionWhere+conditionExtra)
 		if len(m.groupBy) > 0 {
 			sqlWithHolder = fmt.Sprintf("SELECT COUNT(1) FROM (%s) count_alias", sqlWithHolder)
 		}
 		return sqlWithHolder, conditionArgs
 
 	default:
-		conditionWhere, conditionExtra, conditionArgs := m.formatCondition(limit1, false)
+		conditionWhere, conditionExtra, conditionArgs := m.formatCondition(ctx, limit1, false)
 		// Raw SQL Model, especially for UNION/UNION ALL featured SQL.
 		if m.rawSql != "" {
 			sqlWithHolder = fmt.Sprintf(
@@ -590,10 +588,7 @@ func (m *Model) getFormattedSqlAndArgs(queryType int, limit1 bool) (sqlWithHolde
 		// DISTINCT t.user_id uid
 		sqlWithHolder = fmt.Sprintf(
 			"SELECT %s%s FROM %s%s",
-			m.distinct,
-			m.getFieldsFiltered(),
-			m.tables,
-			conditionWhere+conditionExtra,
+			m.distinct, m.getFieldsFiltered(), m.tables, conditionWhere+conditionExtra,
 		)
 		return sqlWithHolder, conditionArgs
 	}
@@ -603,7 +598,7 @@ func (m *Model) getFormattedSqlAndArgs(queryType int, limit1 bool) (sqlWithHolde
 // Note that this function does not change any attribute value of the `m`.
 //
 // The parameter `limit1` specifies whether limits querying only one record if m.limit is not set.
-func (m *Model) formatCondition(limit1 bool, isCountStatement bool) (conditionWhere string, conditionExtra string, conditionArgs []interface{}) {
+func (m *Model) formatCondition(ctx context.Context, limit1 bool, isCountStatement bool) (conditionWhere string, conditionExtra string, conditionArgs []interface{}) {
 	autoPrefix := ""
 	if gstr.Contains(m.tables, " JOIN ") {
 		autoPrefix = m.db.GetCore().QuoteWord(
@@ -623,7 +618,7 @@ func (m *Model) formatCondition(limit1 bool, isCountStatement bool) (conditionWh
 			switch holder.Operator {
 			case whereHolderOperatorWhere:
 				if conditionWhere == "" {
-					newWhere, newArgs := formatWhereHolder(m.db, formatWhereHolderInput{
+					newWhere, newArgs := formatWhereHolder(ctx, m.db, formatWhereHolderInput{
 						ModelWhereHolder: holder,
 						OmitNil:          m.option&optionOmitNilWhere > 0,
 						OmitEmpty:        m.option&optionOmitEmptyWhere > 0,
@@ -639,7 +634,7 @@ func (m *Model) formatCondition(limit1 bool, isCountStatement bool) (conditionWh
 				fallthrough
 
 			case whereHolderOperatorAnd:
-				newWhere, newArgs := formatWhereHolder(m.db, formatWhereHolderInput{
+				newWhere, newArgs := formatWhereHolder(ctx, m.db, formatWhereHolderInput{
 					ModelWhereHolder: holder,
 					OmitNil:          m.option&optionOmitNilWhere > 0,
 					OmitEmpty:        m.option&optionOmitEmptyWhere > 0,
@@ -658,7 +653,7 @@ func (m *Model) formatCondition(limit1 bool, isCountStatement bool) (conditionWh
 				}
 
 			case whereHolderOperatorOr:
-				newWhere, newArgs := formatWhereHolder(m.db, formatWhereHolderInput{
+				newWhere, newArgs := formatWhereHolder(ctx, m.db, formatWhereHolderInput{
 					ModelWhereHolder: holder,
 					OmitNil:          m.option&optionOmitNilWhere > 0,
 					OmitEmpty:        m.option&optionOmitEmptyWhere > 0,
@@ -709,7 +704,7 @@ func (m *Model) formatCondition(limit1 bool, isCountStatement bool) (conditionWh
 			Args:   gconv.Interfaces(m.having[1]),
 			Prefix: autoPrefix,
 		}
-		havingStr, havingArgs := formatWhereHolder(m.db, formatWhereHolderInput{
+		havingStr, havingArgs := formatWhereHolder(ctx, m.db, formatWhereHolderInput{
 			ModelWhereHolder: havingHolder,
 			OmitNil:          m.option&optionOmitNilWhere > 0,
 			OmitEmpty:        m.option&optionOmitEmptyWhere > 0,

database/gdb/gdb_model_update.go

@@ -25,6 +25,7 @@ import (
 // and dataAndWhere[1:] is treated as where condition fields.
 // Also see Model.Data and Model.Where functions.
 func (m *Model) Update(dataAndWhere ...interface{}) (result sql.Result, err error) {
+	var ctx = m.GetCtx()
 	if len(dataAndWhere) > 0 {
 		if len(dataAndWhere) > 2 {
 			return m.Data(dataAndWhere[0]).Where(dataAndWhere[1], dataAndWhere[2:]...).Update()
@@ -36,7 +37,7 @@ func (m *Model) Update(dataAndWhere ...interface{}) (result sql.Result, err erro
 	}
 	defer func() {
 		if err == nil {
-			m.checkAndRemoveCache()
+			m.checkAndRemoveSelectCache(ctx)
 		}
 	}()
 	if m.data == nil {
@@ -44,27 +45,28 @@ func (m *Model) Update(dataAndWhere ...interface{}) (result sql.Result, err erro
 	}
 	var (
 		updateData                                    = m.data
+		reflectInfo                                   = reflection.OriginTypeAndKind(updateData)
 		fieldNameUpdate                               = m.getSoftFieldNameUpdated()
-		conditionWhere, conditionExtra, conditionArgs = m.formatCondition(false, false)
+		conditionWhere, conditionExtra, conditionArgs = m.formatCondition(ctx, false, false)
 	)
-	// Automatically update the record updating time.
-	if !m.unscoped && fieldNameUpdate != "" {
-		reflectInfo := reflection.OriginTypeAndKind(m.data)
-		switch reflectInfo.OriginKind {
-		case reflect.Map, reflect.Struct:
-			dataMap := m.db.ConvertDataForRecord(m.GetCtx(), m.data)
-			if fieldNameUpdate != "" {
-				dataMap[fieldNameUpdate] = gtime.Now().String()
-			}
-			updateData = dataMap
+	switch reflectInfo.OriginKind {
+	case reflect.Map, reflect.Struct:
+		dataMap := m.db.ConvertDataForRecord(ctx, m.data)
+		// Automatically update the record updating time.
+		if !m.unscoped && fieldNameUpdate != "" {
+			dataMap[fieldNameUpdate] = gtime.Now().String()
+		}
+		updateData = dataMap
 
-		default:
-			updates := gconv.String(m.data)
+	default:
+		updates := gconv.String(m.data)
+		// Automatically update the record updating time.
+		if !m.unscoped && fieldNameUpdate != "" {
 			if fieldNameUpdate != "" && !gstr.Contains(updates, fieldNameUpdate) {
 				updates += fmt.Sprintf(`,%s='%s'`, fieldNameUpdate, gtime.Now().String())
 			}
-			updateData = updates
 		}
+		updateData = updates
 	}
 	newData, err := m.filterDataForInsertOrUpdate(updateData)
 	if err != nil {
@@ -74,14 +76,30 @@ func (m *Model) Update(dataAndWhere ...interface{}) (result sql.Result, err erro
 	if !gstr.ContainsI(conditionStr, " WHERE ") {
 		return nil, gerror.NewCode(gcode.CodeMissingParameter, "there should be WHERE condition statement for UPDATE operation")
 	}
-	return m.db.DoUpdate(
-		m.GetCtx(),
-		m.getLink(true),
-		m.tables,
-		newData,
-		conditionStr,
-		m.mergeArguments(conditionArgs)...,
-	)
+
+	in := &HookUpdateInput{
+		internalParamHookUpdate: internalParamHookUpdate{
+			internalParamHook: internalParamHook{
+				link:  m.getLink(true),
+				model: m,
+			},
+			handler: m.hookHandler.Update,
+		},
+		Table:     m.tables,
+		Data:      newData,
+		Condition: conditionStr,
+		Args:      m.mergeArguments(conditionArgs),
+	}
+	return in.Next(ctx)
+}
+
+// UpdateAndGetAffected performs update statement and returns the affected rows number.
+func (m *Model) UpdateAndGetAffected(dataAndWhere ...interface{}) (affected int64, err error) {
+	result, err := m.Update(dataAndWhere...)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected()
 }
 
 // Increment increments a column's value by a given amount.

database/gdb/gdb_model_with.go

@@ -143,7 +143,7 @@ func (m *Model) doWithScanStruct(pointer interface{}) error {
 		}
 
 		// Recursively with feature checks.
-		model = m.db.With(field.Value)
+		model = m.db.With(field.Value).Hook(m.hookHandler)
 		if m.withAll {
 			model = model.WithAll()
 		} else {
@@ -258,7 +258,7 @@ func (m *Model) doWithScanStructs(pointer interface{}) error {
 			fieldKeys = structType.FieldKeys()
 		}
 		// Recursively with feature checks.
-		model = m.db.With(field.Value)
+		model = m.db.With(field.Value).Hook(m.hookHandler)
 		if m.withAll {
 			model = model.WithAll()
 		} else {

database/gdb/gdb_z_mysql_feature_hook_test.go

@@ -0,0 +1,136 @@
+// Copyright GoFrame Author(https://goframe.org). 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_test
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"testing"
+
+	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_Model_Hook_Select(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		m := db.Model(table).Hook(gdb.HookHandler{
+			Select: func(ctx context.Context, in *gdb.HookSelectInput) (result gdb.Result, err error) {
+				result, err = in.Next(ctx)
+				if err != nil {
+					return
+				}
+				for i, record := range result {
+					record["test"] = gvar.New(100 + record["id"].Int())
+					result[i] = record
+				}
+				return
+			},
+		})
+		all, err := m.Where(`id > 6`).OrderAsc(`id`).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 4)
+		t.Assert(all[0]["id"].Int(), 7)
+		t.Assert(all[0]["test"].Int(), 107)
+		t.Assert(all[1]["test"].Int(), 108)
+		t.Assert(all[2]["test"].Int(), 109)
+		t.Assert(all[3]["test"].Int(), 110)
+	})
+}
+
+func Test_Model_Hook_Insert(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		m := db.Model(table).Hook(gdb.HookHandler{
+			Insert: func(ctx context.Context, in *gdb.HookInsertInput) (result sql.Result, err error) {
+				for i, item := range in.Data {
+					item["passport"] = fmt.Sprintf(`test_port_%d`, item["id"])
+					item["nickname"] = fmt.Sprintf(`test_name_%d`, item["id"])
+					in.Data[i] = item
+				}
+				return in.Next(ctx)
+			},
+		})
+		_, err := m.Insert(g.Map{
+			"id":       1,
+			"nickname": "name_1",
+		})
+		t.AssertNil(err)
+		one, err := m.One()
+		t.AssertNil(err)
+		t.Assert(one["id"].Int(), 1)
+		t.Assert(one["passport"], `test_port_1`)
+		t.Assert(one["nickname"], `test_name_1`)
+	})
+}
+
+func Test_Model_Hook_Update(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		m := db.Model(table).Hook(gdb.HookHandler{
+			Update: func(ctx context.Context, in *gdb.HookUpdateInput) (result sql.Result, err error) {
+				switch value := in.Data.(type) {
+				case gdb.List:
+					for i, data := range value {
+						data["passport"] = `port`
+						data["nickname"] = `name`
+						value[i] = data
+					}
+					in.Data = value
+
+				case gdb.Map:
+					value["passport"] = `port`
+					value["nickname"] = `name`
+					in.Data = value
+				}
+				return in.Next(ctx)
+			},
+		})
+		_, err := m.Data(g.Map{
+			"nickname": "name_1",
+		}).WherePri(1).Update()
+		t.AssertNil(err)
+
+		one, err := m.One()
+		t.AssertNil(err)
+		t.Assert(one["id"].Int(), 1)
+		t.Assert(one["passport"], `port`)
+		t.Assert(one["nickname"], `name`)
+	})
+}
+
+func Test_Model_Hook_Delete(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		m := db.Model(table).Hook(gdb.HookHandler{
+			Delete: func(ctx context.Context, in *gdb.HookDeleteInput) (result sql.Result, err error) {
+				return db.Model(table).Data(g.Map{
+					"nickname": `deleted`,
+				}).Where(in.Condition).Update()
+			},
+		})
+		_, err := m.Where(1).Delete()
+		t.AssertNil(err)
+
+		all, err := m.All()
+		t.AssertNil(err)
+		for _, item := range all {
+			t.Assert(item["nickname"].String(), `deleted`)
+		}
+	})
+}

database/gdb/gdb_z_mysql_feature_model_struct_test.go

@@ -550,7 +550,7 @@ func Test_Scan_JsonAttributes(t *testing.T) {
 	}
 
 	table := "jfy_gift"
-	array := gstr.SplitAndTrim(gtest.TestDataContent(`issue1380.sql`), ";")
+	array := gstr.SplitAndTrim(gtest.DataContent(`issue1380.sql`), ";")
 	for _, v := range array {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)

database/gdb/gdb_z_mysql_feature_sharding_test.go

@@ -0,0 +1,138 @@
+// Copyright GoFrame Author(https://goframe.org). 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_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_Model_Sharding(t *testing.T) {
+	table1 := createTable()
+	table2 := createTable()
+	defer dropTable(table1)
+	defer dropTable(table2)
+
+	gtest.C(t, func(t *gtest.T) {
+		_, err1 := db.Model(table1).Data(g.Map{
+			"id": 1,
+		}).Insert()
+		t.AssertNil(err1)
+		_, err2 := db.Model(table2).Data(g.Map{
+			"id": 2,
+		}).Insert()
+		t.AssertNil(err2)
+	})
+	// no sharding.
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model(table1).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 1)
+		t.Assert(all[0]["id"].String(), 1)
+	})
+	// with sharding handler.
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model(table1).Sharding(func(ctx context.Context, in gdb.ShardingInput) (out *gdb.ShardingOutput, err error) {
+			out = &gdb.ShardingOutput{
+				Table: table2,
+			}
+			return
+		}).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 1)
+		t.Assert(all[0]["id"].String(), 2)
+	})
+	// with sharding handler and no existence table name.
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model("none").Sharding(func(ctx context.Context, in gdb.ShardingInput) (out *gdb.ShardingOutput, err error) {
+			out = &gdb.ShardingOutput{
+				Table: table2,
+			}
+			return
+		}).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 1)
+		t.Assert(all[0]["id"].String(), 2)
+	})
+	// with sharding handler and no existence table name and tables fields retrieving.
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id       int
+			Passport string
+			Password string
+			NickName string
+		}
+		var users []User
+		err := db.Model("none").Sharding(func(ctx context.Context, in gdb.ShardingInput) (out *gdb.ShardingOutput, err error) {
+			out = &gdb.ShardingOutput{
+				Table: table2,
+			}
+			return
+		}).Scan(&users)
+		t.AssertNil(err)
+		t.Assert(len(users), 1)
+		t.Assert(users[0].Id, 2)
+	})
+}
+
+func Test_Model_Sharding_Schema(t *testing.T) {
+	var (
+		db1    = db
+		db2    = db.Schema(TestSchema2)
+		table1 = createTableWithDb(db1)
+		table2 = createTableWithDb(db2)
+	)
+
+	defer dropTableWithDb(db1, table1)
+	defer dropTableWithDb(db2, table2)
+
+	gtest.C(t, func(t *gtest.T) {
+		_, err1 := db1.Model(table1).Data(g.Map{
+			"id": 1,
+		}).Insert()
+		t.AssertNil(err1)
+		_, err2 := db2.Model(table2).Data(g.Map{
+			"id": 2,
+		}).Insert()
+		t.AssertNil(err2)
+	})
+	// no sharding.
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db1.Model(table1).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 1)
+		t.Assert(all[0]["id"].String(), 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		_, err := db1.Model(table2).All()
+		// Table not exist error.
+		t.AssertNE(err, nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db2.Model(table2).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 1)
+		t.Assert(all[0]["id"].String(), 2)
+	})
+	// with sharding handler and no existence table name and schema change.
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db1.Model("none").Sharding(func(ctx context.Context, in gdb.ShardingInput) (out *gdb.ShardingOutput, err error) {
+			out = &gdb.ShardingOutput{
+				Table:  table2,
+				Schema: TestSchema2,
+			}
+			return
+		}).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 1)
+		t.Assert(all[0]["id"].String(), 2)
+	})
+}

database/gdb/gdb_z_mysql_feature_with_test.go

@@ -10,7 +10,6 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/gogf/gf/v2/debug/gdebug"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/test/gtest"
@@ -1644,7 +1643,7 @@ func Test_Table_Relation_With_MultipleDepends1(t *testing.T) {
 		dropTable("table_b")
 		dropTable("table_c")
 	}()
-	for _, v := range gstr.SplitAndTrim(gfile.GetContents(gdebug.TestDataPath("with_multiple_depends.sql")), ";") {
+	for _, v := range gstr.SplitAndTrim(gfile.GetContents(gtest.DataPath("with_multiple_depends.sql")), ";") {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)
 		}
@@ -1716,7 +1715,7 @@ func Test_Table_Relation_With_MultipleDepends2(t *testing.T) {
 		dropTable("table_b")
 		dropTable("table_c")
 	}()
-	for _, v := range gstr.SplitAndTrim(gfile.GetContents(gdebug.TestDataPath("with_multiple_depends.sql")), ";") {
+	for _, v := range gstr.SplitAndTrim(gfile.GetContents(gtest.DataPath("with_multiple_depends.sql")), ";") {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)
 		}
@@ -1803,7 +1802,7 @@ func Test_Table_Relation_With_MultipleDepends_Embedded(t *testing.T) {
 		dropTable("table_b")
 		dropTable("table_c")
 	}()
-	for _, v := range gstr.SplitAndTrim(gfile.GetContents(gdebug.TestDataPath("with_multiple_depends.sql")), ";") {
+	for _, v := range gstr.SplitAndTrim(gfile.GetContents(gtest.DataPath("with_multiple_depends.sql")), ";") {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)
 		}
@@ -1996,7 +1995,7 @@ func Test_With_Feature_Issue1401(t *testing.T) {
 		table1 = "parcels"
 		table2 = "parcel_items"
 	)
-	array := gstr.SplitAndTrim(gtest.TestDataContent(`issue1401.sql`), ";")
+	array := gstr.SplitAndTrim(gtest.DataContent(`issue1401.sql`), ";")
 	for _, v := range array {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)
@@ -2038,7 +2037,7 @@ func Test_With_Feature_Issue1412(t *testing.T) {
 		table1 = "parcels"
 		table2 = "items"
 	)
-	array := gstr.SplitAndTrim(gtest.TestDataContent(`issue1412.sql`), ";")
+	array := gstr.SplitAndTrim(gtest.DataContent(`issue1412.sql`), ";")
 	for _, v := range array {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)

database/gdb/gdb_z_mysql_model_test.go

@@ -18,13 +18,13 @@ import (
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
 	"github.com/gogf/gf/v2/database/gdb"
-	"github.com/gogf/gf/v2/debug/gdebug"
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/guid"
 	"github.com/gogf/gf/v2/util/gutil"
 )
 
@@ -433,6 +433,18 @@ func Test_Model_Update(t *testing.T) {
 	})
 }
 
+func Test_Model_UpdateAndGetAffected(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		n, err := db.Model(table).Data("nickname", "T100").
+			Where(1).Order("id desc").Limit(2).
+			UpdateAndGetAffected()
+		t.AssertNil(err)
+		t.Assert(n, 2)
+	})
+}
+
 func Test_Model_Clone(t *testing.T) {
 	table := createInitTable()
 	defer dropTable(table)
@@ -689,6 +701,18 @@ func Test_Model_Count(t *testing.T) {
 		t.AssertNil(err)
 		t.Assert(count, TableSize)
 	})
+	// Count with cache, check internal ctx data feature.
+	gtest.C(t, func(t *gtest.T) {
+		for i := 0; i < 10; i++ {
+			count, err := db.Model(table).Cache(gdb.CacheOption{
+				Duration: time.Second * 10,
+				Name:     guid.S(),
+				Force:    false,
+			}).Count()
+			t.AssertNil(err)
+			t.Assert(count, TableSize)
+		}
+	})
 	gtest.C(t, func(t *gtest.T) {
 		count, err := db.Model(table).FieldsEx("id").Where("id>8").Count()
 		t.AssertNil(err)
@@ -2195,7 +2219,7 @@ func Test_Model_FieldsEx_WithReservedWords(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (
 			table      = "fieldsex_test_table"
-			sqlTpcPath = gdebug.TestDataPath("reservedwords_table_tpl.sql")
+			sqlTpcPath = gtest.DataPath("reservedwords_table_tpl.sql")
 			sqlContent = gfile.GetContents(sqlTpcPath)
 		)
 		t.AssertNE(sqlContent, "")
@@ -4203,3 +4227,62 @@ func Test_Model_WherePrefixLike(t *testing.T) {
 		t.Assert(r[0]["id"], "3")
 	})
 }
+
+// https://github.com/gogf/gf/issues/1700
+func Test_Model_Issue1700(t *testing.T) {
+	table := "user_" + gtime.Now().TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+	    CREATE TABLE %s (
+	        id         int(10) unsigned NOT NULL AUTO_INCREMENT,
+	        user_id    int(10) unsigned NOT NULL,
+	        UserId    int(10) unsigned NOT NULL,
+	        PRIMARY KEY (id)
+	    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+	    `, table,
+	)); err != nil {
+		gtest.AssertNil(err)
+	}
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id     int `orm:"id"`
+			Userid int `orm:"user_id"`
+			UserId int `orm:"UserId"`
+		}
+		_, err := db.Model(table).Data(User{
+			Id:     1,
+			Userid: 2,
+			UserId: 3,
+		}).Insert()
+		t.AssertNil(err)
+
+		one, err := db.Model(table).One()
+		t.AssertNil(err)
+		t.Assert(one, g.Map{
+			"id":      1,
+			"user_id": 2,
+			"UserId":  3,
+		})
+
+		for i := 0; i < 1000; i++ {
+			var user *User
+			err = db.Model(table).Scan(&user)
+			t.AssertNil(err)
+			t.Assert(user.Id, 1)
+			t.Assert(user.Userid, 2)
+			t.Assert(user.UserId, 3)
+		}
+	})
+}
+
+// https://github.com/gogf/gf/issues/1701
+func Test_Model_Issue1701(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		value, err := db.Model(table).Fields(gdb.Raw("if(id=1,100,null)")).WherePri(1).Value()
+		t.AssertNil(err)
+		t.Assert(value.String(), 100)
+	})
+}

debug/gdebug/gdebug_testdata.go

@@ -1,36 +0,0 @@
-// Copyright GoFrame Author(https://goframe.org). 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 (
-	"io/ioutil"
-	"path/filepath"
-)
-
-// TestDataPath retrieves and returns the testdata path of current package,
-// which is used for unit testing cases only.
-// The optional parameter `names` specifies the sub-folders/sub-files,
-// which will be joined with current system separator and returned with the path.
-func TestDataPath(names ...string) string {
-	path := CallerDirectory() + string(filepath.Separator) + "testdata"
-	for _, name := range names {
-		path += string(filepath.Separator) + name
-	}
-	return path
-}
-
-// TestDataContent retrieves and returns the file content for specified testdata path of current package
-func TestDataContent(names ...string) string {
-	path := TestDataPath(names...)
-	if path != "" {
-		data, err := ioutil.ReadFile(path)
-		if err == nil {
-			return string(data)
-		}
-	}
-	return ""
-}

encoding/gbase64/gbase64_z_unit_test.go

@@ -9,7 +9,6 @@ package gbase64_test
 import (
 	"testing"
 
-	"github.com/gogf/gf/v2/debug/gdebug"
 	"github.com/gogf/gf/v2/encoding/gbase64"
 	"github.com/gogf/gf/v2/test/gtest"
 )
@@ -66,7 +65,7 @@ func Test_Basic(t *testing.T) {
 }
 
 func Test_File(t *testing.T) {
-	path := gdebug.TestDataPath("test")
+	path := gtest.DataPath("test")
 	expect := "dGVzdA=="
 	gtest.C(t, func(t *gtest.T) {
 		b, err := gbase64.EncodeFile(path)

encoding/gcompress/gcompress_z_unit_gzip_test.go

@@ -9,7 +9,6 @@ package gcompress_test
 import (
 	"testing"
 
-	"github.com/gogf/gf/v2/debug/gdebug"
 	"github.com/gogf/gf/v2/encoding/gcompress"
 	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/os/gtime"
@@ -43,7 +42,7 @@ func Test_Gzip_UnGzip(t *testing.T) {
 }
 
 func Test_Gzip_UnGzip_File(t *testing.T) {
-	srcPath := gdebug.TestDataPath("gzip", "file.txt")
+	srcPath := gtest.DataPath("gzip", "file.txt")
 	dstPath1 := gfile.Temp(gtime.TimestampNanoStr(), "gzip.zip")
 	dstPath2 := gfile.Temp(gtime.TimestampNanoStr(), "file.txt")
 

encoding/gcompress/gcompress_z_unit_zip_test.go

@@ -10,7 +10,6 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/gogf/gf/v2/debug/gdebug"
 	"github.com/gogf/gf/v2/encoding/gcompress"
 	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/os/gtime"
@@ -20,8 +19,8 @@ import (
 func Test_ZipPath(t *testing.T) {
 	// file
 	gtest.C(t, func(t *gtest.T) {
-		srcPath := gdebug.TestDataPath("zip", "path1", "1.txt")
-		dstPath := gdebug.TestDataPath("zip", "zip.zip")
+		srcPath := gtest.DataPath("zip", "path1", "1.txt")
+		dstPath := gtest.DataPath("zip", "zip.zip")
 
 		t.Assert(gfile.Exists(dstPath), false)
 		t.Assert(gcompress.ZipPath(srcPath, dstPath), nil)
@@ -42,8 +41,8 @@ func Test_ZipPath(t *testing.T) {
 	// multiple files
 	gtest.C(t, func(t *gtest.T) {
 		var (
-			srcPath1 = gdebug.TestDataPath("zip", "path1", "1.txt")
-			srcPath2 = gdebug.TestDataPath("zip", "path2", "2.txt")
+			srcPath1 = gtest.DataPath("zip", "path1", "1.txt")
+			srcPath2 = gtest.DataPath("zip", "path2", "2.txt")
 			dstPath  = gfile.Temp(gtime.TimestampNanoStr(), "zip.zip")
 		)
 		if p := gfile.Dir(dstPath); !gfile.Exists(p) {
@@ -75,8 +74,8 @@ func Test_ZipPath(t *testing.T) {
 	// one dir and one file.
 	gtest.C(t, func(t *gtest.T) {
 		var (
-			srcPath1 = gdebug.TestDataPath("zip", "path1")
-			srcPath2 = gdebug.TestDataPath("zip", "path2", "2.txt")
+			srcPath1 = gtest.DataPath("zip", "path1")
+			srcPath2 = gtest.DataPath("zip", "path2", "2.txt")
 			dstPath  = gfile.Temp(gtime.TimestampNanoStr(), "zip.zip")
 		)
 		if p := gfile.Dir(dstPath); !gfile.Exists(p) {
@@ -107,8 +106,8 @@ func Test_ZipPath(t *testing.T) {
 	})
 	// directory.
 	gtest.C(t, func(t *gtest.T) {
-		srcPath := gdebug.TestDataPath("zip")
-		dstPath := gdebug.TestDataPath("zip", "zip.zip")
+		srcPath := gtest.DataPath("zip")
+		dstPath := gtest.DataPath("zip", "zip.zip")
 
 		pwd := gfile.Pwd()
 		err := gfile.Chdir(srcPath)
@@ -141,10 +140,10 @@ func Test_ZipPath(t *testing.T) {
 	// multiple directory paths joined using char ','.
 	gtest.C(t, func(t *gtest.T) {
 		var (
-			srcPath  = gdebug.TestDataPath("zip")
-			srcPath1 = gdebug.TestDataPath("zip", "path1")
-			srcPath2 = gdebug.TestDataPath("zip", "path2")
-			dstPath  = gdebug.TestDataPath("zip", "zip.zip")
+			srcPath  = gtest.DataPath("zip")
+			srcPath1 = gtest.DataPath("zip", "path1")
+			srcPath2 = gtest.DataPath("zip", "path2")
+			dstPath  = gtest.DataPath("zip", "zip.zip")
 		)
 		pwd := gfile.Pwd()
 		err := gfile.Chdir(srcPath)
@@ -181,9 +180,9 @@ func Test_ZipPath(t *testing.T) {
 func Test_ZipPathWriter(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (
-			srcPath  = gdebug.TestDataPath("zip")
-			srcPath1 = gdebug.TestDataPath("zip", "path1")
-			srcPath2 = gdebug.TestDataPath("zip", "path2")
+			srcPath  = gtest.DataPath("zip")
+			srcPath1 = gtest.DataPath("zip", "path1")
+			srcPath2 = gtest.DataPath("zip", "path2")
 		)
 		pwd := gfile.Pwd()
 		err := gfile.Chdir(srcPath)

encoding/gjson/gjson.go

@@ -22,8 +22,17 @@ import (
 )
 
 const (
-	// Separator char for hierarchical data access.
-	defaultSplitChar = '.'
+	ContentTypeJson = `json`
+	ContentTypeJs   = `js`
+	ContentTypeXml  = `xml`
+	ContentTypeIni  = `ini`
+	ContentTypeYaml = `yaml`
+	ContentTypeYml  = `yml`
+	ContentTypeToml = `toml`
+)
+
+const (
+	defaultSplitChar = '.' // Separator char for hierarchical data access.
 )
 
 // Json is the customized JSON struct.
@@ -34,10 +43,11 @@ type Json struct {
 	vc bool         // Violence Check(false in default), which is used to access data when the hierarchical data key contains separator char.
 }
 
-// Options for Json object creating.
+// Options for Json object creating/loading.
 type Options struct {
 	Safe      bool   // Mark this object is for in concurrent-safe usage. This is especially for Json object creating.
-	Tags      string // Custom priority tags for decoding. Eg: "json,yaml,MyTag". This is especially for struct parsing into Json object.
+	Tags      string // Custom priority tags for decoding, eg: "json,yaml,MyTag". This is especially for struct parsing into Json object.
+	Type      string // Type specifies the data content type, eg: json, xml, yaml, toml, ini.
 	StrNumber bool   // StrNumber causes the Decoder to unmarshal a number into an interface{} as a string instead of as a float64.
 }
 

encoding/gjson/gjson_api.go

@@ -41,7 +41,7 @@ func (j *Json) IsNil() bool {
 }
 
 // Get retrieves and returns value by specified `pattern`.
-// It returns all values of current Json object if `pattern` is given empty or string ".".
+// It returns all values of current Json object if `pattern` is given ".".
 // It returns nil if no value found by `pattern`.
 //
 // We can also access slice item by its index number in `pattern` like:
@@ -71,7 +71,7 @@ func (j *Json) Get(pattern string, def ...interface{}) *gvar.Var {
 }
 
 // GetJson gets the value by specified `pattern`,
-// and converts it to a un-concurrent-safe Json object.
+// and converts it to an un-concurrent-safe Json object.
 func (j *Json) GetJson(pattern string, def ...interface{}) *Json {
 	return New(j.Get(pattern, def...).Val())
 }

encoding/gjson/gjson_api_new_load.go

@@ -21,6 +21,7 @@ import (
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
@@ -30,7 +31,7 @@ import (
 // The parameter `safe` specifies whether using this Json object in concurrent-safe context,
 // which is false in default.
 func New(data interface{}, safe ...bool) *Json {
-	return NewWithTag(data, "json", safe...)
+	return NewWithTag(data, ContentTypeJson, safe...)
 }
 
 // NewWithTag creates a Json object with any variable type of `data`, but `data` should be a map
@@ -104,56 +105,73 @@ func Load(path string, safe ...bool) (*Json, error) {
 	} else {
 		path = p
 	}
-	option := Options{}
-	if len(safe) > 0 && safe[0] {
-		option.Safe = true
+	options := Options{
+		Type: gfile.Ext(path),
 	}
-	return doLoadContentWithOptions(gfile.Ext(path), gfile.GetBytesWithCache(path), option)
+	if len(safe) > 0 && safe[0] {
+		options.Safe = true
+	}
+	return doLoadContentWithOptions(gfile.GetBytesWithCache(path), options)
+}
+
+// LoadWithOptions creates a Json object from given JSON format content and options.
+func LoadWithOptions(data interface{}, options Options) (*Json, error) {
+	return doLoadContentWithOptions(gconv.Bytes(data), options)
 }
 
 // LoadJson creates a Json object from given JSON format content.
 func LoadJson(data interface{}, safe ...bool) (*Json, error) {
-	option := Options{}
+	option := Options{
+		Type: ContentTypeJson,
+	}
 	if len(safe) > 0 && safe[0] {
 		option.Safe = true
 	}
-	return doLoadContentWithOptions("json", gconv.Bytes(data), option)
+	return doLoadContentWithOptions(gconv.Bytes(data), option)
 }
 
 // LoadXml creates a Json object from given XML format content.
 func LoadXml(data interface{}, safe ...bool) (*Json, error) {
-	option := Options{}
+	option := Options{
+		Type: ContentTypeXml,
+	}
 	if len(safe) > 0 && safe[0] {
 		option.Safe = true
 	}
-	return doLoadContentWithOptions("xml", gconv.Bytes(data), option)
+	return doLoadContentWithOptions(gconv.Bytes(data), option)
 }
 
 // LoadIni creates a Json object from given INI format content.
 func LoadIni(data interface{}, safe ...bool) (*Json, error) {
-	option := Options{}
+	option := Options{
+		Type: ContentTypeIni,
+	}
 	if len(safe) > 0 && safe[0] {
 		option.Safe = true
 	}
-	return doLoadContentWithOptions("ini", gconv.Bytes(data), option)
+	return doLoadContentWithOptions(gconv.Bytes(data), option)
 }
 
 // LoadYaml creates a Json object from given YAML format content.
 func LoadYaml(data interface{}, safe ...bool) (*Json, error) {
-	option := Options{}
+	option := Options{
+		Type: ContentTypeYaml,
+	}
 	if len(safe) > 0 && safe[0] {
 		option.Safe = true
 	}
-	return doLoadContentWithOptions("yaml", gconv.Bytes(data), option)
+	return doLoadContentWithOptions(gconv.Bytes(data), option)
 }
 
 // LoadToml creates a Json object from given TOML format content.
 func LoadToml(data interface{}, safe ...bool) (*Json, error) {
-	option := Options{}
+	option := Options{
+		Type: ContentTypeToml,
+	}
 	if len(safe) > 0 && safe[0] {
 		option.Safe = true
 	}
-	return doLoadContentWithOptions("toml", gconv.Bytes(data), option)
+	return doLoadContentWithOptions(gconv.Bytes(data), option)
 }
 
 // LoadContent creates a Json object from given content, it checks the data type of `content`
@@ -179,11 +197,13 @@ func LoadContentType(dataType string, data interface{}, safe ...bool) (*Json, er
 	if content[0] == 0xEF && content[1] == 0xBB && content[2] == 0xBF {
 		content = content[3:]
 	}
-	option := Options{}
-	if len(safe) > 0 && safe[0] {
-		option.Safe = true
+	options := Options{
+		Type: dataType,
 	}
-	return doLoadContentWithOptions(dataType, content, option)
+	if len(safe) > 0 && safe[0] {
+		options.Safe = true
+	}
+	return doLoadContentWithOptions(content, options)
 }
 
 // IsValidDataType checks and returns whether given `dataType` a valid data type for loading.
@@ -195,7 +215,14 @@ func IsValidDataType(dataType string) bool {
 		dataType = dataType[1:]
 	}
 	switch dataType {
-	case "json", "js", "xml", "yaml", "yml", "toml", "ini":
+	case
+		ContentTypeJson,
+		ContentTypeJs,
+		ContentTypeXml,
+		ContentTypeYaml,
+		ContentTypeYml,
+		ContentTypeToml,
+		ContentTypeIni:
 		return true
 	}
 	return false
@@ -206,10 +233,13 @@ func loadContentWithOptions(data interface{}, options Options) (*Json, error) {
 	if len(content) == 0 {
 		return NewWithOptions(nil, options), nil
 	}
-	return loadContentTypeWithOptions(checkDataType(content), content, options)
+	if options.Type == "" {
+		options.Type = checkDataType(content)
+	}
+	return loadContentTypeWithOptions(content, options)
 }
 
-func loadContentTypeWithOptions(dataType string, data interface{}, options Options) (*Json, error) {
+func loadContentTypeWithOptions(data interface{}, options Options) (*Json, error) {
 	content := gconv.Bytes(data)
 	if len(content) == 0 {
 		return NewWithOptions(nil, options), nil
@@ -218,13 +248,13 @@ func loadContentTypeWithOptions(dataType string, data interface{}, options Optio
 	if content[0] == 0xEF && content[1] == 0xBB && content[2] == 0xBF {
 		content = content[3:]
 	}
-	return doLoadContentWithOptions(dataType, content, options)
+	return doLoadContentWithOptions(content, options)
 }
 
 // doLoadContent creates a Json object from given content.
 // It supports data content type as follows:
 // JSON, XML, INI, YAML and TOML.
-func doLoadContentWithOptions(dataType string, data []byte, options Options) (*Json, error) {
+func doLoadContentWithOptions(data []byte, options Options) (*Json, error) {
 	var (
 		err    error
 		result interface{}
@@ -232,34 +262,39 @@ func doLoadContentWithOptions(dataType string, data []byte, options Options) (*J
 	if len(data) == 0 {
 		return NewWithOptions(nil, options), nil
 	}
-	if dataType == "" {
-		dataType = checkDataType(data)
+	if options.Type == "" {
+		options.Type = checkDataType(data)
 	}
-	switch dataType {
-	case "json", ".json", ".js":
+	options.Type = gstr.TrimLeft(options.Type, ".")
+	switch options.Type {
+	case ContentTypeJson, ContentTypeJs:
 
-	case "xml", ".xml":
+	case ContentTypeXml:
 		if data, err = gxml.ToJson(data); err != nil {
 			return nil, err
 		}
 
-	case "yml", "yaml", ".yml", ".yaml":
+	case ContentTypeYaml, ContentTypeYml:
 		if data, err = gyaml.ToJson(data); err != nil {
 			return nil, err
 		}
 
-	case "toml", ".toml":
+	case ContentTypeToml:
 		if data, err = gtoml.ToJson(data); err != nil {
 			return nil, err
 		}
 
-	case "ini", ".ini":
+	case ContentTypeIni:
 		if data, err = gini.ToJson(data); err != nil {
 			return nil, err
 		}
 
 	default:
-		err = gerror.NewCodef(gcode.CodeInvalidParameter, `unsupported type "%s" for loading`, dataType)
+		err = gerror.NewCodef(
+			gcode.CodeInvalidParameter,
+			`unsupported type "%s" for loading`,
+			options.Type,
+		)
 	}
 	if err != nil {
 		return nil, err
@@ -268,7 +303,7 @@ func doLoadContentWithOptions(dataType string, data []byte, options Options) (*J
 	if options.StrNumber {
 		decoder.UseNumber()
 	}
-	if err := decoder.Decode(&result); err != nil {
+	if err = decoder.Decode(&result); err != nil {
 		return nil, err
 	}
 	switch result.(type) {
@@ -283,23 +318,23 @@ func doLoadContentWithOptions(dataType string, data []byte, options Options) (*J
 // functions to load the content for certain content type.
 func checkDataType(content []byte) string {
 	if json.Valid(content) {
-		return "json"
+		return ContentTypeJson
 	} else if gregex.IsMatch(`^<.+>[\S\s]+<.+>\s*$`, content) {
-		return "xml"
+		return ContentTypeXml
 	} 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"
+		return ContentTypeYaml
 	} 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"
+		return ContentTypeToml
 	} 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"
+		return ContentTypeIni
 	} else {
 		return ""
 	}

encoding/gjson/gjson_implements.go

@@ -13,7 +13,10 @@ func (j Json) MarshalJSON() ([]byte, error) {
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (j *Json) UnmarshalJSON(b []byte) error {
-	r, err := LoadContent(b)
+	r, err := loadContentWithOptions(b, Options{
+		Type:      ContentTypeJson,
+		StrNumber: true,
+	})
 	if r != nil {
 		// Value copy.
 		*j = *r
@@ -23,7 +26,9 @@ func (j *Json) UnmarshalJSON(b []byte) error {
 
 // UnmarshalValue is an interface implement which sets any type of value for Json.
 func (j *Json) UnmarshalValue(value interface{}) error {
-	if r := New(value); r != nil {
+	if r := NewWithOptions(value, Options{
+		StrNumber: true,
+	}); r != nil {
 		// Value copy.
 		*j = *r
 	}

encoding/gjson/gjson_z_example_load_test.go

@@ -9,17 +9,17 @@ package gjson_test
 import (
 	"fmt"
 
-	"github.com/gogf/gf/v2/debug/gdebug"
 	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/test/gtest"
 )
 
 func ExampleLoad() {
-	jsonFilePath := gdebug.TestDataPath("json", "data1.json")
+	jsonFilePath := gtest.DataPath("json", "data1.json")
 	j, _ := gjson.Load(jsonFilePath)
 	fmt.Println(j.Get("name"))
 	fmt.Println(j.Get("score"))
 
-	notExistFilePath := gdebug.TestDataPath("json", "data2.json")
+	notExistFilePath := gtest.DataPath("json", "data2.json")
 	j2, _ := gjson.Load(notExistFilePath)
 	fmt.Println(j2.Get("name"))
 
@@ -195,7 +195,7 @@ func ExampleIsValidDataType() {
 }
 
 func ExampleLoad_Xml() {
-	jsonFilePath := gdebug.TestDataPath("xml", "data1.xml")
+	jsonFilePath := gtest.DataPath("xml", "data1.xml")
 	j, _ := gjson.Load(jsonFilePath)
 	fmt.Println(j.Get("doc.name"))
 	fmt.Println(j.Get("doc.score"))

encoding/gjson/gjson_z_unit_test.go

@@ -15,6 +15,7 @@ import (
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func Test_New(t *testing.T) {
@@ -576,3 +577,13 @@ func Test_Issue1617(t *testing.T) {
 		})
 	})
 }
+
+// https://github.com/gogf/gf/issues/1747
+func Test_Issue1747(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var j *gjson.Json
+		err := gconv.Struct(gvar.New("[1, 2, 336371793314971759]"), &j)
+		t.AssertNil(err)
+		t.Assert(j.Get("2"), `336371793314971759`)
+	})
+}

errors/gerror/gerror.go

@@ -17,36 +17,6 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 )
 
-// iCode is the interface for Code feature.
-type iCode interface {
-	Error() string
-	Code() gcode.Code
-}
-
-// iStack is the interface for Stack feature.
-type iStack interface {
-	Error() string
-	Stack() string
-}
-
-// iCause is the interface for Cause feature.
-type iCause interface {
-	Error() string
-	Cause() error
-}
-
-// iCurrent is the interface for Current feature.
-type iCurrent interface {
-	Error() string
-	Current() error
-}
-
-// iNext is the interface for Next feature.
-type iNext interface {
-	Error() string
-	Next() error
-}
-
 // New creates and returns an error which is formatted from given text.
 func New(text string) error {
 	return &Error{
@@ -305,8 +275,39 @@ func Next(err error) error {
 	return nil
 }
 
+// Unwrap is alias of function `Next`.
+// It is just for implements for stdlib errors.Unwrap from Go version 1.17.
+func Unwrap(err error) error {
+	return Next(err)
+}
+
 // HasStack checks and returns whether `err` implemented interface `iStack`.
 func HasStack(err error) bool {
 	_, ok := err.(iStack)
 	return ok
 }
+
+// Equal reports whether current error `err` equals to error `target`.
+// Please note that, in default comparison for `Error`,
+// the errors are considered the same if both the `code` and `text` of them are the same.
+func Equal(err, target error) bool {
+	if err == target {
+		return true
+	}
+	if e, ok := err.(iEqual); ok {
+		return e.Equal(target)
+	}
+	if e, ok := target.(iEqual); ok {
+		return e.Equal(err)
+	}
+	return false
+}
+
+// Is reports whether current error `err` has error `target` in its chaining errors.
+// It is just for implements for stdlib errors.Unwrap from Go version 1.17.
+func Is(err, target error) bool {
+	if e, ok := err.(iIs); ok {
+		return e.Is(target)
+	}
+	return false
+}

errors/gerror/gerror_error.go

@@ -7,10 +7,8 @@
 package gerror
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
-	"io"
 	"runtime"
 	"strings"
 
@@ -59,18 +57,6 @@ func (err *Error) Error() string {
 	return errStr
 }
 
-// Code returns the error code.
-// It returns CodeNil if it has no error code.
-func (err *Error) Code() gcode.Code {
-	if err == nil {
-		return gcode.CodeNil
-	}
-	if err.code == gcode.CodeNil {
-		return Code(err.Next())
-	}
-	return err.code
-}
-
 // Cause returns the root cause error.
 func (err *Error) Cause() error {
 	if err == nil {
@@ -97,64 +83,6 @@ func (err *Error) Cause() error {
 	return nil
 }
 
-// Format formats the frame according to the fmt.Formatter interface.
-//
-// %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) {
-	switch verb {
-	case 's', 'v':
-		switch {
-		case s.Flag('-'):
-			if err.text != "" {
-				_, _ = io.WriteString(s, err.text)
-			} else {
-				_, _ = io.WriteString(s, err.Error())
-			}
-		case s.Flag('+'):
-			if verb == 's' {
-				_, _ = io.WriteString(s, err.Stack())
-			} else {
-				_, _ = io.WriteString(s, err.Error()+"\n"+err.Stack())
-			}
-		default:
-			_, _ = io.WriteString(s, err.Error())
-		}
-	}
-}
-
-// Stack returns the stack callers as string.
-// It returns an empty string if the `err` does not support stacks.
-func (err *Error) Stack() string {
-	if err == nil {
-		return ""
-	}
-	var (
-		loop   = err
-		index  = 1
-		buffer = bytes.NewBuffer(nil)
-	)
-	for loop != nil {
-		buffer.WriteString(fmt.Sprintf("%d. %-v\n", index, loop))
-		index++
-		formatSubStack(loop.stack, buffer)
-		if loop.error != nil {
-			if e, ok := loop.error.(*Error); ok {
-				loop = e
-			} else {
-				buffer.WriteString(fmt.Sprintf("%d. %s\n", index, loop.error.Error()))
-				index++
-				break
-			}
-		} else {
-			break
-		}
-	}
-	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 {
@@ -178,53 +106,46 @@ func (err *Error) Next() error {
 	return err.error
 }
 
-// SetCode updates the internal code with given code.
-func (err *Error) SetCode(code gcode.Code) {
-	if err == nil {
-		return
-	}
-	err.code = code
+// Unwrap is alias of function `Next`.
+// It is just for implements for stdlib errors.Unwrap from Go version 1.17.
+func (err *Error) Unwrap() error {
+	return err.Next()
 }
 
-// MarshalJSON implements the interface MarshalJSON for json.Marshal.
-// Note that do not use pointer as its receiver here.
-func (err Error) MarshalJSON() ([]byte, error) {
-	return []byte(`"` + err.Error() + `"`), nil
+// Equal reports whether current error `err` equals to error `target`.
+// Please note that, in default comparison for `Error`,
+// the errors are considered the same if both the `code` and `text` of them are the same.
+func (err *Error) Equal(target error) bool {
+	if err == target {
+		return true
+	}
+	// Code should be the same.
+	// Note that if both errors have `nil` code, they are also considered equal.
+	if err.code != Code(target) {
+		return false
+	}
+	// Text should be the same.
+	if err.text != fmt.Sprintf(`%-s`, target) {
+		return false
+	}
+	return true
 }
 
-// formatSubStack formats the stack for error.
-func formatSubStack(st stack, buffer *bytes.Buffer) {
-	if st == nil {
-		return
+// Is reports whether current error `err` has error `target` in its chaining errors.
+// It is just for implements for stdlib errors.Unwrap from Go version 1.17.
+func (err *Error) Is(target error) bool {
+	if Equal(err, target) {
+		return true
 	}
-	index := 1
-	space := "  "
-	for _, p := range st {
-		if fn := runtime.FuncForPC(p - 1); fn != nil {
-			file, line := fn.FileLine(p - 1)
-			// Custom filtering.
-			if strings.Contains(file, stackFilterKeyLocal) {
-				continue
-			}
-			// Avoid stack string like "`autogenerated`"
-			if strings.Contains(file, "<") {
-				continue
-			}
-			// Ignore GO ROOT paths.
-			if goRootForFilter != "" &&
-				len(file) >= len(goRootForFilter) &&
-				file[0:len(goRootForFilter)] == goRootForFilter {
-				continue
-			}
-			// Graceful indent.
-			if index > 9 {
-				space = " "
-			}
-			buffer.WriteString(fmt.Sprintf(
-				"   %d).%s%s\n    \t%s:%d\n",
-				index, space, fn.Name(), file, line,
-			))
-			index++
-		}
+	nextErr := err.Next()
+	if nextErr == nil {
+		return false
 	}
+	if Equal(nextErr, target) {
+		return true
+	}
+	if e, ok := nextErr.(iIs); ok {
+		return e.Is(target)
+	}
+	return false
 }

errors/gerror/gerror_error_code.go

@@ -0,0 +1,31 @@
+// Copyright GoFrame Author(https://goframe.org). 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 gerror
+
+import (
+	"github.com/gogf/gf/v2/errors/gcode"
+)
+
+// Code returns the error code.
+// It returns CodeNil if it has no error code.
+func (err *Error) Code() gcode.Code {
+	if err == nil {
+		return gcode.CodeNil
+	}
+	if err.code == gcode.CodeNil {
+		return Code(err.Next())
+	}
+	return err.code
+}
+
+// SetCode updates the internal code with given code.
+func (err *Error) SetCode(code gcode.Code) {
+	if err == nil {
+		return
+	}
+	err.code = code
+}

errors/gerror/gerror_error_format.go

@@ -0,0 +1,80 @@
+// Copyright GoFrame Author(https://goframe.org). 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 gerror
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"runtime"
+	"strings"
+)
+
+// Format formats the frame according to the fmt.Formatter interface.
+//
+// %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) {
+	switch verb {
+	case 's', 'v':
+		switch {
+		case s.Flag('-'):
+			if err.text != "" {
+				_, _ = io.WriteString(s, err.text)
+			} else {
+				_, _ = io.WriteString(s, err.Error())
+			}
+		case s.Flag('+'):
+			if verb == 's' {
+				_, _ = io.WriteString(s, err.Stack())
+			} else {
+				_, _ = io.WriteString(s, err.Error()+"\n"+err.Stack())
+			}
+		default:
+			_, _ = io.WriteString(s, err.Error())
+		}
+	}
+}
+
+// formatSubStack formats the stack for error.
+func formatSubStack(st stack, buffer *bytes.Buffer) {
+	if st == nil {
+		return
+	}
+	index := 1
+	space := "  "
+	for _, p := range st {
+		if fn := runtime.FuncForPC(p - 1); fn != nil {
+			file, line := fn.FileLine(p - 1)
+			// Custom filtering.
+			if strings.Contains(file, stackFilterKeyLocal) {
+				continue
+			}
+			// Avoid stack string like "`autogenerated`"
+			if strings.Contains(file, "<") {
+				continue
+			}
+			// Ignore GO ROOT paths.
+			if goRootForFilter != "" &&
+				len(file) >= len(goRootForFilter) &&
+				file[0:len(goRootForFilter)] == goRootForFilter {
+				continue
+			}
+			// Graceful indent.
+			if index > 9 {
+				space = " "
+			}
+			buffer.WriteString(fmt.Sprintf(
+				"   %d).%s%s\n    \t%s:%d\n",
+				index, space, fn.Name(), file, line,
+			))
+			index++
+		}
+	}
+}

errors/gerror/gerror_error_json.go

@@ -0,0 +1,13 @@
+// Copyright GoFrame Author(https://goframe.org). 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 gerror
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+// Note that do not use pointer as its receiver here.
+func (err Error) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + err.Error() + `"`), nil
+}

errors/gerror/gerror_error_stack.go

@@ -0,0 +1,42 @@
+// Copyright GoFrame Author(https://goframe.org). 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 gerror
+
+import (
+	"bytes"
+	"fmt"
+)
+
+// Stack returns the stack callers as string.
+// It returns an empty string if the `err` does not support stacks.
+func (err *Error) Stack() string {
+	if err == nil {
+		return ""
+	}
+	var (
+		loop   = err
+		index  = 1
+		buffer = bytes.NewBuffer(nil)
+	)
+	for loop != nil {
+		buffer.WriteString(fmt.Sprintf("%d. %-v\n", index, loop))
+		index++
+		formatSubStack(loop.stack, buffer)
+		if loop.error != nil {
+			if e, ok := loop.error.(*Error); ok {
+				loop = e
+			} else {
+				buffer.WriteString(fmt.Sprintf("%d. %s\n", index, loop.error.Error()))
+				index++
+				break
+			}
+		} else {
+			break
+		}
+	}
+	return buffer.String()
+}

errors/gerror/gerror_interface.go

@@ -0,0 +1,51 @@
+// Copyright GoFrame Author(https://goframe.org). 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 gerror
+
+import (
+	"github.com/gogf/gf/v2/errors/gcode"
+)
+
+// iIs is the interface for Is feature.
+type iIs interface {
+	Is(target error) bool
+}
+
+// iEqual is the interface for Equal feature.
+type iEqual interface {
+	Equal(target error) bool
+}
+
+// iCode is the interface for Code feature.
+type iCode interface {
+	Error() string
+	Code() gcode.Code
+}
+
+// iStack is the interface for Stack feature.
+type iStack interface {
+	Error() string
+	Stack() string
+}
+
+// iCause is the interface for Cause feature.
+type iCause interface {
+	Error() string
+	Cause() error
+}
+
+// iCurrent is the interface for Current feature.
+type iCurrent interface {
+	Error() string
+	Current() error
+}
+
+// iNext is the interface for Next feature.
+type iNext interface {
+	Error() string
+	Next() error
+}

errors/gerror/gerror_option.go

@@ -16,7 +16,7 @@ type Option struct {
 	Code  gcode.Code // Error code if necessary.
 }
 
-// NewOption creates and returns an error with Option.
+// NewOption creates and returns a custom error with Option.
 // It is the senior usage for creating error, which is often used internally in framework.
 func NewOption(option Option) error {
 	err := &Error{

errors/gerror/gerror_z_unit_test.go

@@ -255,6 +255,24 @@ func Test_Next(t *testing.T) {
 	})
 }
 
+func Test_Unwrap(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.Unwrap(err)
+		t.Assert(err.Error(), "2: 1")
+
+		err = gerror.Unwrap(err)
+		t.Assert(err.Error(), "1")
+
+		err = gerror.Unwrap(err)
+		t.AssertNil(err)
+	})
+}
+
 func Test_Code(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		err := errors.New("123")
@@ -340,3 +358,26 @@ func Test_HasStack(t *testing.T) {
 		t.Assert(gerror.HasStack(err2), true)
 	})
 }
+
+func Test_Equal(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		err1 := errors.New("1")
+		err2 := errors.New("1")
+		err3 := gerror.New("1")
+		err4 := gerror.New("4")
+		t.Assert(gerror.Equal(err1, err2), false)
+		t.Assert(gerror.Equal(err1, err3), true)
+		t.Assert(gerror.Equal(err2, err3), true)
+		t.Assert(gerror.Equal(err3, err4), false)
+		t.Assert(gerror.Equal(err1, err4), false)
+	})
+}
+
+func Test_Is(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		err1 := errors.New("1")
+		err2 := gerror.Wrap(err1, "2")
+		err2 = gerror.Wrap(err2, "3")
+		t.Assert(gerror.Is(err2, err1), true)
+	})
+}

example/go.sum

@@ -76,6 +76,7 @@ github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfC
 github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
+github.com/go-test/deep v1.0.7/go.mod h1:QV8Hv/iy04NyLBxAdO9njL0iVPN1S4d/A3NVv1V36o8=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/gogf/katyusha v0.3.0/go.mod h1:AknlfKGS7HjZfLiz74Nd/eL2uq7bg+9aucZgfvXw8vQ=
 github.com/gogf/katyusha v0.3.1-0.20220128101623-e25b27a99b29 h1:s28bNu6QekQG3XFFB3G6YV3AGvQz8Uj4lBu/WXIeF28=
@@ -114,6 +115,8 @@ github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
+github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grokify/html-strip-tags-go v0.0.1 h1:0fThFwLbW7P/kOiTBs03FsJSV9RM2M/Q/MOnCQxKMo0=
 github.com/grokify/html-strip-tags-go v0.0.1/go.mod h1:2Su6romC5/1VXOQMaWL2yb618ARB8iVo6/DR99A6d78=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
@@ -135,6 +138,8 @@ github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORN
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/longbridgeapp/sqlparser v0.3.1 h1:iWOZWGIFgQrJRgobLXUNJdvqGRpbVXkyKUKUA5CNJBE=
+github.com/longbridgeapp/sqlparser v0.3.1/go.mod h1:GIHaUq8zvYyHLCLMJJykx1CdM6LHtkUih/QaJXySSx4=
 github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
 github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=

example/httpserver/swagger/main.go

@@ -9,7 +9,7 @@ import (
 )
 
 type HelloReq struct {
-	g.Meta `path:"/hello" method:"get"`
+	g.Meta `path:"/hello" method:"get" sort:"1"`
 	Name   string `v:"required" dc:"Your name"`
 }
 type HelloRes struct {

frame/gins/gins_database.go

@@ -13,6 +13,7 @@ import (
 	"github.com/gogf/gf/v2/database/gdb"
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/consts"
 	"github.com/gogf/gf/v2/internal/intlog"
 	"github.com/gogf/gf/v2/os/gcfg"
 	"github.com/gogf/gf/v2/text/gregex"
@@ -23,7 +24,6 @@ import (
 
 const (
 	frameCoreComponentNameDatabase = "gf.core.component.database"
-	configNodeNameDatabase         = "database"
 )
 
 // Database returns an instance of database ORM object with specified configuration group name.
@@ -42,11 +42,11 @@ func Database(name ...string) gdb.DB {
 		// It ignores returned error to avoid file no found error while it's not necessary.
 		var (
 			configMap     map[string]interface{}
-			configNodeKey = configNodeNameDatabase
+			configNodeKey = consts.ConfigNodeNameDatabase
 		)
 		// It firstly searches the configuration of the instance name.
 		if configData, _ := Config().Data(ctx); len(configData) > 0 {
-			if v, _ := gutil.MapPossibleItemByKey(configData, configNodeNameDatabase); v != "" {
+			if v, _ := gutil.MapPossibleItemByKey(configData, consts.ConfigNodeNameDatabase); v != "" {
 				configNodeKey = v
 			}
 		}
@@ -89,7 +89,7 @@ func Database(name ...string) gdb.DB {
 				err = gerror.NewCodef(
 					gcode.CodeMissingConfiguration,
 					`database initialization failed: "%s" node not found, is configuration file or configuration node missing?`,
-					configNodeNameDatabase,
+					consts.ConfigNodeNameDatabase,
 				)
 				panic(err)
 			}
@@ -130,13 +130,16 @@ func Database(name ...string) gdb.DB {
 			if node.Link != "" || node.Host != "" {
 				cg = append(cg, *node)
 			}
-
 			if len(cg) > 0 {
 				if gdb.GetConfig(group) == nil {
 					intlog.Printf(ctx, "add configuration for group: %s, %#v", gdb.DefaultGroupName, cg)
 					gdb.SetConfigGroup(gdb.DefaultGroupName, cg)
 				} else {
-					intlog.Printf(ctx, "ignore configuration as it already exists for group: %s, %#v", gdb.DefaultGroupName, cg)
+					intlog.Printf(
+						ctx,
+						"ignore configuration as it already exists for group: %s, %#v",
+						gdb.DefaultGroupName, cg,
+					)
 					intlog.Printf(ctx, "%s, %#v", gdb.DefaultGroupName, cg)
 				}
 			}
@@ -147,7 +150,7 @@ func Database(name ...string) gdb.DB {
 			// Initialize logger for ORM.
 			var (
 				loggerConfigMap map[string]interface{}
-				loggerNodeName  = fmt.Sprintf("%s.%s", configNodeKey, configNodeNameLogger)
+				loggerNodeName  = fmt.Sprintf("%s.%s", configNodeKey, consts.ConfigNodeNameLogger)
 			)
 			if v, _ := Config().Get(ctx, loggerNodeName); !v.IsEmpty() {
 				loggerConfigMap = v.Map()

frame/gins/gins_log.go

@@ -10,13 +10,13 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/gogf/gf/v2/internal/consts"
 	"github.com/gogf/gf/v2/os/glog"
 	"github.com/gogf/gf/v2/util/gutil"
 )
 
 const (
 	frameCoreComponentNameLogger = "gf.core.component.logger"
-	configNodeNameLogger         = "logger"
 )
 
 // Log returns an instance of glog.Logger.
@@ -36,11 +36,11 @@ func Log(name ...string) *glog.Logger {
 		// To avoid file no found error while it's not necessary.
 		var (
 			configMap      map[string]interface{}
-			loggerNodeName = configNodeNameLogger
+			loggerNodeName = consts.ConfigNodeNameLogger
 		)
 		// Try to find possible `loggerNodeName` in case-insensitive way.
 		if configData, _ := Config().Data(ctx); len(configData) > 0 {
-			if v, _ := gutil.MapPossibleItemByKey(configData, configNodeNameLogger); v != "" {
+			if v, _ := gutil.MapPossibleItemByKey(configData, consts.ConfigNodeNameLogger); v != "" {
 				loggerNodeName = v
 			}
 		}

frame/gins/gins_redis.go

@@ -11,6 +11,7 @@ import (
 	"fmt"
 
 	"github.com/gogf/gf/v2/database/gredis"
+	"github.com/gogf/gf/v2/internal/consts"
 	"github.com/gogf/gf/v2/internal/intlog"
 	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/gutil"
@@ -18,7 +19,6 @@ import (
 
 const (
 	frameCoreComponentNameRedis = "gf.core.component.redis"
-	configNodeNameRedis         = "redis"
 )
 
 // Redis returns an instance of redis client with specified configuration group name.
@@ -47,7 +47,7 @@ func Redis(name ...string) *gredis.Redis {
 			if configMap, err = Config().Data(ctx); err != nil {
 				intlog.Errorf(ctx, `retrieve config data map failed: %+v`, err)
 			}
-			if _, v := gutil.MapPossibleItemByKey(configMap, configNodeNameRedis); v != nil {
+			if _, v := gutil.MapPossibleItemByKey(configMap, consts.ConfigNodeNameRedis); v != nil {
 				configMap = gconv.Map(v)
 			}
 			if len(configMap) > 0 {

frame/gins/gins_server.go

@@ -10,6 +10,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/gogf/gf/v2/internal/consts"
 	"github.com/gogf/gf/v2/internal/intlog"
 	"github.com/gogf/gf/v2/net/ghttp"
 	"github.com/gogf/gf/v2/util/gconv"
@@ -17,9 +18,8 @@ import (
 )
 
 const (
-	frameCoreComponentNameServer  = "gf.core.component.server" // Prefix for HTTP server instance.
-	configNodeNameServer          = "server"                   // General version configuration item name.
-	configNodeNameServerSecondary = "httpserver"               // New version configuration item name support from v2.
+	frameCoreComponentNameServer = "gf.core.component.server" // Prefix for HTTP server instance.
+
 )
 
 // Server returns an instance of http server with specified name.
@@ -49,19 +49,19 @@ func Server(name ...interface{}) *ghttp.Server {
 			}
 			// Find possible server configuration item by possible names.
 			if len(configMap) > 0 {
-				if v, _ := gutil.MapPossibleItemByKey(configMap, configNodeNameServer); v != "" {
+				if v, _ := gutil.MapPossibleItemByKey(configMap, consts.ConfigNodeNameServer); v != "" {
 					configNodeName = v
 				}
 				if configNodeName == "" {
-					if v, _ := gutil.MapPossibleItemByKey(configMap, configNodeNameServerSecondary); v != "" {
+					if v, _ := gutil.MapPossibleItemByKey(configMap, consts.ConfigNodeNameServerSecondary); v != "" {
 						configNodeName = v
 					}
 				}
 			}
-			// Server configuration.
+			// Automatically retrieve configuration by instance name.
 			serverConfigMap = Config().MustGet(
 				ctx,
-				fmt.Sprintf(`%s.%s`, configNodeName, server.GetName()),
+				fmt.Sprintf(`%s.%s`, configNodeName, instanceName),
 			).Map()
 			if len(serverConfigMap) == 0 {
 				serverConfigMap = Config().MustGet(ctx, configNodeName).Map()
@@ -81,7 +81,7 @@ func Server(name ...interface{}) *ghttp.Server {
 			// Server logger configuration checks.
 			serverLoggerConfigMap = Config().MustGet(
 				ctx,
-				fmt.Sprintf(`%s.%s.%s`, configNodeName, server.GetName(), configNodeNameLogger),
+				fmt.Sprintf(`%s.%s.%s`, configNodeName, instanceName, consts.ConfigNodeNameLogger),
 			).Map()
 			if len(serverLoggerConfigMap) > 0 {
 				if err = server.Logger().SetConfigWithMap(serverLoggerConfigMap); err != nil {

frame/gins/gins_view.go

@@ -10,6 +10,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/gogf/gf/v2/internal/consts"
 	"github.com/gogf/gf/v2/internal/intlog"
 	"github.com/gogf/gf/v2/os/gview"
 	"github.com/gogf/gf/v2/util/gutil"
@@ -17,7 +18,6 @@ import (
 
 const (
 	frameCoreComponentNameViewer = "gf.core.component.viewer"
-	configNodeNameViewer         = "viewer"
 )
 
 // View returns an instance of View with default settings.
@@ -47,13 +47,13 @@ func getViewInstance(name ...string) *gview.View {
 	if Config().Available(ctx) {
 		var (
 			configMap      map[string]interface{}
-			configNodeName = configNodeNameViewer
+			configNodeName = consts.ConfigNodeNameViewer
 		)
 		if configMap, err = Config().Data(ctx); err != nil {
 			intlog.Errorf(ctx, `retrieve config data map failed: %+v`, err)
 		}
 		if len(configMap) > 0 {
-			if v, _ := gutil.MapPossibleItemByKey(configMap, configNodeNameViewer); v != "" {
+			if v, _ := gutil.MapPossibleItemByKey(configMap, consts.ConfigNodeNameViewer); v != "" {
 				configNodeName = v
 			}
 		}

frame/gins/gins_z_unit_config_test.go

@@ -12,7 +12,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/gogf/gf/v2/debug/gdebug"
 	"github.com/gogf/gf/v2/frame/gins"
 	"github.com/gogf/gf/v2/os/gcfg"
 	"github.com/gogf/gf/v2/os/gfile"
@@ -23,7 +22,7 @@ import (
 var (
 	ctx           = context.Background()
 	configContent = gfile.GetContents(
-		gdebug.TestDataPath("config", "config.toml"),
+		gtest.DataPath("config", "config.toml"),
 	)
 )