v2.4.0-rc2 (#2575 )

version updates to v2.4.0-rc (#2574 )
version updates
2026-06-08 18:47:45 +08:00 · 2023-04-12 21:14:03 +08:00 · 2023-04-12 20:24:20 +08:00 · 2023-04-12 17:38:06 +08:00 · 2023-04-12 15:36:44 +08:00 · 2023-04-12 11:54:15 +08:00
209 changed files with 5156 additions and 3097 deletions
--- a/.github/workflows/cli.yml
+++ b/.github/workflows/cli.yml
@ -16,12 +16,12 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Github Code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
      
      - name: Set Up Golang Environment
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v4
        with:
-          go-version: 1.17
+          go-version: 1.20.3
      
      - name: Build CLI Binary
        run: |
@ -34,7 +34,7 @@ jobs:
      - name: Build CLI Binary For All Platform
        run: |
          cd cmd/gf
-          gf build main.go -n gf -a all -s all
+          gf build main.go -n gf -a amd64,386 -s windows,linux,darwin

      - name: Move Files Before Release
        run: |
@ -47,18 +47,18 @@ jobs:

      - name: Create Github Release
        id: create_release
-        uses: actions/create-release@v1
+        uses: softprops/action-gh-release@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tag_name:     ${{ github.ref }}
-          release_name: GoFrame Release ${{ github.ref }}
+          name: GoFrame Release ${{ github.ref }}
          draft:        false
          prerelease:   false
      
      - name: Upload Release Asset
        id:   upload-release-asset
-        uses: alexellis/upload-assets@0.2.2
+        uses: alexellis/upload-assets@0.4.0
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
--- a/.github/workflows/gf.yml
+++ b/.github/workflows/gf.yml
@ -66,7 +66,9 @@ jobs:
          - 3306:3306

      # PostgreSQL backend server.
-      # docker run -d --name postgres -p 5432:5432 -e POSTGRES_PASSWORD=12345678 -e POSTGRES_USER=postgres -e POSTGRES_DB=test -v postgres:/Users/john/Temp/postgresql/data loads/postgres:13
+      # docker run -d --name postgres -p 5432:5432 \
+      # -e POSTGRES_PASSWORD=12345678 -e POSTGRES_USER=postgres -e POSTGRES_DB=test \
+      # -v postgres:/Users/john/Temp/postgresql/data loads/postgres:13
      postgres:
        image: loads/postgres:13
        env:
@ -84,6 +86,13 @@ jobs:
          --health-retries 5

      # MSSQL backend server.
+      # docker run -d --name mssql -p 1433:1433 \
+      # -e ACCEPT_EULA=Y \
+      # -e SA_PASSWORD=LoremIpsum86 \
+      # -e MSSQL_DB=test \
+      # -e MSSQL_USER=root \
+      # -e MSSQL_PASSWORD=LoremIpsum86 \
+      # loads/mssqldocker:14.0.3391.2
      mssql:
        image: loads/mssqldocker:14.0.3391.2
        env:
@ -111,6 +120,7 @@ jobs:
          - 9001:9001

      # Polaris backend server.
+      # docker run -d --name polaris -p 8090:8090 -p 8091:8091 -p 8093:8093 loads/polaris-server-standalone:1.11.2
      polaris:
        image: loads/polaris-server-standalone:1.11.2
        ports:
--- a/.github/workflows/tag.yml
+++ b/.github/workflows/tag.yml
@ -17,9 +17,21 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Github Code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3

-      - name: Auto Creating Tags
+      - name: Update Dependencies
+        run: make gftidy
+
+      - name: Commit & Push Changes
+        uses: actions-js/push@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: master
+          author_name:  TagRobot
+          author_email: tagrobot@goframe.org
+          message: "auto update version to ${{ github.ref_name }}"
+
+      - name: Auto Creating Tags For Contrib Packages
        run: |
          git config --global user.email "tagrobot@goframe.org"
          git config --global user.name  "TagRobot"
--- a/.golangci.yml
+++ b/.golangci.yml
@ -135,7 +135,7 @@ linters-settings:
  goconst:
    # Minimal length of string constant.
    # Default: 3
-    min-len: 2
+    min-len: 4
    # Minimum occurrences of constant string count to trigger issue.
    # Default: 3
    # For subsequent optimization, the value is reduced.
--- a/28
+++ b/28
@ -1,4 +1,4 @@
-
+SHELL := /bin/bash

 .PHONY: tidy
 tidy:
@ -13,4 +13,28 @@ tidy:

 .PHONY: lint
 lint:
-	golangci-lint run
+	golangci-lint run
+
+gftidy:
+	$(eval files=$(shell find . -name go.mod))
+	@set -e; \
+	# GITHUB_REF_NAME=v2.4.0; \
+	if [[ $$GITHUB_REF_NAME =~ "v" ]]; then \
+		latestVersion=$$GITHUB_REF_NAME; \
+	else \
+		latestVersion=latest; \
+	fi; \
+	for file in ${files}; do \
+		goModPath=$$(dirname $$file); \
+		if [[ $$goModPath =~ "./contrib" || $$goModPath =~ "./cmd/gf" || $$goModPath =~ "./example" ]]; then \
+			echo ""; \
+			echo "processing dir: $$goModPath"; \
+			# Do not modify the order of any of the following sentences \
+			cd $$goModPath; \
+			go mod tidy; \
+			go list -f "{{if and (not .Indirect) (not .Main)}}{{.Path}}@$$latestVersion{{end}}" -m all | grep "^github.com/gogf/gf/contrib" | xargs -L1 go get -v; \
+			go get -v github.com/gogf/gf/v2@$$latestVersion; \
+			go mod tidy; \
+			cd -; \
+		fi \
+	done
--- a/README.MD
+++ b/README.MD
@ -1,18 +1,20 @@
 # GoFrame
+
 <div align=center>
 <img src="https://goframe.org/statics/image/gf-head-large.png" width="100"/>

 [![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf)
 [![GoFrame CI](https://github.com/gogf/gf/actions/workflows/gf.yml/badge.svg)](https://github.com/gogf/gf/actions/workflows/gf.yml)
-[![Go Report](https://goreportcard.com/badge/github.com/gogf/gf?v=1)](https://goreportcard.com/report/github.com/gogf/gf)
+[![Go Report Card](https://goreportcard.com/badge/github.com/gogf/gf/v2)](https://goreportcard.com/report/github.com/gogf/gf/v2)
 [![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf)
 [![Production Ready](https://img.shields.io/badge/production-ready-blue.svg)](https://github.com/gogf/gf)
 [![License](https://img.shields.io/github/license/gogf/gf.svg?style=flat)](https://github.com/gogf/gf)
 </div>

-`GoFrame` is a modular, powerful, high-performance and enterprise-class application development framework of Golang. 
+`GoFrame` is a modular, powerful, high-performance and enterprise-class application development framework of Golang.

 # Features
+
 - modular, loosely coupled design
 - rich components, out-of-the-box
 - automatic codes generating for efficiency
@ -27,34 +29,37 @@
 - much, much more...ready to explore?

 # Installation
+
 Enter your repo. directory and execute following command:

 ## primary module
+
 ```bash
 go get -u -v github.com/gogf/gf/v2
 ```

 ## cli tool
+
 ```bash
 go install github.com/gogf/gf/cmd/gf/v2
 ```

 # Limitation
+
 ```
 golang version >= 1.15
 ```

 # Architecture
+
 <div align=center>
 <img src="https://goframe.org/download/attachments/1114119/arch.png"/>
 </div>

-
 # Documentation

-* Chinese Official Site(中文官网): [https://goframe.org](https://goframe.org/display/gf)
-* GoDoc API: [https://pkg.go.dev/github.com/gogf/gf/v2](https://pkg.go.dev/github.com/gogf/gf/v2)
-
+- Chinese Official Site(中文官网): [https://goframe.org](https://goframe.org/display/gf)
+- GoDoc API: [https://pkg.go.dev/github.com/gogf/gf/v2](https://pkg.go.dev/github.com/gogf/gf/v2)

 # License

@ -76,32 +81,20 @@ golang version >= 1.15

 > We list part of the users here, if your company or products are using `GoFrame`, please let us know [here](https://goframe.org/pages/viewpage.action?pageId=1114415).

-
 # Contributors
+
 This project exists thanks to all the people who contribute. [[Contributors](https://github.com/gogf/gf/graphs/contributors)].
 <a href="https://github.com/gogf/gf/graphs/contributors"><img src="https://contributors-img.web.app/image?repo=gogf/gf" /></a>

-
 # Donators

 If you love `GoFrame`, why not [buy developer a cup of coffee](https://goframe.org/pages/viewpage.action?pageId=1115633)?

 # Sponsors
+
 We appreciate any kind of sponsorship for `GoFrame` development. If you've got some interesting, please contact WeChat `389961817` / Email `john@goframe.org`.

-
-
 # Thanks
+
 <a href="https://www.jetbrains.com/?from=GoFrame"><img src="https://goframe.org/download/thumbnails/1114119/jetbrains.png" height="120" alt="JetBrains"/></a>
 <a href="https://www.atlassian.com/?from=GoFrame"><img src="https://goframe.org/download/attachments/1114119/atlassian.jpg" height="120" alt="Atlassian"/></a>
-
-
-
-
-
-
-
-
-
-
-
--- a/cmd/gf/go.mod
+++ b/cmd/gf/go.mod
@ -3,18 +3,18 @@ module github.com/gogf/gf/cmd/gf/v2
 go 1.18

 require (
-	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.1.0
-	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.1.0
-	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.1.0
-	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.1.0
-	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.1.0
-	github.com/gogf/gf/v2 v2.2.2
+	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.3.3
+	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.3.3
+	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.3.3
+	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.3.3
+	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.3.3
+	github.com/gogf/gf/v2 v2.3.3
 	github.com/olekukonko/tablewriter v0.0.5
-	golang.org/x/tools v0.2.0
+	golang.org/x/tools v0.7.0
 )

 require (
-	github.com/BurntSushi/toml v1.2.1 // indirect
+	github.com/BurntSushi/toml v1.1.0 // indirect
 	github.com/clbanning/mxj/v2 v2.5.5 // indirect
 	github.com/denisenkom/go-mssqldb v0.11.0 // indirect
 	github.com/fatih/color v1.13.0 // indirect
@ -34,14 +34,15 @@ require (
 	github.com/mattn/go-runewidth v0.0.9 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
 	github.com/sijms/go-ora/v2 v2.4.20 // indirect
+	github.com/stretchr/testify v1.7.2 // indirect
 	go.opentelemetry.io/otel v1.7.0 // indirect
 	go.opentelemetry.io/otel/sdk v1.7.0 // indirect
 	go.opentelemetry.io/otel/trace v1.7.0 // indirect
 	golang.org/x/crypto v0.1.0 // indirect
-	golang.org/x/mod v0.6.0 // indirect
-	golang.org/x/net v0.7.0 // indirect
-	golang.org/x/sys v0.5.0 // indirect
-	golang.org/x/text v0.7.0 // indirect
+	golang.org/x/mod v0.9.0 // indirect
+	golang.org/x/net v0.8.0 // indirect
+	golang.org/x/sys v0.6.0 // indirect
+	golang.org/x/text v0.8.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	modernc.org/libc v1.16.8 // indirect
 	modernc.org/mathutil v1.4.1 // indirect
@ -50,6 +51,7 @@ require (
 )

 replace (
+	github.com/gogf/gf/contrib/drivers/clickhouse/v2 => ../../contrib/drivers/clickhouse/
 	github.com/gogf/gf/contrib/drivers/mssql/v2 => ../../contrib/drivers/mssql/
 	github.com/gogf/gf/contrib/drivers/mysql/v2 => ../../contrib/drivers/mysql/
 	github.com/gogf/gf/contrib/drivers/oracle/v2 => ../../contrib/drivers/oracle/
--- a/cmd/gf/go.sum
+++ b/cmd/gf/go.sum
@ -1,6 +1,5 @@
+github.com/BurntSushi/toml v1.1.0 h1:ksErzDEI1khOiGPgpwuI7x2ebx/uXQNw7xJpn9Eq1+I=
 github.com/BurntSushi/toml v1.1.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
-github.com/BurntSushi/toml v1.2.1 h1:9F2/+DoOYIOksmaJFPw1tGFy1eDnIJXg+UHjuD8lTak=
-github.com/BurntSushi/toml v1.2.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
 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/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
@ -54,8 +53,9 @@ github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qq
 github.com/sijms/go-ora/v2 v2.4.20 h1:9e3z7VLBQXRAHGiIda1GEFtRhfxata0LghyMZqvLKew=
 github.com/sijms/go-ora/v2 v2.4.20/go.mod h1:EHxlY6x7y9HAsdfumurRfTd+v8NrEOTR3Xl4FWlH6xk=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.2 h1:4jaiDzPyXQvSd7D0EjG45355tLlV3VOECpq10pLC+8s=
+github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
 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.7.0 h1:Z2lA3Tdch0iDcrhJXDIlC94XE+bxok1F9B+4Lz/lGsM=
@ -72,15 +72,15 @@ golang.org/x/crypto v0.1.0 h1:MDRAIl0xIo9Io2xV565hzXHw3zVseKrJKodhohM5CjU=
 golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=
 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/mod v0.6.0 h1:b9gGHsz9/HhJ3HF5DHQytPpuwocVTChQJK3AvoLRD5I=
-golang.org/x/mod v0.6.0/go.mod h1:4mET923SAdbXp2ki8ey+zGs1SLqsuM2Y0uvdZR/fUNI=
+golang.org/x/mod v0.9.0 h1:KENHtAZL2y3NLMYZeHY9DW8HW8V+kQyJsY/V9JlKvCs=
+golang.org/x/mod v0.9.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 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-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
-golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.8.0 h1:Zrh2ngAOFYneWTAIAPethzeaQLuHwhuBkuV6ZiRnUaQ=
+golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/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=
@ -97,21 +97,21 @@ golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220405052023-b1e9470b6e64/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
+golang.org/x/sys v0.6.0/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/go.mod h1:EFNZuWvGYxIRUEX+K8UmCFwYmZjqcrnq15ZuVldZkZ0=
-golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.8.0 h1:57P1ETyNKtuIjB4SRd15iJxuhj8Gc416Y78H3qgMh68=
+golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 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-20201124115921-2c860bdd6e78/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.7/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo=
-golang.org/x/tools v0.2.0 h1:G6AHpWxTMGY1KyEYoAQ5WTtIekUUvDNjan3ugu60JvE=
-golang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA=
+golang.org/x/tools v0.7.0 h1:W4OVu8VVOaIO0yzWMNdepAulS7YfoS3Zabrm8DOXXU4=
+golang.org/x/tools v0.7.0/go.mod h1:4pg6aUX35JBAogB10C9AtvVL+qowtN4pT3CGSQex14s=
 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=
--- a/cmd/gf/internal/cmd/cmd.go
+++ b/cmd/gf/internal/cmd/cmd.go
@ -4,6 +4,7 @@ import (
 	"context"
 	"strings"

+	"github.com/gogf/gf/v2"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gcmd"
 	"github.com/gogf/gf/v2/util/gtag"
@ -48,17 +49,21 @@ func (c cGF) Index(ctx context.Context, in cGFInput) (out *cGFOutput, err error)
 		_, err = Version.Index(ctx, cVersionInput{})
 		return
 	}
+	answer := "n"
 	// No argument or option, do installation checks.
-	if !service.Install.IsInstalled() {
+	if data, isInstalled := service.Install.IsInstalled(); !isInstalled {
 		mlog.Print("hi, it seams it's the first time you installing gf cli.")
-		s := gcmd.Scanf("do you want to install gf binary to your system? [y/n]: ")
-		if strings.EqualFold(s, "y") {
-			if err = service.Install.Run(ctx); err != nil {
-				return
-			}
-			gcmd.Scan("press `Enter` to exit...")
+		answer = gcmd.Scanf("do you want to install gf(%s) binary to your system? [y/n]: ", gf.VERSION)
+	} else if !data.IsSelf {
+		mlog.Print("hi, you have installed gf cli.")
+		answer = gcmd.Scanf("do you want to install gf(%s) binary to your system? [y/n]: ", gf.VERSION)
+	}
+	if strings.EqualFold(answer, "y") {
+		if err = service.Install.Run(ctx); err != nil {
 			return
 		}
+		gcmd.Scan("press `Enter` to exit...")
+		return
 	}
 	// Print help content.
 	gcmd.CommandFromCtx(ctx).Print()
--- a/cmd/gf/internal/cmd/cmd_build.go
+++ b/cmd/gf/internal/cmd/cmd_build.go
@ -124,13 +124,16 @@ type cBuildInput struct {
 	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"`
+	DumpENV       bool   `short:"de" name:"dumpEnv" brief:"dump current go build environment before building binary" orphan:"true"`
 }

 type cBuildOutput struct{}

 func (c cBuild) Index(ctx context.Context, in cBuildInput) (out *cBuildOutput, err error) {
 	// print used go env
-	_, _ = Env.Index(ctx, cEnvInput{})
+	if in.DumpENV {
+		_, _ = Env.Index(ctx, cEnvInput{})
+	}

 	mlog.SetHeaderPrint(true)

@ -239,7 +242,7 @@ func (c cBuild) Index(ctx context.Context, in cBuildInput) (out *cBuildOutput, e
 		if len(customSystems) > 0 && customSystems[0] != "all" && !gstr.InArray(customSystems, system) {
 			continue
 		}
-		for arch, _ := range item {
+		for arch := range item {
 			if len(customArches) > 0 && customArches[0] != "all" && !gstr.InArray(customArches, arch) {
 				continue
 			}
--- a/cmd/gf/internal/cmd/cmd_gen_dao.go
+++ b/cmd/gf/internal/cmd/cmd_gen_dao.go
@ -1,6 +1,10 @@
 package cmd

 import (
+	// DO NOT import clickhouse in default, as it will fail building cli binary in some platforms.
+	// You can change the imports here and build the cli binary manually if clickhouse is necessary for you.
+	// _ "github.com/gogf/gf/contrib/drivers/clickhouse/v2"
+
 	_ "github.com/gogf/gf/contrib/drivers/mssql/v2"
 	_ "github.com/gogf/gf/contrib/drivers/mysql/v2"
 	_ "github.com/gogf/gf/contrib/drivers/oracle/v2"
--- a/cmd/gf/internal/cmd/cmd_gen_pb.go
+++ b/cmd/gf/internal/cmd/cmd_gen_pb.go
@ -1,65 +1,7 @@
 package cmd

-import (
-	"context"
-
-	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/os/gfile"
-	"github.com/gogf/gf/v2/os/gproc"
-)
+import "github.com/gogf/gf/cmd/gf/v2/internal/cmd/genpb"

 type (
-	cGenPb      struct{}
-	cGenPbInput struct {
-		g.Meta `name:"pb" brief:"parse proto files and generate protobuf go files"`
-		Path   string `name:"path"   short:"p" dc:"protobuf file folder path" d:"manifest/protobuf"`
-		Output string `name:"output" short:"o" dc:"output folder path storing generated go files" d:"api"`
-	}
-	cGenPbOutput struct{}
+	cGenPb = genpb.CGenPb
 )
-
-func (c cGenPb) Pb(ctx context.Context, in cGenPbInput) (out *cGenPbOutput, err error) {
-	// Necessary check.
-	protoc := gproc.SearchBinary("protoc")
-	if protoc == "" {
-		mlog.Fatalf(`command "protoc" not found in your environment, please install protoc first to proceed this command`)
-	}
-
-	// protocol fold checks.
-	protoPath := gfile.RealPath(in.Path)
-	if protoPath == "" {
-		mlog.Fatalf(`proto files folder "%s" does not exist`, in.Path)
-	}
-	// output path checks.
-	outputPath := gfile.RealPath(in.Output)
-	if outputPath == "" {
-		mlog.Fatalf(`output folder "%s" does not exist`, in.Output)
-	}
-
-	// folder scanning.
-	files, err := gfile.ScanDirFile(protoPath, "*.proto", true)
-	if err != nil {
-		mlog.Fatal(err)
-	}
-	if len(files) == 0 {
-		mlog.Fatalf(`no proto files found in folder "%s"`, in.Path)
-	}
-
-	if err = gfile.Chdir(protoPath); err != nil {
-		mlog.Fatal(err)
-	}
-	for _, file := range files {
-		var command = gproc.NewProcess(protoc, nil)
-		command.Args = append(command.Args, "--proto_path="+gfile.Pwd())
-		command.Args = append(command.Args, "--go_out=paths=source_relative:"+outputPath)
-		command.Args = append(command.Args, "--go-grpc_out=paths=source_relative:"+outputPath)
-		command.Args = append(command.Args, file)
-		mlog.Print(command.String())
-		if err = command.Run(ctx); err != nil {
-			mlog.Fatal(err)
-		}
-	}
-	mlog.Print("done!")
-	return
-}
--- a/cmd/gf/internal/cmd/cmd_gen_pbentity.go
+++ b/cmd/gf/internal/cmd/cmd_gen_pbentity.go
@ -1,411 +1,7 @@
 package cmd

-import (
-	"bytes"
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/gogf/gf/v2/database/gdb"
-	"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/text/gregex"
-	"github.com/gogf/gf/v2/text/gstr"
-	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/gtag"
-	"github.com/olekukonko/tablewriter"
-
-	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
-	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
-)
+import "github.com/gogf/gf/cmd/gf/v2/internal/cmd/genpbentity"

 type (
-	cGenPbEntity      struct{}
-	cGenPbEntityInput struct {
-		g.Meta       `name:"pbentity" config:"{cGenPbEntityConfig}" brief:"{cGenPbEntityBrief}" eg:"{cGenPbEntityEg}" ad:"{cGenPbEntityAd}"`
-		Path         string `name:"path"         short:"p" brief:"{cGenPbEntityBriefPath}"`
-		Package      string `name:"package"      short:"k" brief:"{cGenPbEntityBriefPackage}"`
-		Link         string `name:"link"         short:"l" brief:"{cGenPbEntityBriefLink}"`
-		Tables       string `name:"tables"       short:"t" brief:"{cGenPbEntityBriefTables}"`
-		Prefix       string `name:"prefix"       short:"f" brief:"{cGenPbEntityBriefPrefix}"`
-		RemovePrefix string `name:"removePrefix" short:"r" brief:"{cGenPbEntityBriefRemovePrefix}"`
-		NameCase     string `name:"nameCase"     short:"n" brief:"{cGenPbEntityBriefNameCase}" d:"Camel"`
-		JsonCase     string `name:"jsonCase"     short:"j" brief:"{cGenPbEntityBriefJsonCase}" d:"CamelLower"`
-		Option       string `name:"option"       short:"o" brief:"{cGenPbEntityBriefOption}"`
-	}
-	cGenPbEntityOutput struct{}
-
-	cGenPbEntityInternalInput struct {
-		cGenPbEntityInput
-		TableName    string // TableName specifies the table name of the table.
-		NewTableName string // NewTableName specifies the prefix-stripped name of the table.
-	}
+	cGenPbEntity = genpbentity.CGenPbEntity
 )
-
-const (
-	cGenPbEntityConfig = `gfcli.gen.pbentity`
-	cGenPbEntityBrief  = `generate entity message files in protobuf3 format`
-	cGenPbEntityEg     = `
-gf gen pbentity
-gf gen pbentity -l "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
-gf gen pbentity -p ./protocol/demos/entity -t user,user_detail,user_login
-gf gen pbentity -r user_
-`
-
-	cGenPbEntityAd = `
-CONFIGURATION SUPPORT
-    Options are also supported by configuration file.
-    It's suggested using configuration file instead of command line arguments making producing. 
-    The configuration node name is "gf.gen.pbentity", which also supports multiple databases, for example(config.yaml):
-    gfcli:
-      gen:
-      - pbentity:
-            link:    "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
-            path:    "protocol/demos/entity"
-            tables:  "order,products"
-            package: "demos"
-      - pbentity:
-            link:    "mysql:root:12345678@tcp(127.0.0.1:3306)/primary"
-            path:    "protocol/demos/entity"
-            prefix:  "primary_"
-            tables:  "user, userDetail"
-            package: "demos"
-            option:  |
-			  option go_package    = "protobuf/demos";
-			  option java_package  = "protobuf/demos";
-			  option php_namespace = "protobuf/demos";
-`
-	cGenPbEntityBriefPath         = `directory path for generated files`
-	cGenPbEntityBriefPackage      = `package name for all entity proto files`
-	cGenPbEntityBriefLink         = `database configuration, the same as the ORM configuration of GoFrame`
-	cGenPbEntityBriefTables       = `generate models only for given tables, multiple table names separated with ','`
-	cGenPbEntityBriefPrefix       = `add specified prefix for all entity names and entity proto files`
-	cGenPbEntityBriefRemovePrefix = `remove specified prefix of the table, multiple prefix separated with ','`
-	cGenPbEntityBriefOption       = `extra protobuf options`
-	cGenPbEntityBriefGroup        = `
-specifying the configuration group name of database for generated ORM instance,
-it's not necessary and the default value is "default"
-`
-
-	cGenPbEntityBriefNameCase = `
-case for message attribute names, default is "Camel":
-| Case            | Example            |
-|---------------- |--------------------|
-| Camel           | AnyKindOfString    | 
-| CamelLower      | anyKindOfString    | default
-| Snake           | any_kind_of_string |
-| SnakeScreaming  | ANY_KIND_OF_STRING |
-| SnakeFirstUpper | rgb_code_md5       |
-| Kebab           | any-kind-of-string |
-| KebabScreaming  | ANY-KIND-OF-STRING |
-`
-
-	cGenPbEntityBriefJsonCase = `
-case for message json tag, cases are the same as "nameCase", default "CamelLower".
-set it to "none" to ignore json tag generating.
-`
-)
-
-func init() {
-	gtag.Sets(g.MapStrStr{
-		`cGenPbEntityConfig`:            cGenPbEntityConfig,
-		`cGenPbEntityBrief`:             cGenPbEntityBrief,
-		`cGenPbEntityEg`:                cGenPbEntityEg,
-		`cGenPbEntityAd`:                cGenPbEntityAd,
-		`cGenPbEntityBriefPath`:         cGenPbEntityBriefPath,
-		`cGenPbEntityBriefPackage`:      cGenPbEntityBriefPackage,
-		`cGenPbEntityBriefLink`:         cGenPbEntityBriefLink,
-		`cGenPbEntityBriefTables`:       cGenPbEntityBriefTables,
-		`cGenPbEntityBriefPrefix`:       cGenPbEntityBriefPrefix,
-		`cGenPbEntityBriefRemovePrefix`: cGenPbEntityBriefRemovePrefix,
-		`cGenPbEntityBriefGroup`:        cGenPbEntityBriefGroup,
-		`cGenPbEntityBriefNameCase`:     cGenPbEntityBriefNameCase,
-		`cGenPbEntityBriefJsonCase`:     cGenPbEntityBriefJsonCase,
-		`cGenPbEntityBriefOption`:       cGenPbEntityBriefOption,
-	})
-}
-
-func (c cGenPbEntity) PbEntity(ctx context.Context, in cGenPbEntityInput) (out *cGenPbEntityOutput, err error) {
-	var (
-		config = g.Cfg()
-	)
-	if config.Available(ctx) {
-		v := config.MustGet(ctx, cGenPbEntityConfig)
-		if v.IsSlice() {
-			for i := 0; i < len(v.Interfaces()); i++ {
-				doGenPbEntityForArray(ctx, i, in)
-			}
-		} else {
-			doGenPbEntityForArray(ctx, -1, in)
-		}
-	} else {
-		doGenPbEntityForArray(ctx, -1, in)
-	}
-	mlog.Print("done!")
-	return
-}
-
-func doGenPbEntityForArray(ctx context.Context, index int, in cGenPbEntityInput) {
-	var (
-		err error
-		db  gdb.DB
-	)
-	if index >= 0 {
-		err = g.Cfg().MustGet(
-			ctx,
-			fmt.Sprintf(`%s.%d`, cGenPbEntityConfig, index),
-		).Scan(&in)
-		if err != nil {
-			mlog.Fatalf(`invalid configuration of "%s": %+v`, cGenPbEntityConfig, err)
-		}
-	}
-	if in.Package == "" {
-		mlog.Fatal("package name should not be empty")
-	}
-	removePrefixArray := gstr.SplitAndTrim(in.RemovePrefix, ",")
-	// It uses user passed database configuration.
-	if in.Link != "" {
-		var (
-			tempGroup = gtime.TimestampNanoStr()
-			match, _  = gregex.MatchString(`([a-z]+):(.+)`, in.Link)
-		)
-		if len(match) == 3 {
-			gdb.AddConfigNode(tempGroup, gdb.ConfigNode{
-				Type: gstr.Trim(match[1]),
-				Link: gstr.Trim(match[2]),
-			})
-			db, _ = gdb.Instance(tempGroup)
-		}
-	} else {
-		db = g.DB()
-	}
-	if db == nil {
-		mlog.Fatal("database initialization failed")
-	}
-
-	tableNames := ([]string)(nil)
-	if in.Tables != "" {
-		tableNames = gstr.SplitAndTrim(in.Tables, ",")
-	} else {
-		tableNames, err = db.Tables(context.TODO())
-		if err != nil {
-			mlog.Fatalf("fetching tables failed: \n %v", err)
-		}
-	}
-
-	for _, tableName := range tableNames {
-		newTableName := tableName
-		for _, v := range removePrefixArray {
-			newTableName = gstr.TrimLeftStr(newTableName, v, 1)
-		}
-		generatePbEntityContentFile(ctx, db, cGenPbEntityInternalInput{
-			cGenPbEntityInput: in,
-			TableName:         tableName,
-			NewTableName:      newTableName,
-		})
-	}
-}
-
-// generatePbEntityContentFile generates the protobuf files for given table.
-func generatePbEntityContentFile(ctx context.Context, db gdb.DB, in cGenPbEntityInternalInput) {
-	fieldMap, err := db.TableFields(ctx, in.TableName)
-	if err != nil {
-		mlog.Fatalf("fetching tables fields failed for table '%s':\n%v", in.TableName, err)
-	}
-	// Change the `newTableName` if `Prefix` is given.
-	newTableName := "Entity_" + in.Prefix + in.NewTableName
-	var (
-		tableNameCamelCase  = gstr.CaseCamel(newTableName)
-		tableNameSnakeCase  = gstr.CaseSnake(newTableName)
-		entityMessageDefine = generateEntityMessageDefinition(tableNameCamelCase, fieldMap, in)
-		fileName            = gstr.Trim(tableNameSnakeCase, "-_.")
-		path                = gfile.Join(in.Path, fileName+".proto")
-	)
-	entityContent := gstr.ReplaceByMap(getTplPbEntityContent(""), g.MapStrStr{
-		"{PackageName}":   in.Package,
-		"{OptionContent}": in.Option,
-		"{EntityMessage}": entityMessageDefine,
-	})
-	if err := gfile.PutContents(path, strings.TrimSpace(entityContent)); err != nil {
-		mlog.Fatalf("writing content to '%s' failed: %v", path, err)
-	} else {
-		mlog.Print("generated:", path)
-	}
-}
-
-// generateEntityMessageDefinition generates and returns the message definition for specified table.
-func generateEntityMessageDefinition(entityName string, fieldMap map[string]*gdb.TableField, in cGenPbEntityInternalInput) string {
-	var (
-		buffer = bytes.NewBuffer(nil)
-		array  = make([][]string, len(fieldMap))
-		names  = sortFieldKeyForPbEntity(fieldMap)
-	)
-	for index, name := range names {
-		array[index] = generateMessageFieldForPbEntity(index+1, fieldMap[name], in)
-	}
-	tw := tablewriter.NewWriter(buffer)
-	tw.SetBorder(false)
-	tw.SetRowLine(false)
-	tw.SetAutoWrapText(false)
-	tw.SetColumnSeparator("")
-	tw.AppendBulk(array)
-	tw.Render()
-	stContent := buffer.String()
-	// Let's do this hack of table writer for indent!
-	stContent = gstr.Replace(stContent, "  #", "")
-	buffer.Reset()
-	buffer.WriteString(fmt.Sprintf("message %s {\n", entityName))
-	buffer.WriteString(stContent)
-	buffer.WriteString("}")
-	return buffer.String()
-}
-
-// generateMessageFieldForPbEntity generates and returns the message definition for specified field.
-func generateMessageFieldForPbEntity(index int, field *gdb.TableField, in cGenPbEntityInternalInput) []string {
-	var (
-		typeName   string
-		comment    string
-		jsonTagStr string
-	)
-	t, _ := gregex.ReplaceString(`\(.+\)`, "", field.Type)
-	t = gstr.Split(gstr.Trim(t), " ")[0]
-	t = gstr.ToLower(t)
-	switch t {
-	case "binary", "varbinary", "blob", "tinyblob", "mediumblob", "longblob":
-		typeName = "bytes"
-
-	case "bit", "int", "tinyint", "small_int", "smallint", "medium_int", "mediumint", "serial":
-		if gstr.ContainsI(field.Type, "unsigned") {
-			typeName = "uint32"
-		} else {
-			typeName = "int32"
-		}
-
-	case "int8", "big_int", "bigint", "bigserial":
-		if gstr.ContainsI(field.Type, "unsigned") {
-			typeName = "uint64"
-		} else {
-			typeName = "int64"
-		}
-
-	case "real":
-		typeName = "float"
-
-	case "float", "double", "decimal", "smallmoney":
-		typeName = "double"
-
-	case "bool":
-		typeName = "bool"
-
-	case "datetime", "timestamp", "date", "time":
-		typeName = "int64"
-
-	default:
-		// Auto detecting type.
-		switch {
-		case strings.Contains(t, "int"):
-			typeName = "int"
-		case strings.Contains(t, "text") || strings.Contains(t, "char"):
-			typeName = "string"
-		case strings.Contains(t, "float") || strings.Contains(t, "double"):
-			typeName = "double"
-		case strings.Contains(t, "bool"):
-			typeName = "bool"
-		case strings.Contains(t, "binary") || strings.Contains(t, "blob"):
-			typeName = "bytes"
-		case strings.Contains(t, "date") || strings.Contains(t, "time"):
-			typeName = "int64"
-		default:
-			typeName = "string"
-		}
-	}
-	comment = gstr.ReplaceByArray(field.Comment, g.SliceStr{
-		"\n", " ",
-		"\r", " ",
-	})
-	comment = gstr.Trim(comment)
-	comment = gstr.Replace(comment, `\n`, " ")
-	comment, _ = gregex.ReplaceString(`\s{2,}`, ` `, comment)
-	if jsonTagName := formatCase(field.Name, in.JsonCase); jsonTagName != "" {
-		jsonTagStr = fmt.Sprintf(`[(gogoproto.jsontag) = "%s"]`, jsonTagName)
-		// beautiful indent.
-		if index < 10 {
-			// 3 spaces
-			jsonTagStr = "   " + jsonTagStr
-		} else if index < 100 {
-			// 2 spaces
-			jsonTagStr = "  " + jsonTagStr
-		} else {
-			// 1 spaces
-			jsonTagStr = " " + jsonTagStr
-		}
-	}
-	return []string{
-		"    #" + typeName,
-		" #" + formatCase(field.Name, in.NameCase),
-		" #= " + gconv.String(index) + jsonTagStr + ";",
-		" #" + fmt.Sprintf(`// %s`, comment),
-	}
-}
-
-func getTplPbEntityContent(tplEntityPath string) string {
-	if tplEntityPath != "" {
-		return gfile.GetContents(tplEntityPath)
-	}
-	return consts.TemplatePbEntityMessageContent
-}
-
-// formatCase call gstr.Case* function to convert the s to specified case.
-func formatCase(str, caseStr string) string {
-	switch gstr.ToLower(caseStr) {
-	case gstr.ToLower("Camel"):
-		return gstr.CaseCamel(str)
-
-	case gstr.ToLower("CamelLower"):
-		return gstr.CaseCamelLower(str)
-
-	case gstr.ToLower("Kebab"):
-		return gstr.CaseKebab(str)
-
-	case gstr.ToLower("KebabScreaming"):
-		return gstr.CaseKebabScreaming(str)
-
-	case gstr.ToLower("Snake"):
-		return gstr.CaseSnake(str)
-
-	case gstr.ToLower("SnakeFirstUpper"):
-		return gstr.CaseSnakeFirstUpper(str)
-
-	case gstr.ToLower("SnakeScreaming"):
-		return gstr.CaseSnakeScreaming(str)
-
-	case "none":
-		return ""
-	}
-	return str
-}
-
-func sortFieldKeyForPbEntity(fieldMap map[string]*gdb.TableField) []string {
-	names := make(map[int]string)
-	for _, field := range fieldMap {
-		names[field.Index] = field.Name
-	}
-	var (
-		result = make([]string, len(names))
-		i      = 0
-		j      = 0
-	)
-	for {
-		if len(names) == 0 {
-			break
-		}
-		if val, ok := names[i]; ok {
-			result[j] = val
-			j++
-			delete(names, i)
-		}
-		i++
-	}
-	return result
-}
--- a/cmd/gf/internal/cmd/gendao/gendao.go
+++ b/cmd/gf/internal/cmd/gendao/gendao.go
@ -216,6 +216,7 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 	}
 	removePrefixArray := gstr.SplitAndTrim(in.RemovePrefix, ",")
 	if in.ImportPrefix == "" {
+		mlog.Debug(`import prefix is empty, trying calculating the import package path using go.mod`)
 		if !gfile.Exists("go.mod") {
 			mlog.Fatal("go.mod does not exist in current working directory")
 		}
--- a/cmd/gf/internal/cmd/genpb/genpb.go
+++ b/cmd/gf/internal/cmd/genpb/genpb.go
@ -0,0 +1,122 @@
+package genpb
+
+import (
+	"context"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gproc"
+	"github.com/gogf/gf/v2/util/gtag"
+)
+
+type (
+	CGenPb      struct{}
+	CGenPbInput struct {
+		g.Meta     `name:"pb" config:"{CGenPbConfig}" brief:"{CGenPbBrief}" eg:"{CGenPbEg}"`
+		Path       string `name:"path" short:"p"  dc:"protobuf file folder path" d:"manifest/protobuf"`
+		OutputApi  string `name:"api"  short:"a"  dc:"output folder path storing generated go files of api" d:"api"`
+		OutputCtrl string `name:"ctrl" short:"c"  dc:"output folder path storing generated go files of controller" d:"internal/controller"`
+	}
+	CGenPbOutput struct{}
+)
+
+const (
+	CGenPbConfig = `gfcli.gen.pb`
+	CGenPbBrief  = `parse proto files and generate protobuf go files`
+	CGenPbEg     = `
+gf gen pb
+gf gen pb -p . -a . -p .
+`
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`CGenPbEg`:     CGenPbEg,
+		`CGenPbBrief`:  CGenPbBrief,
+		`CGenPbConfig`: CGenPbConfig,
+	})
+}
+
+func (c CGenPb) Pb(ctx context.Context, in CGenPbInput) (out *CGenPbOutput, err error) {
+	// Necessary check.
+	protoc := gproc.SearchBinary("protoc")
+	if protoc == "" {
+		mlog.Fatalf(`command "protoc" not found in your environment, please install protoc first: https://grpc.io/docs/languages/go/quickstart/`)
+	}
+
+	// protocol fold checks.
+	var (
+		protoPath    = gfile.RealPath(in.Path)
+		isParsingPWD bool
+	)
+	if protoPath == "" {
+		// Use current working directory as protoPath if there are proto files under.
+		currentPath := gfile.Pwd()
+		currentFiles, _ := gfile.ScanDirFile(currentPath, "*.proto")
+		if len(currentFiles) > 0 {
+			protoPath = currentPath
+			isParsingPWD = true
+		} else {
+			mlog.Fatalf(`proto files folder "%s" does not exist`, in.Path)
+		}
+	}
+	// output path checks.
+	outputApiPath := gfile.RealPath(in.OutputApi)
+	if outputApiPath == "" {
+		if isParsingPWD {
+			outputApiPath = protoPath
+		} else {
+			mlog.Fatalf(`output api folder "%s" does not exist`, in.OutputApi)
+		}
+	}
+	outputCtrlPath := gfile.RealPath(in.OutputCtrl)
+	if outputCtrlPath == "" {
+		if isParsingPWD {
+			outputCtrlPath = ""
+		} else {
+			mlog.Fatalf(`output controller folder "%s" does not exist`, in.OutputCtrl)
+		}
+	}
+
+	// folder scanning.
+	files, err := gfile.ScanDirFile(protoPath, "*.proto", true)
+	if err != nil {
+		mlog.Fatal(err)
+	}
+	if len(files) == 0 {
+		mlog.Fatalf(`no proto files found in folder "%s"`, in.Path)
+	}
+
+	if err = gfile.Chdir(protoPath); err != nil {
+		mlog.Fatal(err)
+	}
+	for _, file := range files {
+		var command = gproc.NewProcess(protoc, nil)
+		command.Args = append(command.Args, "--proto_path="+gfile.Pwd())
+		command.Args = append(command.Args, "--go_out=paths=source_relative:"+outputApiPath)
+		command.Args = append(command.Args, "--go-grpc_out=paths=source_relative:"+outputApiPath)
+		command.Args = append(command.Args, file)
+		mlog.Print(command.String())
+		if err = command.Run(ctx); err != nil {
+			mlog.Fatal(err)
+		}
+	}
+	// Generate struct tag according comment rules.
+	err = c.generateStructTag(ctx, generateStructTagInput{OutputApiPath: outputApiPath})
+	if err != nil {
+		return
+	}
+	// Generate controllers according comment rules.
+	if outputCtrlPath != "" {
+		err = c.generateController(ctx, generateControllerInput{
+			OutputApiPath:  outputApiPath,
+			OutputCtrlPath: outputCtrlPath,
+		})
+		if err != nil {
+			return
+		}
+	}
+	mlog.Print("done!")
+	return
+}
--- a/cmd/gf/internal/cmd/genpb/genpb_controller.go
+++ b/cmd/gf/internal/cmd/genpb/genpb_controller.go
@ -0,0 +1,189 @@
+package genpb
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+)
+
+type generateControllerInput struct {
+	OutputApiPath  string
+	OutputCtrlPath string
+}
+
+type generateCtrl struct {
+	Name    string
+	Package string
+	Version string
+	Methods []generateCtrlMethod
+}
+
+type generateCtrlMethod struct {
+	Name       string
+	Definition string
+}
+
+const (
+	controllerTemplate = `
+package {Package}
+
+type Controller struct {
+	{Version}.Unimplemented{Name}Server
+}
+
+func Register(s *grpcx.GrpcServer) {
+	{Version}.Register{Name}Server(s.Server, &Controller{})
+}
+`
+	controllerMethodTemplate = `
+func (*Controller) {Definition} {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}
+`
+)
+
+func (c CGenPb) generateController(ctx context.Context, in generateControllerInput) (err error) {
+	files, err := gfile.ScanDirFile(in.OutputApiPath, "*_grpc.pb.go", true)
+	if err != nil {
+		return err
+	}
+	var controllers []generateCtrl
+	for _, file := range files {
+		fileControllers, err := c.parseControllers(file)
+		if err != nil {
+			return err
+		}
+		controllers = append(controllers, fileControllers...)
+	}
+	if len(controllers) == 0 {
+		return nil
+	}
+	// Generate controller files.
+	err = c.doGenerateControllers(in, controllers)
+	return
+}
+
+func (c CGenPb) parseControllers(filePath string) ([]generateCtrl, error) {
+	var (
+		controllers []generateCtrl
+		content     = gfile.GetContents(filePath)
+	)
+	_, err := gregex.ReplaceStringFuncMatch(
+		`type (\w+)Server interface {([\s\S]+?)}`,
+		content,
+		func(match []string) string {
+			ctrl := generateCtrl{
+				Name:    match[1],
+				Package: gfile.Basename(gfile.Dir(gfile.Dir(filePath))),
+				Version: gfile.Basename(gfile.Dir(filePath)),
+				Methods: make([]generateCtrlMethod, 0),
+			}
+			lines := gstr.Split(match[2], "\n")
+			for _, line := range lines {
+				line = gstr.Trim(line)
+				if line == "" || !gstr.IsLetterUpper(line[0]) {
+					continue
+				}
+				// Comment.
+				if gregex.IsMatchString(`^//.+`, line) {
+					continue
+				}
+				line, _ = gregex.ReplaceStringFuncMatch(
+					`^(\w+)\(context\.Context, \*(\w+)\) \(\*(\w+), error\)$`,
+					line,
+					func(match []string) string {
+						return fmt.Sprintf(
+							`%s(ctx context.Context, req *%s.%s) (res *%s.%s, err error)`,
+							match[1], ctrl.Version, match[2], ctrl.Version, match[3],
+						)
+					},
+				)
+				ctrl.Methods = append(ctrl.Methods, generateCtrlMethod{
+					Name:       gstr.Split(line, "(")[0],
+					Definition: line,
+				})
+			}
+			if len(ctrl.Methods) > 0 {
+				controllers = append(controllers, ctrl)
+			}
+			return match[0]
+		},
+	)
+	return controllers, err
+}
+
+func (c CGenPb) doGenerateControllers(in generateControllerInput, controllers []generateCtrl) (err error) {
+	for _, controller := range controllers {
+		err = c.doGenerateController(in, controller)
+		if err != nil {
+			return err
+		}
+	}
+	err = utils.ReplaceGeneratedContentGFV2(in.OutputCtrlPath)
+	return nil
+}
+
+func (c CGenPb) doGenerateController(in generateControllerInput, controller generateCtrl) (err error) {
+	var (
+		folderPath = gfile.Join(in.OutputCtrlPath, controller.Package)
+		filePath   = gfile.Join(folderPath, controller.Package+".go")
+		isDirty    bool
+	)
+	if !gfile.Exists(folderPath) {
+		if err = gfile.Mkdir(folderPath); err != nil {
+			return err
+		}
+	}
+	if !gfile.Exists(filePath) {
+		templateContent := gstr.ReplaceByMap(controllerTemplate, g.MapStrStr{
+			"{Name}":    controller.Name,
+			"{Version}": controller.Version,
+			"{Package}": controller.Package,
+		})
+		if err = gfile.PutContents(filePath, templateContent); err != nil {
+			return err
+		}
+		isDirty = true
+	}
+	// Exist controller content.
+	var ctrlContent string
+	files, err := gfile.ScanDirFile(folderPath, "*.go", false)
+	if err != nil {
+		return err
+	}
+	for _, file := range files {
+		if ctrlContent != "" {
+			ctrlContent += "\n"
+		}
+		ctrlContent += gfile.GetContents(file)
+	}
+	// Generate method content.
+	var generatedContent string
+	for _, method := range controller.Methods {
+		if gstr.Contains(ctrlContent, fmt.Sprintf(`%s(`, method.Name)) {
+			continue
+		}
+		if generatedContent != "" {
+			generatedContent += "\n"
+		}
+		generatedContent += gstr.ReplaceByMap(controllerMethodTemplate, g.MapStrStr{
+			"{Definition}": method.Definition,
+		})
+	}
+	if generatedContent != "" {
+		err = gfile.PutContentsAppend(filePath, generatedContent)
+		if err != nil {
+			return err
+		}
+		isDirty = true
+	}
+	if isDirty {
+		utils.GoFmt(filePath)
+	}
+	return nil
+}
--- a/cmd/gf/internal/cmd/genpb/genpb_tag.go
+++ b/cmd/gf/internal/cmd/genpb/genpb_tag.go
@ -0,0 +1,107 @@
+package genpb
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
+	"github.com/gogf/gf/v2/container/gmap"
+	"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"
+)
+
+type generateStructTagInput struct {
+	OutputApiPath string
+}
+
+func (c CGenPb) generateStructTag(ctx context.Context, in generateStructTagInput) (err error) {
+	files, err := gfile.ScanDirFile(in.OutputApiPath, "*.pb.go", true)
+	if err != nil {
+		return err
+	}
+	var content string
+	for _, file := range files {
+		content = gfile.GetContents(file)
+		content, err = c.doTagReplacement(ctx, content)
+		if err != nil {
+			return err
+		}
+		if err = gfile.PutContents(file, content); err != nil {
+			return err
+		}
+		utils.GoFmt(file)
+	}
+	return
+}
+
+func (c CGenPb) doTagReplacement(ctx context.Context, content string) (string, error) {
+	content, err := gregex.ReplaceStringFuncMatch(`type (\w+) struct {([\s\S]+?)}`, content, func(match []string) string {
+		var (
+			topCommentMatch  []string
+			tailCommentMatch []string
+			lines            = gstr.Split(match[2], "\n")
+			lineTagMap       = gmap.NewListMap()
+		)
+		for index, line := range lines {
+			line = gstr.Trim(line)
+			if line == "" {
+				continue
+			}
+			// Top comment.
+			topCommentMatch, _ = gregex.MatchString(`^/[/|\*](.+)`, line)
+			if len(topCommentMatch) > 1 {
+				c.tagCommentIntoListMap(gstr.Trim(topCommentMatch[1]), lineTagMap)
+				continue
+			}
+			// Tail comment.
+			tailCommentMatch, _ = gregex.MatchString(".+?`.+?`.+?//(.+)", line)
+			if len(tailCommentMatch) > 1 {
+				c.tagCommentIntoListMap(gstr.Trim(tailCommentMatch[1]), lineTagMap)
+			}
+			// Tag injection.
+			if !lineTagMap.IsEmpty() {
+				tagContent := c.listMapToStructTag(lineTagMap)
+				lineTagMap.Clear()
+				line, _ = gregex.ReplaceString("`(.+)`", fmt.Sprintf("`$1 %s`", tagContent), line)
+			}
+			lines[index] = line
+		}
+		match[2] = gstr.Join(lines, "\n")
+		return fmt.Sprintf("type %s struct {%s}", match[1], match[2])
+	})
+	return content, err
+}
+
+func (c CGenPb) tagCommentIntoListMap(comment string, lineTagMap *gmap.ListMap) {
+	tagCommentMatch, _ := gregex.MatchString(`^(\w+):(.+)`, comment)
+	if len(tagCommentMatch) > 1 {
+		var (
+			tagName    = gstr.Trim(tagCommentMatch[1])
+			tagContent = gstr.Trim(tagCommentMatch[2])
+		)
+		lineTagMap.Set(tagName, lineTagMap.GetVar(tagName).String()+tagContent)
+	} else {
+		var (
+			tagName    = "dc"
+			tagContent = comment
+		)
+		lineTagMap.Set(tagName, lineTagMap.GetVar(tagName).String()+tagContent)
+	}
+}
+
+func (c CGenPb) listMapToStructTag(lineTagMap *gmap.ListMap) string {
+	var tag string
+	lineTagMap.Iterator(func(key, value interface{}) bool {
+		if tag != "" {
+			tag += " "
+		}
+		tag += fmt.Sprintf(
+			`%s:"%s"`,
+			key, gstr.Replace(gconv.String(value), `"`, `\"`),
+		)
+		return true
+	})
+	return tag
+}
--- a/cmd/gf/internal/cmd/genpbentity/genpbentity.go
+++ b/cmd/gf/internal/cmd/genpbentity/genpbentity.go
@ -0,0 +1,413 @@
+package genpbentity
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"github.com/olekukonko/tablewriter"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gtag"
+)
+
+type (
+	CGenPbEntity      struct{}
+	CGenPbEntityInput struct {
+		g.Meta       `name:"pbentity" config:"{CGenPbEntityConfig}" brief:"{CGenPbEntityBrief}" eg:"{CGenPbEntityEg}" ad:"{CGenPbEntityAd}"`
+		Path         string `name:"path"         short:"p" brief:"{CGenPbEntityBriefPath}" d:"manifest/protobuf/pbentity"`
+		Package      string `name:"package"      short:"k" brief:"{CGenPbEntityBriefPackage}"`
+		Link         string `name:"link"         short:"l" brief:"{CGenPbEntityBriefLink}"`
+		Tables       string `name:"tables"       short:"t" brief:"{CGenPbEntityBriefTables}"`
+		Prefix       string `name:"prefix"       short:"f" brief:"{CGenPbEntityBriefPrefix}"`
+		RemovePrefix string `name:"removePrefix" short:"r" brief:"{CGenPbEntityBriefRemovePrefix}"`
+		NameCase     string `name:"nameCase"     short:"n" brief:"{CGenPbEntityBriefNameCase}" d:"Camel"`
+		JsonCase     string `name:"jsonCase"     short:"j" brief:"{CGenPbEntityBriefJsonCase}" d:"CamelLower"`
+		Option       string `name:"option"       short:"o" brief:"{CGenPbEntityBriefOption}"`
+	}
+	CGenPbEntityOutput struct{}
+
+	CGenPbEntityInternalInput struct {
+		CGenPbEntityInput
+		DB           gdb.DB
+		TableName    string // TableName specifies the table name of the table.
+		NewTableName string // NewTableName specifies the prefix-stripped name of the table.
+	}
+)
+
+const (
+	defaultPackageSuffix = `api/pbentity`
+	CGenPbEntityConfig   = `gfcli.gen.pbentity`
+	CGenPbEntityBrief    = `generate entity message files in protobuf3 format`
+	CGenPbEntityEg       = `
+gf gen pbentity
+gf gen pbentity -l "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
+gf gen pbentity -p ./protocol/demos/entity -t user,user_detail,user_login
+gf gen pbentity -r user_ -k github.com/gogf/gf/example/protobuf
+gf gen pbentity -r user_
+`
+
+	CGenPbEntityAd = `
+CONFIGURATION SUPPORT
+    Options are also supported by configuration file.
+    It's suggested using configuration file instead of command line arguments making producing. 
+    The configuration node name is "gf.gen.pbentity", which also supports multiple databases, for example(config.yaml):
+    gfcli:
+      gen:
+      - pbentity:
+            link:    "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
+            path:    "protocol/demos/entity"
+            tables:  "order,products"
+            package: "demos"
+      - pbentity:
+            link:    "mysql:root:12345678@tcp(127.0.0.1:3306)/primary"
+            path:    "protocol/demos/entity"
+            prefix:  "primary_"
+            tables:  "user, userDetail"
+            package: "demos"
+            option:  |
+			  option go_package    = "protobuf/demos";
+			  option java_package  = "protobuf/demos";
+			  option php_namespace = "protobuf/demos";
+`
+	CGenPbEntityBriefPath         = `directory path for generated files storing`
+	CGenPbEntityBriefPackage      = `package path for all entity proto files`
+	CGenPbEntityBriefLink         = `database configuration, the same as the ORM configuration of GoFrame`
+	CGenPbEntityBriefTables       = `generate models only for given tables, multiple table names separated with ','`
+	CGenPbEntityBriefPrefix       = `add specified prefix for all entity names and entity proto files`
+	CGenPbEntityBriefRemovePrefix = `remove specified prefix of the table, multiple prefix separated with ','`
+	CGenPbEntityBriefOption       = `extra protobuf options`
+	CGenPbEntityBriefGroup        = `
+specifying the configuration group name of database for generated ORM instance,
+it's not necessary and the default value is "default"
+`
+
+	CGenPbEntityBriefNameCase = `
+case for message attribute names, default is "Camel":
+| Case            | Example            |
+|---------------- |--------------------|
+| Camel           | AnyKindOfString    | 
+| CamelLower      | anyKindOfString    | default
+| Snake           | any_kind_of_string |
+| SnakeScreaming  | ANY_KIND_OF_STRING |
+| SnakeFirstUpper | rgb_code_md5       |
+| Kebab           | any-kind-of-string |
+| KebabScreaming  | ANY-KIND-OF-STRING |
+`
+
+	CGenPbEntityBriefJsonCase = `
+case for message json tag, cases are the same as "nameCase", default "CamelLower".
+set it to "none" to ignore json tag generating.
+`
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`CGenPbEntityConfig`:            CGenPbEntityConfig,
+		`CGenPbEntityBrief`:             CGenPbEntityBrief,
+		`CGenPbEntityEg`:                CGenPbEntityEg,
+		`CGenPbEntityAd`:                CGenPbEntityAd,
+		`CGenPbEntityBriefPath`:         CGenPbEntityBriefPath,
+		`CGenPbEntityBriefPackage`:      CGenPbEntityBriefPackage,
+		`CGenPbEntityBriefLink`:         CGenPbEntityBriefLink,
+		`CGenPbEntityBriefTables`:       CGenPbEntityBriefTables,
+		`CGenPbEntityBriefPrefix`:       CGenPbEntityBriefPrefix,
+		`CGenPbEntityBriefRemovePrefix`: CGenPbEntityBriefRemovePrefix,
+		`CGenPbEntityBriefGroup`:        CGenPbEntityBriefGroup,
+		`CGenPbEntityBriefNameCase`:     CGenPbEntityBriefNameCase,
+		`CGenPbEntityBriefJsonCase`:     CGenPbEntityBriefJsonCase,
+		`CGenPbEntityBriefOption`:       CGenPbEntityBriefOption,
+	})
+}
+
+func (c CGenPbEntity) PbEntity(ctx context.Context, in CGenPbEntityInput) (out *CGenPbEntityOutput, err error) {
+	var (
+		config = g.Cfg()
+	)
+	if config.Available(ctx) {
+		v := config.MustGet(ctx, CGenPbEntityConfig)
+		if v.IsSlice() {
+			for i := 0; i < len(v.Interfaces()); i++ {
+				doGenPbEntityForArray(ctx, i, in)
+			}
+		} else {
+			doGenPbEntityForArray(ctx, -1, in)
+		}
+	} else {
+		doGenPbEntityForArray(ctx, -1, in)
+	}
+	mlog.Print("done!")
+	return
+}
+
+func doGenPbEntityForArray(ctx context.Context, index int, in CGenPbEntityInput) {
+	var (
+		err error
+		db  gdb.DB
+	)
+	if index >= 0 {
+		err = g.Cfg().MustGet(
+			ctx,
+			fmt.Sprintf(`%s.%d`, CGenPbEntityConfig, index),
+		).Scan(&in)
+		if err != nil {
+			mlog.Fatalf(`invalid configuration of "%s": %+v`, CGenPbEntityConfig, err)
+		}
+	}
+	if in.Package == "" {
+		mlog.Debug(`package parameter is empty, trying calculating the package path using go.mod`)
+		if !gfile.Exists("go.mod") {
+			mlog.Fatal("go.mod does not exist in current working directory")
+		}
+		var (
+			modName      string
+			goModContent = gfile.GetContents("go.mod")
+			match, _     = gregex.MatchString(`^module\s+(.+)\s*`, goModContent)
+		)
+		if len(match) > 1 {
+			modName = gstr.Trim(match[1])
+			in.Package = modName + "/" + defaultPackageSuffix
+		} else {
+			mlog.Fatal("module name does not found in go.mod")
+		}
+	}
+	removePrefixArray := gstr.SplitAndTrim(in.RemovePrefix, ",")
+	// It uses user passed database configuration.
+	if in.Link != "" {
+		var (
+			tempGroup = gtime.TimestampNanoStr()
+			match, _  = gregex.MatchString(`([a-z]+):(.+)`, in.Link)
+		)
+		if len(match) == 3 {
+			gdb.AddConfigNode(tempGroup, gdb.ConfigNode{
+				Type: gstr.Trim(match[1]),
+				Link: gstr.Trim(match[2]),
+			})
+			db, _ = gdb.Instance(tempGroup)
+		}
+	} else {
+		db = g.DB()
+	}
+	if db == nil {
+		mlog.Fatal("database initialization failed")
+	}
+
+	tableNames := ([]string)(nil)
+	if in.Tables != "" {
+		tableNames = gstr.SplitAndTrim(in.Tables, ",")
+	} else {
+		tableNames, err = db.Tables(context.TODO())
+		if err != nil {
+			mlog.Fatalf("fetching tables failed: \n %v", err)
+		}
+	}
+
+	for _, tableName := range tableNames {
+		newTableName := tableName
+		for _, v := range removePrefixArray {
+			newTableName = gstr.TrimLeftStr(newTableName, v, 1)
+		}
+		generatePbEntityContentFile(ctx, CGenPbEntityInternalInput{
+			CGenPbEntityInput: in,
+			DB:                db,
+			TableName:         tableName,
+			NewTableName:      newTableName,
+		})
+	}
+}
+
+// generatePbEntityContentFile generates the protobuf files for given table.
+func generatePbEntityContentFile(ctx context.Context, in CGenPbEntityInternalInput) {
+	fieldMap, err := in.DB.TableFields(ctx, in.TableName)
+	if err != nil {
+		mlog.Fatalf("fetching tables fields failed for table '%s':\n%v", in.TableName, err)
+	}
+	// Change the `newTableName` if `Prefix` is given.
+	newTableName := in.Prefix + in.NewTableName
+	var (
+		imports             string
+		tableNameCamelCase  = gstr.CaseCamel(newTableName)
+		tableNameSnakeCase  = gstr.CaseSnake(newTableName)
+		entityMessageDefine = generateEntityMessageDefinition(tableNameCamelCase, fieldMap, in)
+		fileName            = gstr.Trim(tableNameSnakeCase, "-_.")
+		path                = gfile.Join(in.Path, fileName+".proto")
+	)
+	if gstr.Contains(entityMessageDefine, "google.protobuf.Timestamp") {
+		imports = `import "google/protobuf/timestamp.proto";`
+	}
+	entityContent := gstr.ReplaceByMap(getTplPbEntityContent(""), g.MapStrStr{
+		"{Imports}":       imports,
+		"{PackageName}":   gfile.Basename(in.Package),
+		"{GoPackage}":     in.Package,
+		"{OptionContent}": in.Option,
+		"{EntityMessage}": entityMessageDefine,
+	})
+	if err := gfile.PutContents(path, strings.TrimSpace(entityContent)); err != nil {
+		mlog.Fatalf("writing content to '%s' failed: %v", path, err)
+	} else {
+		mlog.Print("generated:", path)
+	}
+}
+
+// generateEntityMessageDefinition generates and returns the message definition for specified table.
+func generateEntityMessageDefinition(entityName string, fieldMap map[string]*gdb.TableField, in CGenPbEntityInternalInput) string {
+	var (
+		buffer = bytes.NewBuffer(nil)
+		array  = make([][]string, len(fieldMap))
+		names  = sortFieldKeyForPbEntity(fieldMap)
+	)
+	for index, name := range names {
+		array[index] = generateMessageFieldForPbEntity(index+1, fieldMap[name], in)
+	}
+	tw := tablewriter.NewWriter(buffer)
+	tw.SetBorder(false)
+	tw.SetRowLine(false)
+	tw.SetAutoWrapText(false)
+	tw.SetColumnSeparator("")
+	tw.AppendBulk(array)
+	tw.Render()
+	stContent := buffer.String()
+	// Let's do this hack of table writer for indent!
+	stContent = gstr.Replace(stContent, "  #", "")
+	buffer.Reset()
+	buffer.WriteString(fmt.Sprintf("message %s {\n", entityName))
+	buffer.WriteString(stContent)
+	buffer.WriteString("}")
+	return buffer.String()
+}
+
+// generateMessageFieldForPbEntity generates and returns the message definition for specified field.
+func generateMessageFieldForPbEntity(index int, field *gdb.TableField, in CGenPbEntityInternalInput) []string {
+	var (
+		typeName   string
+		comment    string
+		jsonTagStr string
+		err        error
+		ctx        = gctx.GetInitCtx()
+	)
+	typeName, err = in.DB.CheckLocalTypeForField(ctx, field.Type, nil)
+	if err != nil {
+		panic(err)
+	}
+	var typeMapping = map[string]string{
+		gdb.LocalTypeString:      "string",
+		gdb.LocalTypeDate:        "google.protobuf.Timestamp",
+		gdb.LocalTypeDatetime:    "google.protobuf.Timestamp",
+		gdb.LocalTypeInt:         "int32",
+		gdb.LocalTypeUint:        "uint32",
+		gdb.LocalTypeInt64:       "int64",
+		gdb.LocalTypeUint64:      "uint64",
+		gdb.LocalTypeIntSlice:    "repeated int32",
+		gdb.LocalTypeInt64Slice:  "repeated int64",
+		gdb.LocalTypeUint64Slice: "repeated uint64",
+		gdb.LocalTypeInt64Bytes:  "repeated int64",
+		gdb.LocalTypeUint64Bytes: "repeated uint64",
+		gdb.LocalTypeFloat32:     "float32",
+		gdb.LocalTypeFloat64:     "float64",
+		gdb.LocalTypeBytes:       "[]byte",
+		gdb.LocalTypeBool:        "bool",
+		gdb.LocalTypeJson:        "string",
+		gdb.LocalTypeJsonb:       "string",
+	}
+	typeName = typeMapping[typeName]
+	if typeName == "" {
+		typeName = "string"
+	}
+
+	comment = gstr.ReplaceByArray(field.Comment, g.SliceStr{
+		"\n", " ",
+		"\r", " ",
+	})
+	comment = gstr.Trim(comment)
+	comment = gstr.Replace(comment, `\n`, " ")
+	comment, _ = gregex.ReplaceString(`\s{2,}`, ` `, comment)
+	if jsonTagName := formatCase(field.Name, in.JsonCase); jsonTagName != "" {
+		// beautiful indent.
+		if index < 10 {
+			// 3 spaces
+			jsonTagStr = "   " + jsonTagStr
+		} else if index < 100 {
+			// 2 spaces
+			jsonTagStr = "  " + jsonTagStr
+		} else {
+			// 1 spaces
+			jsonTagStr = " " + jsonTagStr
+		}
+	}
+	return []string{
+		"    #" + typeName,
+		" #" + formatCase(field.Name, in.NameCase),
+		" #= " + gconv.String(index) + jsonTagStr + ";",
+		" #" + fmt.Sprintf(`// %s`, comment),
+	}
+}
+
+func getTplPbEntityContent(tplEntityPath string) string {
+	if tplEntityPath != "" {
+		return gfile.GetContents(tplEntityPath)
+	}
+	return consts.TemplatePbEntityMessageContent
+}
+
+// formatCase call gstr.Case* function to convert the s to specified case.
+func formatCase(str, caseStr string) string {
+	switch gstr.ToLower(caseStr) {
+	case gstr.ToLower("Camel"):
+		return gstr.CaseCamel(str)
+
+	case gstr.ToLower("CamelLower"):
+		return gstr.CaseCamelLower(str)
+
+	case gstr.ToLower("Kebab"):
+		return gstr.CaseKebab(str)
+
+	case gstr.ToLower("KebabScreaming"):
+		return gstr.CaseKebabScreaming(str)
+
+	case gstr.ToLower("Snake"):
+		return gstr.CaseSnake(str)
+
+	case gstr.ToLower("SnakeFirstUpper"):
+		return gstr.CaseSnakeFirstUpper(str)
+
+	case gstr.ToLower("SnakeScreaming"):
+		return gstr.CaseSnakeScreaming(str)
+
+	case "none":
+		return ""
+	}
+	return str
+}
+
+func sortFieldKeyForPbEntity(fieldMap map[string]*gdb.TableField) []string {
+	names := make(map[int]string)
+	for _, field := range fieldMap {
+		names[field.Index] = field.Name
+	}
+	var (
+		result = make([]string, len(names))
+		i      = 0
+		j      = 0
+	)
+	for {
+		if len(names) == 0 {
+			break
+		}
+		if val, ok := names[i]; ok {
+			result[j] = val
+			j++
+			delete(names, i)
+		}
+		i++
+	}
+	return result
+}
--- a/cmd/gf/internal/cmd/genservice/genservice.go
+++ b/cmd/gf/internal/cmd/genservice/genservice.go
@ -189,6 +189,10 @@ func (c CGenService) Service(ctx context.Context, in CGenServiceInput) (out *CGe
 		generatedDstFilePathSet.Add(dstFilePath)
 		for _, file := range files {
 			fileContent = gfile.GetContents(file)
+			fileContent, err := gregex.ReplaceString(`/[/|\*](.+)`, "", fileContent)
+			if err != nil {
+				return nil, err
+			}
 			// Calculate imported packages of source go files.
 			err = c.calculateImportedPackages(fileContent, srcImportedPackages)
 			if err != nil {
@ -254,7 +258,7 @@ func (c CGenService) Service(ctx context.Context, in CGenServiceInput) (out *CGe
 		}

 		// Replace v1 to v2 for GoFrame.
-		if err = c.replaceGeneratedServiceContentGFV2(in); err != nil {
+		if err = utils.ReplaceGeneratedContentGFV2(in.DstFolder); err != nil {
 			return nil, err
 		}
 		mlog.Printf(`gofmt go files in "%s"`, in.DstFolder)
@ -264,14 +268,3 @@ func (c CGenService) Service(ctx context.Context, in CGenServiceInput) (out *CGe
 	mlog.Print(`done!`)
 	return
 }
-
-func (c CGenService) replaceGeneratedServiceContentGFV2(in CGenServiceInput) (err error) {
-	return gfile.ReplaceDirFunc(func(path, content string) string {
-		if gstr.Contains(content, `"github.com/gogf/gf`) && !gstr.Contains(content, `"github.com/gogf/gf/v2`) {
-			content = gstr.Replace(content, `"github.com/gogf/gf"`, `"github.com/gogf/gf/v2"`)
-			content = gstr.Replace(content, `"github.com/gogf/gf/`, `"github.com/gogf/gf/v2/`)
-			return content
-		}
-		return content
-	}, in.DstFolder, "*.go", false)
-}
--- a/cmd/gf/internal/cmd/genservice/genservice_generate.go
+++ b/cmd/gf/internal/cmd/genservice/genservice_generate.go
@ -56,7 +56,7 @@ func (c CGenService) generateServiceFile(in generateServiceFilesInput) (ok bool,
 		generatingInterfaceCheck string
 	)
 	// Variable definitions.
-	for structName, _ := range in.SrcStructFunctions {
+	for structName := range in.SrcStructFunctions {
 		generatingInterfaceCheck = fmt.Sprintf(`[^\w\d]+%s.I%s[^\w\d]`, in.DstPackageName, structName)
 		if gregex.IsMatchString(generatingInterfaceCheck, generatedContent) {
 			continue
@ -75,7 +75,7 @@ func (c CGenService) generateServiceFile(in generateServiceFilesInput) (ok bool,
 		generatedContent += "\n"
 	}
 	// Variable register function definitions.
-	for structName, _ := range in.SrcStructFunctions {
+	for structName := range in.SrcStructFunctions {
 		generatingInterfaceCheck = fmt.Sprintf(`[^\w\d]+%s.I%s[^\w\d]`, in.DstPackageName, structName)
 		if gregex.IsMatchString(generatingInterfaceCheck, generatedContent) {
 			continue
--- a/cmd/gf/internal/consts/consts_gen_pbentity_template.go
+++ b/cmd/gf/internal/consts/consts_gen_pbentity_template.go
@ -9,9 +9,9 @@ syntax = "proto3";

 package {PackageName};

-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
-
+option go_package = "{GoPackage}";
 {OptionContent}
+{Imports}

 {EntityMessage}
 `
--- a/cmd/gf/internal/packed/template-mono.go
+++ b/cmd/gf/internal/packed/template-mono.go
--- a/cmd/gf/internal/packed/template-single.go
+++ b/cmd/gf/internal/packed/template-single.go
--- a/cmd/gf/internal/service/install.go
+++ b/cmd/gf/internal/service/install.go
@ -29,6 +29,7 @@ type serviceInstallAvailablePath struct {
 	filePath  string
 	writable  bool
 	installed bool
+	IsSelf    bool
 }

 func (s serviceInstall) Run(ctx context.Context) (err error) {
@ -131,14 +132,14 @@ func (s serviceInstall) Run(ctx context.Context) (err error) {
 }

 // IsInstalled checks and returns whether the binary is installed.
-func (s serviceInstall) IsInstalled() bool {
+func (s serviceInstall) IsInstalled() (*serviceInstallAvailablePath, bool) {
 	paths := s.getAvailablePaths()
 	for _, aPath := range paths {
 		if aPath.installed {
-			return true
+			return &aPath, true
 		}
 	}
-	return false
+	return nil, false
 }

 // getGoPathBinFilePath retrieves ad returns the GOPATH/bin path for binary.
@ -214,6 +215,7 @@ func (s serviceInstall) checkAndAppendToAvailablePath(folderPaths []serviceInsta
 		filePath  = gfile.Join(dirPath, binaryFileName)
 		writable  = gfile.IsWritable(dirPath)
 		installed = gfile.Exists(filePath)
+		self      = gfile.SelfPath() == filePath
 	)
 	if !writable && !installed {
 		return folderPaths
@ -225,5 +227,6 @@ func (s serviceInstall) checkAndAppendToAvailablePath(folderPaths []serviceInsta
 			writable:  writable,
 			filePath:  filePath,
 			installed: installed,
+			IsSelf:    self,
 		})
 }
--- a/cmd/gf/internal/utility/utils/utils.go
+++ b/cmd/gf/internal/utility/utils/utils.go
@ -3,12 +3,13 @@ package utils
 import (
 	"context"
 	"fmt"
+	"golang.org/x/tools/imports"
+
 	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/os/gproc"
 	"github.com/gogf/gf/v2/text/gstr"
-	"golang.org/x/tools/imports"
 )

 // GoFmt formats the source file and adds or removes import statements as necessary.
@ -52,3 +53,16 @@ func IsFileDoNotEdit(filePath string) bool {
 	}
 	return gstr.Contains(gfile.GetContents(filePath), consts.DoNotEditKey)
 }
+
+// ReplaceGeneratedContentGFV2 replaces generated go content from goframe v1 to v2.
+func ReplaceGeneratedContentGFV2(folderPath string) (err error) {
+	return gfile.ReplaceDirFunc(func(path, content string) string {
+		if gstr.Contains(content, `"github.com/gogf/gf`) && !gstr.Contains(content, `"github.com/gogf/gf/v2`) {
+			content = gstr.Replace(content, `"github.com/gogf/gf"`, `"github.com/gogf/gf/v2"`)
+			content = gstr.Replace(content, `"github.com/gogf/gf/`, `"github.com/gogf/gf/v2/`)
+			content = gstr.Replace(content, `"github.com/gogf/gf/v2/contrib/`, `"github.com/gogf/gf/contrib/`)
+			return content
+		}
+		return content
+	}, folderPath, "*.go", true)
+}
--- a/container/garray/garray_normal_any.go
+++ b/container/garray/garray_normal_any.go
@ -233,13 +233,26 @@ func (a *Array) doRemoveWithoutLock(index int) (value interface{}, found bool) {
 // RemoveValue removes an item by value.
 // It returns true if value is found in the array, or else false if not found.
 func (a *Array) RemoveValue(value interface{}) bool {
-	if i := a.Search(value); i != -1 {
-		a.Remove(i)
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if i := a.doSearchWithoutLock(value); i != -1 {
+		a.doRemoveWithoutLock(i)
 		return true
 	}
 	return false
 }

+// RemoveValues removes multiple items by `values`.
+func (a *Array) RemoveValues(values ...interface{}) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for _, value := range values {
+		if i := a.doSearchWithoutLock(value); i != -1 {
+			a.doRemoveWithoutLock(i)
+		}
+	}
+}
+
 // PushLeft pushes one or multiple items to the beginning of array.
 func (a *Array) PushLeft(value ...interface{}) *Array {
 	a.mu.Lock()
@ -487,6 +500,10 @@ func (a *Array) Contains(value interface{}) bool {
 func (a *Array) Search(value interface{}) int {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
+	return a.doSearchWithoutLock(value)
+}
+
+func (a *Array) doSearchWithoutLock(value interface{}) int {
 	if len(a.array) == 0 {
 		return -1
 	}
@ -778,6 +795,24 @@ func (a *Array) UnmarshalValue(value interface{}) error {
 	return nil
 }

+// Filter `filter func(value interface{}, index int) bool` filter array, value
+// means the value of the current element, the index of the current original
+// color of value, when the custom function returns True, the element will be
+// filtered, otherwise it will not be filtered, `Filter` function returns a new
+// array, will not modify the original array.
+func (a *Array) Filter(filter func(index int, value interface{}) bool) *Array {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if filter(i, a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
 // FilterNil removes all nil value of the array.
 func (a *Array) FilterNil() *Array {
 	a.mu.Lock()
--- a/container/garray/garray_normal_int.go
+++ b/container/garray/garray_normal_int.go
@ -228,13 +228,26 @@ func (a *IntArray) doRemoveWithoutLock(index int) (value int, found bool) {
 // RemoveValue removes an item by value.
 // It returns true if value is found in the array, or else false if not found.
 func (a *IntArray) RemoveValue(value int) bool {
-	if i := a.Search(value); i != -1 {
-		_, found := a.Remove(i)
-		return found
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if i := a.doSearchWithoutLock(value); i != -1 {
+		a.doRemoveWithoutLock(i)
+		return true
 	}
 	return false
 }

+// RemoveValues removes multiple items by `values`.
+func (a *IntArray) RemoveValues(values ...int) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for _, value := range values {
+		if i := a.doSearchWithoutLock(value); i != -1 {
+			a.doRemoveWithoutLock(i)
+		}
+	}
+}
+
 // PushLeft pushes one or multiple items to the beginning of array.
 func (a *IntArray) PushLeft(value ...int) *IntArray {
 	a.mu.Lock()
@ -497,6 +510,10 @@ func (a *IntArray) Contains(value int) bool {
 func (a *IntArray) Search(value int) int {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
+	return a.doSearchWithoutLock(value)
+}
+
+func (a *IntArray) doSearchWithoutLock(value int) int {
 	if len(a.array) == 0 {
 		return -1
 	}
@ -771,6 +788,24 @@ func (a *IntArray) UnmarshalValue(value interface{}) error {
 	return nil
 }

+// Filter `filter func(value int, index int) bool` filter array, value
+// means the value of the current element, the index of the current original
+// color of value, when the custom function returns True, the element will be
+// filtered, otherwise it will not be filtered, `Filter` function returns a new
+// array, will not modify the original array.
+func (a *IntArray) Filter(filter func(index int, value int) bool) *IntArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if filter(i, a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
 // FilterEmpty removes all zero value of the array.
 func (a *IntArray) FilterEmpty() *IntArray {
 	a.mu.Lock()
--- a/container/garray/garray_normal_str.go
+++ b/container/garray/garray_normal_str.go
@ -222,6 +222,17 @@ func (a *StrArray) RemoveValue(value string) bool {
 	return false
 }

+// RemoveValues removes multiple items by `values`.
+func (a *StrArray) RemoveValues(values ...string) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for _, value := range values {
+		if i := a.doSearchWithoutLock(value); i != -1 {
+			a.doRemoveWithoutLock(i)
+		}
+	}
+}
+
 // PushLeft pushes one or multiple items to the beginning of array.
 func (a *StrArray) PushLeft(value ...string) *StrArray {
 	a.mu.Lock()
@ -499,6 +510,10 @@ func (a *StrArray) ContainsI(value string) bool {
 func (a *StrArray) Search(value string) int {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
+	return a.doSearchWithoutLock(value)
+}
+
+func (a *StrArray) doSearchWithoutLock(value string) int {
 	if len(a.array) == 0 {
 		return -1
 	}
@ -784,6 +799,24 @@ func (a *StrArray) UnmarshalValue(value interface{}) error {
 	return nil
 }

+// Filter `filter func(value string, index int) bool` filter array, value
+// means the value of the current element, the index of the current original
+// color of value, when the custom function returns True, the element will be
+// filtered, otherwise it will not be filtered, `Filter` function returns a new
+// array, will not modify the original array.
+func (a *StrArray) Filter(filter func(index int, value string) bool) *StrArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if filter(i, a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
 // FilterEmpty removes all empty string value of the array.
 func (a *StrArray) FilterEmpty() *StrArray {
 	a.mu.Lock()
--- a/container/garray/garray_sorted_any.go
+++ b/container/garray/garray_sorted_any.go
@ -216,6 +216,17 @@ func (a *SortedArray) RemoveValue(value interface{}) bool {
 	return false
 }

+// RemoveValues removes an item by `values`.
+func (a *SortedArray) RemoveValues(values ...interface{}) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for _, value := range values {
+		if i, r := a.binSearch(value, false); r == 0 {
+			a.doRemoveWithoutLock(i)
+		}
+	}
+}
+
 // PopLeft pops and returns an item from the beginning of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedArray) PopLeft() (value interface{}, found bool) {
@ -470,7 +481,7 @@ func (a *SortedArray) binSearch(value interface{}, lock bool) (index int, result

 // SetUnique sets unique mark to the array,
 // which means it does not contain any repeated items.
-// It also do unique check, remove all repeated items.
+// It also does unique check, remove all repeated items.
 func (a *SortedArray) SetUnique(unique bool) *SortedArray {
 	oldUnique := a.unique
 	a.unique = unique
@ -750,6 +761,24 @@ func (a *SortedArray) FilterNil() *SortedArray {
 	return a
 }

+// Filter `filter func(value interface{}, index int) bool` filter array, value
+// means the value of the current element, the index of the current original
+// color of value, when the custom function returns True, the element will be
+// filtered, otherwise it will not be filtered, `Filter` function returns a new
+// array, will not modify the original array.
+func (a *SortedArray) Filter(filter func(index int, value interface{}) bool) *SortedArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if filter(i, a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
 // FilterEmpty removes all empty value of the array.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (a *SortedArray) FilterEmpty() *SortedArray {
--- a/container/garray/garray_sorted_int.go
+++ b/container/garray/garray_sorted_int.go
@ -202,6 +202,17 @@ func (a *SortedIntArray) RemoveValue(value int) bool {
 	return false
 }

+// RemoveValues removes an item by `values`.
+func (a *SortedIntArray) RemoveValues(values ...int) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for _, value := range values {
+		if i, r := a.binSearch(value, false); r == 0 {
+			a.doRemoveWithoutLock(i)
+		}
+	}
+}
+
 // PopLeft pops and returns an item from the beginning of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedIntArray) PopLeft() (value int, found bool) {
@ -698,6 +709,24 @@ func (a *SortedIntArray) UnmarshalValue(value interface{}) (err error) {
 	return err
 }

+// Filter `filter func(value int, index int) bool` filter array, value
+// means the value of the current element, the index of the current original
+// color of value, when the custom function returns True, the element will be
+// filtered, otherwise it will not be filtered, `Filter` function returns a new
+// array, will not modify the original array.
+func (a *SortedIntArray) Filter(filter func(index int, value int) bool) *SortedIntArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if filter(i, a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
 // FilterEmpty removes all zero value of the array.
 func (a *SortedIntArray) FilterEmpty() *SortedIntArray {
 	a.mu.Lock()
--- a/container/garray/garray_sorted_str.go
+++ b/container/garray/garray_sorted_str.go
@ -188,6 +188,17 @@ func (a *SortedStrArray) RemoveValue(value string) bool {
 	return false
 }

+// RemoveValues removes an item by `values`.
+func (a *SortedStrArray) RemoveValues(values ...string) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for _, value := range values {
+		if i, r := a.binSearch(value, false); r == 0 {
+			a.doRemoveWithoutLock(i)
+		}
+	}
+}
+
 // PopLeft pops and returns an item from the beginning of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedStrArray) PopLeft() (value string, found bool) {
@ -711,6 +722,24 @@ func (a *SortedStrArray) UnmarshalValue(value interface{}) (err error) {
 	return err
 }

+// Filter `filter func(value string, index int) bool` filter array, value
+// means the value of the current element, the index of the current original
+// color of value, when the custom function returns True, the element will be
+// filtered, otherwise it will not be filtered, `Filter` function returns a new
+// array, will not modify the original array.
+func (a *SortedStrArray) Filter(filter func(index int, value string) bool) *SortedStrArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if filter(i, a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
 // FilterEmpty removes all empty string value of the array.
 func (a *SortedStrArray) FilterEmpty() *SortedStrArray {
 	a.mu.Lock()
--- a/container/garray/garray_z_example_normal_any_test.go
+++ b/container/garray/garray_z_example_normal_any_test.go
@ -9,6 +9,8 @@ package garray_test
 import (
 	"fmt"

+	"github.com/gogf/gf/v2/internal/empty"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
 )
@ -261,6 +263,21 @@ func ExampleArray_Merge() {
 	// [1 2 1 2 3 4 5 6 7 8 9 0]
 }

+func ExampleArray_Filter() {
+	array1 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
+	array2 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
+	fmt.Printf("%#v\n", array1.Filter(func(index int, value interface{}) bool {
+		return empty.IsNil(value)
+	}).Slice())
+	fmt.Printf("%#v\n", array2.Filter(func(index int, value interface{}) bool {
+		return empty.IsEmpty(value)
+	}).Slice())
+
+	// Output:
+	// []interface {}{0, 1, 2, "", []interface {}{}, "john"}
+	// []interface {}{1, 2, "john"}
+}
+
 func ExampleArray_FilterEmpty() {
 	array1 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
 	array2 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
--- a/container/garray/garray_z_example_normal_int_test.go
+++ b/container/garray/garray_z_example_normal_int_test.go
@ -9,6 +9,8 @@ package garray_test
 import (
 	"fmt"

+	"github.com/gogf/gf/v2/internal/empty"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"
@ -699,6 +701,25 @@ func ExampleIntArray_UnmarshalValue() {
 	// &{john [96,98,97]}
 }

+func ExampleIntArray_Filter() {
+	array1 := garray.NewIntArrayFrom(g.SliceInt{10, 40, 50, 0, 0, 0, 60})
+	array2 := garray.NewIntArrayFrom(g.SliceInt{10, 4, 51, 5, 45, 50, 56})
+	fmt.Println(array1.Filter(func(index int, value int) bool {
+		return empty.IsEmpty(value)
+	}))
+	fmt.Println(array2.Filter(func(index int, value int) bool {
+		return value%2 == 0
+	}))
+	fmt.Println(array2.Filter(func(index int, value int) bool {
+		return value%2 == 1
+	}))
+
+	// Output:
+	// [10,40,50,60]
+	// [51,5,45]
+	// []
+}
+
 func ExampleIntArray_FilterEmpty() {
 	s := garray.NewIntArrayFrom(g.SliceInt{10, 40, 50, 0, 0, 0, 60})
 	fmt.Println(s)
--- a/container/garray/garray_z_example_normal_str_test.go
+++ b/container/garray/garray_z_example_normal_str_test.go
@ -8,6 +8,9 @@ package garray_test

 import (
 	"fmt"
+	"strings"
+
+	"github.com/gogf/gf/v2/internal/empty"

 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
@ -622,6 +625,22 @@ func ExampleStrArray_UnmarshalValue() {
 	// &{john ["Math","English","Sport"]}
 }

+func ExampleStrArray_Filter() {
+	s := garray.NewStrArrayFrom(g.SliceStr{"Math", "English", "Sport"})
+	s1 := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "", "c", "", "", "d"})
+	fmt.Println(s1.Filter(func(index int, value string) bool {
+		return empty.IsEmpty(value)
+	}))
+
+	fmt.Println(s.Filter(func(index int, value string) bool {
+		return strings.Contains(value, "h")
+	}))
+
+	// Output:
+	// ["a","b","c","d"]
+	// ["Sport"]
+}
+
 func ExampleStrArray_FilterEmpty() {
 	s := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "", "c", "", "", "d"})
 	fmt.Println(s.FilterEmpty())
--- a/container/garray/garray_z_example_sorted_str_test.go
+++ b/container/garray/garray_z_example_sorted_str_test.go
@ -9,6 +9,8 @@ package garray_test
 import (
 	"fmt"

+	"github.com/gogf/gf/v2/internal/empty"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"
@ -552,6 +554,18 @@ func ExampleSortedStrArray_UnmarshalValue() {
 	// &{john ["Math","English","Sport"]}
 }

+func ExampleSortedStrArray_Filter() {
+	s := garray.NewSortedStrArrayFrom(g.SliceStr{"b", "a", "", "c", "", "", "d"})
+	fmt.Println(s)
+	fmt.Println(s.Filter(func(index int, value string) bool {
+		return empty.IsEmpty(value)
+	}))
+
+	// Output:
+	// ["","","","a","b","c","d"]
+	// ["a","b","c","d"]
+}
+
 func ExampleSortedStrArray_FilterEmpty() {
 	s := garray.NewSortedStrArrayFrom(g.SliceStr{"b", "a", "", "c", "", "", "d"})
 	fmt.Println(s)
--- a/container/garray/garray_z_unit_normal_any_test.go
+++ b/container/garray/garray_z_unit_normal_any_test.go
@ -12,6 +12,8 @@ import (
 	"testing"
 	"time"

+	"github.com/gogf/gf/v2/internal/empty"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"
@ -750,6 +752,15 @@ func TestArray_RemoveValue(t *testing.T) {
 	})
 }

+func TestArray_RemoveValues(t *testing.T) {
+	slice := g.Slice{"a", "b", "d", "c"}
+	array := garray.NewArrayFrom(slice)
+	gtest.C(t, func(t *gtest.T) {
+		array.RemoveValues("a", "b", "c")
+		t.Assert(array.Slice(), g.Slice{"d"})
+	})
+}
+
 func TestArray_UnmarshalValue(t *testing.T) {
 	type V struct {
 		Name  string
@ -791,6 +802,36 @@ func TestArray_FilterNil(t *testing.T) {
 	})
 }

+func TestArray_Filter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
+		array := garray.NewArrayFromCopy(values)
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
+			return empty.IsNil(value)
+		}).Slice(), values)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewArrayFromCopy(g.Slice{nil, 1, 2, 3, 4, nil})
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
+			return empty.IsNil(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}})
+
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
+			return empty.IsEmpty(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewArrayFrom(g.Slice{1, 2, 3, 4})
+
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
+			return empty.IsEmpty(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+}
+
 func TestArray_FilterEmpty(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}})
--- a/container/garray/garray_z_unit_normal_int_test.go
+++ b/container/garray/garray_z_unit_normal_int_test.go
@ -12,6 +12,8 @@ import (
 	"testing"
 	"time"

+	"github.com/gogf/gf/v2/internal/empty"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"
@ -765,6 +767,15 @@ func TestIntArray_RemoveValue(t *testing.T) {
 	})
 }

+func TestIntArray_RemoveValues(t *testing.T) {
+	slice := g.SliceInt{10, 20, 30, 40}
+	array := garray.NewIntArrayFrom(slice)
+	gtest.C(t, func(t *gtest.T) {
+		array.RemoveValues(10, 20, 40)
+		t.Assert(array.Slice(), g.SliceInt{30})
+	})
+}
+
 func TestIntArray_UnmarshalValue(t *testing.T) {
 	type V struct {
 		Name  string
@ -794,6 +805,34 @@ func TestIntArray_UnmarshalValue(t *testing.T) {
 	// })
 }

+func TestIntArray_Filter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewIntArrayFrom(g.SliceInt{0, 1, 2, 3, 4, 0})
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return empty.IsEmpty(value)
+		}), g.SliceInt{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewIntArrayFrom(g.SliceInt{1, 2, 3, 4})
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return empty.IsEmpty(value)
+
+		}), g.SliceInt{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewIntArrayFrom(g.SliceInt{1, 2, 3, 4})
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return value%2 == 0
+		}), g.SliceInt{1, 3})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewIntArrayFrom(g.SliceInt{1, 2, 3, 4})
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return value%2 == 1
+		}), g.SliceInt{2, 4})
+	})
+}
+
 func TestIntArray_FilterEmpty(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewIntArrayFrom(g.SliceInt{0, 1, 2, 3, 4, 0})
--- a/container/garray/garray_z_unit_normal_str_test.go
+++ b/container/garray/garray_z_unit_normal_str_test.go
@ -13,6 +13,8 @@ import (
 	"testing"
 	"time"

+	"github.com/gogf/gf/v2/internal/empty"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"
@ -776,6 +778,15 @@ func TestStrArray_RemoveValue(t *testing.T) {
 	})
 }

+func TestStrArray_RemoveValues(t *testing.T) {
+	slice := g.SliceStr{"a", "b", "d", "c"}
+	array := garray.NewStrArrayFrom(slice)
+	gtest.C(t, func(t *gtest.T) {
+		array.RemoveValues("a", "b", "c")
+		t.Assert(array.Slice(), g.SliceStr{"d"})
+	})
+}
+
 func TestStrArray_UnmarshalValue(t *testing.T) {
 	type V struct {
 		Name  string
@ -804,6 +815,20 @@ func TestStrArray_UnmarshalValue(t *testing.T) {
 		t.Assert(v.Array.Slice(), g.SliceStr{"1", "2", "3"})
 	})
 }
+func TestStrArray_Filter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewStrArrayFrom(g.SliceStr{"", "1", "2", "0"})
+		t.Assert(array.Filter(func(index int, value string) bool {
+			return empty.IsEmpty(value)
+		}), g.SliceStr{"1", "2", "0"})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewStrArrayFrom(g.SliceStr{"1", "2"})
+		t.Assert(array.Filter(func(index int, value string) bool {
+			return empty.IsEmpty(value)
+		}), g.SliceStr{"1", "2"})
+	})
+}

 func TestStrArray_FilterEmpty(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
--- a/container/garray/garray_z_unit_sorted_any_test.go
+++ b/container/garray/garray_z_unit_sorted_any_test.go
@ -13,6 +13,8 @@ import (
 	"testing"
 	"time"

+	"github.com/gogf/gf/v2/internal/empty"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"
@ -869,6 +871,15 @@ func TestSortedArray_RemoveValue(t *testing.T) {
 	})
 }

+func TestSortedArray_RemoveValues(t *testing.T) {
+	slice := g.Slice{"a", "b", "d", "c"}
+	array := garray.NewSortedArrayFrom(slice, gutil.ComparatorString)
+	gtest.C(t, func(t *gtest.T) {
+		array.RemoveValues("a", "b", "c")
+		t.Assert(array.Slice(), g.SliceStr{"d"})
+	})
+}
+
 func TestSortedArray_UnmarshalValue(t *testing.T) {
 	type V struct {
 		Name  string
@ -897,6 +908,33 @@ func TestSortedArray_UnmarshalValue(t *testing.T) {
 		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
 	})
 }
+func TestSortedArray_Filter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
+		array := garray.NewSortedArrayFromCopy(values, gutil.ComparatorInt)
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
+			return empty.IsNil(value)
+		}).Slice(), g.Slice{0, "", g.Slice{}, 1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedArrayFromCopy(g.Slice{nil, 1, 2, 3, 4, nil}, gutil.ComparatorInt)
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
+			return empty.IsNil(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}, gutil.ComparatorInt)
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
+			return empty.IsEmpty(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedArrayFrom(g.Slice{1, 2, 3, 4}, gutil.ComparatorInt)
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
+			return empty.IsEmpty(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+}

 func TestSortedArray_FilterNil(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
--- a/container/garray/garray_z_unit_sorted_int_test.go
+++ b/container/garray/garray_z_unit_sorted_int_test.go
@ -12,6 +12,8 @@ import (
 	"testing"
 	"time"

+	"github.com/gogf/gf/v2/internal/empty"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"
@ -737,6 +739,15 @@ func TestSortedIntArray_RemoveValue(t *testing.T) {
 	})
 }

+func TestSortedIntArray_RemoveValues(t *testing.T) {
+	slice := g.SliceInt{10, 20, 30, 40}
+	array := garray.NewSortedIntArrayFrom(slice)
+	gtest.C(t, func(t *gtest.T) {
+		array.RemoveValues(10, 40, 20)
+		t.Assert(array.Slice(), g.SliceInt{30})
+	})
+}
+
 func TestSortedIntArray_UnmarshalValue(t *testing.T) {
 	type V struct {
 		Name  string
@ -765,6 +776,20 @@ func TestSortedIntArray_UnmarshalValue(t *testing.T) {
 		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
 	})
 }
+func TestSortedIntArray_Filter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedIntArrayFrom(g.SliceInt{0, 1, 2, 3, 4, 0})
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return empty.IsEmpty(value)
+		}), g.SliceInt{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedIntArrayFrom(g.SliceInt{1, 2, 3, 4})
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return empty.IsEmpty(value)
+		}), g.SliceInt{1, 2, 3, 4})
+	})
+}

 func TestSortedIntArray_FilterEmpty(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
--- a/container/garray/garray_z_unit_sorted_str_test.go
+++ b/container/garray/garray_z_unit_sorted_str_test.go
@ -12,6 +12,8 @@ import (
 	"testing"
 	"time"

+	"github.com/gogf/gf/v2/internal/empty"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"
@ -749,6 +751,15 @@ func TestSortedStrArray_RemoveValue(t *testing.T) {
 	})
 }

+func TestSortedStrArray_RemoveValues(t *testing.T) {
+	slice := g.SliceStr{"a", "b", "d", "c"}
+	array := garray.NewSortedStrArrayFrom(slice)
+	gtest.C(t, func(t *gtest.T) {
+		array.RemoveValues("a", "b", "c")
+		t.Assert(array.Slice(), g.SliceStr{"d"})
+	})
+}
+
 func TestSortedStrArray_UnmarshalValue(t *testing.T) {
 	type V struct {
 		Name  string
@ -777,6 +788,20 @@ func TestSortedStrArray_UnmarshalValue(t *testing.T) {
 		t.Assert(v.Array.Slice(), g.SliceStr{"1", "2", "3"})
 	})
 }
+func TestSortedStrArray_Filter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedStrArrayFrom(g.SliceStr{"", "1", "2", "0"})
+		t.Assert(array.Filter(func(index int, value string) bool {
+			return empty.IsEmpty(value)
+		}), g.SliceStr{"0", "1", "2"})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedStrArrayFrom(g.SliceStr{"1", "2"})
+		t.Assert(array.Filter(func(index int, value string) bool {
+			return empty.IsEmpty(value)
+		}), g.SliceStr{"1", "2"})
+	})
+}

 func TestSortedStrArray_FilterEmpty(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
--- a/container/gqueue/gqueue.go
+++ b/container/gqueue/gqueue.go
@ -27,7 +27,6 @@ import (
 // Queue is a concurrent-safe queue built on doubly linked list and channel.
 type Queue struct {
 	limit  int              // Limit for queue size.
-	length *gtype.Int64     // Queue length.
 	list   *glist.List      // Underlying list structure for data maintaining.
 	closed *gtype.Bool      // Whether queue is closed.
 	events chan struct{}    // Events for data writing.
@ -45,7 +44,6 @@ const (
 func New(limit ...int) *Queue {
 	q := &Queue{
 		closed: gtype.NewBool(),
-		length: gtype.NewInt64(),
 	}
 	if len(limit) > 0 && limit[0] > 0 {
 		q.limit = limit[0]
@ -62,7 +60,6 @@ func New(limit ...int) *Queue {
 // Push pushes the data `v` into the queue.
 // Note that it would panic if Push is called after the queue is closed.
 func (q *Queue) Push(v interface{}) {
-	q.length.Add(1)
 	if q.limit > 0 {
 		q.C <- v
 	} else {
@ -76,9 +73,7 @@ func (q *Queue) Push(v interface{}) {
 // Pop pops an item from the queue in FIFO way.
 // Note that it would return nil immediately if Pop is called after the queue is closed.
 func (q *Queue) Pop() interface{} {
-	item := <-q.C
-	q.length.Add(-1)
-	return item
+	return <-q.C
 }

 // Close closes the queue.
@ -101,13 +96,18 @@ func (q *Queue) Close() {
 }

 // Len returns the length of the queue.
-// Note that the result might not be accurate as there's an
+// Note that the result might not be accurate if using unlimited queue size as there's an
 // asynchronous channel reading the list constantly.
 func (q *Queue) Len() (length int64) {
-	return q.length.Val()
+	bufferedSize := int64(len(q.C))
+	if q.limit > 0 {
+		return bufferedSize
+	}
+	return int64(q.list.Size()) + bufferedSize
 }

 // Size is alias of Len.
+// Deprecated: use Len instead.
 func (q *Queue) Size() int64 {
 	return q.Len()
 }
@ -123,14 +123,11 @@ func (q *Queue) asyncLoopFromListToChannel() {
 	for !q.closed.Val() {
 		<-q.events
 		for !q.closed.Val() {
-			if length := q.list.Len(); length > 0 {
-				if length > defaultBatchSize {
-					length = defaultBatchSize
-				}
-				for _, v := range q.list.PopFronts(length) {
-					// When q.C is closed, it will panic here, especially q.C is being blocked for writing.
-					// If any error occurs here, it will be caught by recover and be ignored.
-					q.C <- v
+			if bufferLength := q.list.Len(); bufferLength > 0 {
+				// When q.C is closed, it will panic here, especially q.C is being blocked for writing.
+				// If any error occurs here, it will be caught by recover and be ignored.
+				for i := 0; i < bufferLength; i++ {
+					q.C <- q.list.PopFront()
 				}
 			} else {
 				break
--- a/container/gqueue/gqueue_z_unit_test.go
+++ b/container/gqueue/gqueue_z_unit_test.go
@ -18,14 +18,31 @@ import (

 func TestQueue_Len(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		max := 100
-		for n := 10; n < max; n++ {
-			q1 := gqueue.New(max)
-			for i := 0; i < max; i++ {
+		var (
+			maxNum   = 100
+			maxTries = 100
+		)
+		for n := 10; n < maxTries; n++ {
+			q1 := gqueue.New(maxNum)
+			for i := 0; i < maxNum; i++ {
 				q1.Push(i)
 			}
-			t.Assert(q1.Len(), max)
-			t.Assert(q1.Size(), max)
+			t.Assert(q1.Len(), maxNum)
+			t.Assert(q1.Size(), maxNum)
+		}
+	})
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			maxNum   = 100
+			maxTries = 100
+		)
+		for n := 10; n < maxTries; n++ {
+			q1 := gqueue.New()
+			for i := 0; i < maxNum; i++ {
+				q1.Push(i)
+			}
+			t.AssertLE(q1.Len(), maxNum)
+			t.AssertLE(q1.Size(), maxNum)
 		}
 	})
 }
@ -71,3 +88,19 @@ func TestQueue_Close(t *testing.T) {
 		q1.Close()
 	})
 }
+
+func Test_Issue2509(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New()
+		q.Push(1)
+		q.Push(2)
+		q.Push(3)
+		t.AssertLE(q.Len(), 3)
+		t.Assert(<-q.C, 1)
+		t.AssertLE(q.Len(), 2)
+		t.Assert(<-q.C, 2)
+		t.AssertLE(q.Len(), 1)
+		t.Assert(<-q.C, 3)
+		t.Assert(q.Len(), 0)
+	})
+}
--- a/container/gset/gset_z_unit_any_test.go
+++ b/container/gset/gset_z_unit_any_test.go
@ -114,8 +114,8 @@ func TestSet_LockFunc(t *testing.T) {
 		t.Assert(s.Size(), 2)
 		s.RLockFunc(func(m map[interface{}]struct{}) {
 			t.Assert(m, map[interface{}]struct{}{
-				3: struct{}{},
-				2: struct{}{},
+				3: {},
+				2: {},
 			})
 		})
 	})
--- a/container/gset/gset_z_unit_int_test.go
+++ b/container/gset/gset_z_unit_int_test.go
@ -94,8 +94,8 @@ func TestIntSet_LockFunc(t *testing.T) {
 		t.Assert(s.Size(), 2)
 		s.RLockFunc(func(m map[int]struct{}) {
 			t.Assert(m, map[int]struct{}{
-				3: struct{}{},
-				2: struct{}{},
+				3: {},
+				2: {},
 			})
 		})
 	})
--- a/container/gset/gset_z_unit_str_test.go
+++ b/container/gset/gset_z_unit_str_test.go
@ -105,8 +105,8 @@ func TestStrSet_LockFunc(t *testing.T) {
 		t.Assert(s.Size(), 2)
 		s.RLockFunc(func(m map[string]struct{}) {
 			t.Assert(m, map[string]struct{}{
-				"3": struct{}{},
-				"2": struct{}{},
+				"3": {},
+				"2": {},
 			})
 		})
 	})
--- a/container/gvar/gvar.go
+++ b/container/gvar/gvar.go
@ -28,7 +28,7 @@ type Var struct {
 // The optional parameter `safe` specifies whether Var is used in concurrent-safety,
 // which is false in default.
 func New(value interface{}, safe ...bool) *Var {
-	if len(safe) > 0 && !safe[0] {
+	if len(safe) > 0 && safe[0] {
 		return &Var{
 			value: gtype.NewInterface(value),
 			safe:  true,
--- a/contrib/config/apollo/go.mod
+++ b/contrib/config/apollo/go.mod
@ -4,7 +4,7 @@ go 1.15

 require (
 	github.com/apolloconfig/agollo/v4 v4.1.1
-	github.com/gogf/gf/v2 v2.1.4
+	github.com/gogf/gf/v2 v2.3.3
 )

 replace github.com/gogf/gf/v2 => ../../../
--- a/contrib/config/kubecm/go.mod
+++ b/contrib/config/kubecm/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/config/kubecm/v2
 go 1.18

 require (
-	github.com/gogf/gf/v2 v2.0.0
+	github.com/gogf/gf/v2 v2.3.3
 	k8s.io/api v0.25.2
 	k8s.io/apimachinery v0.25.2
 	k8s.io/client-go v0.25.2
--- a/contrib/config/nacos/go.mod
+++ b/contrib/config/nacos/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/config/nacos/v2
 go 1.15

 require (
-	github.com/gogf/gf/v2 v2.2.1
+	github.com/gogf/gf/v2 v2.3.3
 	github.com/nacos-group/nacos-sdk-go v1.1.2
 )

--- a/contrib/config/polaris/README.MD
+++ b/contrib/config/polaris/README.MD
@ -51,7 +51,7 @@ func init() {
 }
 ```

-## Import boot package in top of main
+## Import boot package on top of main

 It is strongly recommended import your boot package in top of your `main.go`.

--- a/contrib/config/polaris/go.mod
+++ b/contrib/config/polaris/go.mod
@ -3,8 +3,8 @@ module github.com/gogf/gf/contrib/config/polaris/v2
 go 1.15

 require (
-	github.com/gogf/gf/v2 v2.0.0
-	github.com/polarismesh/polaris-go v1.2.0-beta.3
+	github.com/gogf/gf/v2 v2.3.3
+	github.com/polarismesh/polaris-go v1.3.0
 )

 replace github.com/gogf/gf/v2 => ../../../
--- a/contrib/config/polaris/go.sum
+++ b/contrib/config/polaris/go.sum
@ -227,8 +227,8 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 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/polarismesh/polaris-go v1.2.0-beta.3 h1:sqN50VGign37xVFp9nrN1RoLXacsB0QfRYUtuCWMJGI=
-github.com/polarismesh/polaris-go v1.2.0-beta.3/go.mod h1:HsN0ierETIujHpmnnYJ3qkwQw4QGAECuHvBZTDaw1tI=
+github.com/polarismesh/polaris-go v1.3.0 h1:KZKX//ow4OPPoS5+s7h07ptprg+2AcNVGrN6WakC9QM=
+github.com/polarismesh/polaris-go v1.3.0/go.mod h1:HsN0ierETIujHpmnnYJ3qkwQw4QGAECuHvBZTDaw1tI=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
--- a/contrib/config/polaris/polaris.go
+++ b/contrib/config/polaris/polaris.go
@ -10,21 +10,17 @@ package polaris
 import (
 	"context"

+	"github.com/polarismesh/polaris-go"
+	"github.com/polarismesh/polaris-go/api"
+	"github.com/polarismesh/polaris-go/pkg/model"
+
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gcfg"
 	"github.com/gogf/gf/v2/text/gstr"
-	"github.com/polarismesh/polaris-go"
-	"github.com/polarismesh/polaris-go/api"
-	"github.com/polarismesh/polaris-go/pkg/model"
 )

-// LogDir sets the log directory for polaris.
-func LogDir(dir string) error {
-	return api.SetLoggersDir(dir)
-}
-
 // Config is the configuration for polaris.
 type Config struct {
 	// The namespace of the configuration.
@ -65,14 +61,14 @@ func New(ctx context.Context, config Config) (adapter gcfg.Adapter, err error) {
 	)

 	if configAPI, err = polaris.NewConfigAPIByFile(config.Path); err != nil {
-		err = gerror.Wrapf(err, "Polaris configuration initialization failed  with config: %+v", config)
+		err = gerror.Wrapf(err, "Polaris configuration initialization failed with config: %+v", config)
 		return
 	}
 	// set log dir
 	if gstr.Trim(config.LogDir) == "" {
 		config.LogDir = defaultLogDir
 	}
-	if err = LogDir(config.LogDir); err != nil {
+	if err = client.LogDir(config.LogDir); err != nil {
 		err = gerror.Wrap(err, "set polaris log dir failed")
 		return
 	}
@ -85,6 +81,11 @@ func New(ctx context.Context, config Config) (adapter gcfg.Adapter, err error) {
 	return client, nil
 }

+// LogDir sets the log directory for polaris.
+func (c *Client) LogDir(dir string) error {
+	return api.SetLoggersDir(dir)
+}
+
 // Available checks and returns the backend configuration service is available.
 // The optional parameter `resource` specifies certain configuration resource.
 //
@ -103,7 +104,7 @@ func (c *Client) Available(ctx context.Context, resource ...string) (ok bool) {
 	return c.client.GetNamespace() == namespace
 }

-// Get retrieves and returns value by specified `pattern` in current resource.
+// Get retrieves and return value by specified `pattern` in current resource.
 // Pattern like:
 // "x.y.z" for map item.
 // "x.0.y" for slice item.
@ -117,7 +118,7 @@ func (c *Client) Get(ctx context.Context, pattern string) (value interface{}, er
 }

 // Data retrieves and returns all configuration data in current resource as map.
-// Note that this function may lead lots of memory usage if configuration data is too large,
+// Note that this function may lead to lots of memory usage if configuration data are too large,
 // you can implement this function if necessary.
 func (c *Client) Data(ctx context.Context) (data map[string]interface{}, err error) {
 	if c.value.IsNil() {
--- a/contrib/drivers/README.MD
+++ b/contrib/drivers/README.MD
@ -58,6 +58,7 @@ Note:
 - It does not support `Save/Replace` features.
 - It does not support `LastInsertId`.
 - It supports server version >= `SQL Server2005`
+- It ONLY supports datetime2 and datetimeoffset types for auto handling created_at/updated_at/deleted_at columns, because datetime type does not support microseconds precision when column value is passed as string. 

 ## Oracle
 ```
--- a/contrib/drivers/clickhouse/clickhouse_test.go
+++ b/contrib/drivers/clickhouse/clickhouse_test.go
@ -455,9 +455,9 @@ func TestDriverClickhouse_NilTime(t *testing.T) {
 			Col9: uuid.New(),
 			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"},
+					{"key": "value"},
+					{"key": "value"},
+					{"key": "value"},
 				}},
 			Col11: money,
 			Col12: &strMoney,
@ -494,9 +494,9 @@ func TestDriverClickhouse_BatchInsert(t *testing.T) {
 			"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"},
+					{"key": "value"},
+					{"key": "value"},
+					{"key": "value"},
 				},
 			},
 			"Col8":  gtime.Now(),
--- a/contrib/drivers/clickhouse/go.mod
+++ b/contrib/drivers/clickhouse/go.mod
@ -4,7 +4,7 @@ go 1.15

 require (
 	github.com/ClickHouse/clickhouse-go/v2 v2.0.15
-	github.com/gogf/gf/v2 v2.0.0
+	github.com/gogf/gf/v2 v2.3.3
 	github.com/google/uuid v1.3.0
 	github.com/shopspring/decimal v1.3.1
 )
--- a/contrib/drivers/dm/dm.go
+++ b/contrib/drivers/dm/dm.go
@ -23,6 +23,7 @@ import (
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/text/gregex"
 	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/gutil"
 )

@ -283,23 +284,7 @@ func parseValue(listOne gdb.Map, char struct {
 			)
 		}

-		va := reflect.ValueOf(listOne[column])
-		ty := reflect.TypeOf(listOne[column])
-		saveValue := ""
-		switch ty.Kind() {
-		case reflect.String:
-			saveValue = va.String()
-
-		case reflect.Int:
-			saveValue = strconv.FormatInt(va.Int(), 10)
-
-		case reflect.Int64:
-			saveValue = strconv.FormatInt(va.Int(), 10)
-
-		default:
-			// The fish has no chance getting here.
-			// Nothing to do.
-		}
+		saveValue := gconv.String(listOne[column])
 		queryValues = append(
 			queryValues,
 			fmt.Sprintf(
--- a/contrib/drivers/dm/dm_init_test.go
+++ b/contrib/drivers/dm/dm_init_test.go
@ -125,9 +125,9 @@ func createTable(table ...string) (name string) {
 "ENABLED" INT DEFAULT 1 NOT NULL,
 "DELETED" INT DEFAULT 0 NOT NULL,
 "CREATED_BY" VARCHAR(32) DEFAULT '' NOT NULL,
-"CREATED_TIME" TIMESTAMP(0) DEFAULT CURRENT_TIMESTAMP() NOT NULL,
+"CREATED_TIME" TIMESTAMP(6) DEFAULT CURRENT_TIMESTAMP() NOT NULL,
 "UPDATED_BY" VARCHAR(32) DEFAULT '' NOT NULL,
-"UPDATED_TIME" TIMESTAMP(0) DEFAULT CURRENT_TIMESTAMP() NOT NULL,
+"UPDATED_TIME" TIMESTAMP(6) DEFAULT CURRENT_TIMESTAMP() NOT NULL,
 NOT CLUSTER PRIMARY KEY("ID")) STORAGE(ON "MAIN", CLUSTERBTR) ;
 	`, name)); err != nil {
 		gtest.Fatal(err)
--- a/contrib/drivers/dm/dm_z_basic_test.go
+++ b/contrib/drivers/dm/dm_z_basic_test.go
@ -233,7 +233,7 @@ func Test_DB_Insert(t *testing.T) {
 		_, err := db.Insert(ctx, "A_tables", g.Map{
 			"ID":           1000,
 			"ACCOUNT_NAME": "map1",
-			"CREATED_TIME": gtime.Now().String(),
+			"CREATED_TIME": gtime.Now(),
 		})
 		t.AssertNil(err)

@ -249,7 +249,7 @@ func Test_DB_Insert(t *testing.T) {
 		result, err = db.Insert(ctx, "A_tables", g.Map{
 			"ID":           3000,
 			"ACCOUNT_NAME": "map3",
-			// "CREATED_TIME": gtime.Now().String(),
+			// "CREATED_TIME": gtime.Now(),
 		})
 		t.AssertNil(err)
 		n, _ = result.RowsAffected()
@ -320,12 +320,12 @@ func Test_DB_BatchInsert(t *testing.T) {
 			{
 				"ID":           400,
 				"ACCOUNT_NAME": "list_400",
-				// "CREATE_TIME":  gtime.Now().String(),
+				// "CREATE_TIME":  gtime.Now(),
 			},
 			{
 				"ID":           401,
 				"ACCOUNT_NAME": "list_401",
-				"CREATE_TIME":  gtime.Now().String(),
+				"CREATE_TIME":  gtime.Now(),
 			},
 		}, 1)
 		t.AssertNil(err)
@ -342,12 +342,12 @@ func Test_DB_BatchInsert(t *testing.T) {
 			g.Map{
 				"ID":           500,
 				"ACCOUNT_NAME": "500_batch_500",
-				"CREATE_TIME":  gtime.Now().String(),
+				"CREATE_TIME":  gtime.Now(),
 			},
 			g.Map{
 				"ID":           501,
 				"ACCOUNT_NAME": "501_batch_501",
-				// "CREATE_TIME":  gtime.Now().String(),
+				// "CREATE_TIME":  gtime.Now(),
 			},
 		}, 1)
 		t.AssertNil(err)
@ -363,7 +363,7 @@ func Test_DB_BatchInsert(t *testing.T) {
 		result, err := db.Insert(ctx, table, g.Map{
 			"ID":           600,
 			"ACCOUNT_NAME": "600_batch_600",
-			"CREATE_TIME":  gtime.Now().String(),
+			"CREATE_TIME":  gtime.Now(),
 		})
 		t.AssertNil(err)
 		n, _ := result.RowsAffected()
--- a/contrib/drivers/dm/go.mod
+++ b/contrib/drivers/dm/go.mod
@ -6,5 +6,5 @@ replace github.com/gogf/gf/v2 => ../../../

 require (
 	gitee.com/chunanyong/dm v1.8.10
-	github.com/gogf/gf/v2 v2.0.0
+	github.com/gogf/gf/v2 v2.3.3
 )
--- a/contrib/drivers/mssql/go.mod
+++ b/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
+	github.com/gogf/gf/v2 v2.3.3
 )

 replace github.com/gogf/gf/v2 => ../../../
--- a/contrib/drivers/mssql/mssql_init_test.go
+++ b/contrib/drivers/mssql/mssql_init_test.go
@ -107,6 +107,8 @@ func createTable(table ...string) (name string) {
 		PASSWORD VARCHAR(32)  NULL,
 		NICKNAME VARCHAR(45)  NULL,
 		CREATE_TIME datetime NULL,
+		CREATED_AT datetimeoffset NULL,
+		UPDATED_AT datetimeoffset NULL,
 		PRIMARY KEY (ID))
 	`, name, name)); err != nil {
 		gtest.Fatal(err)
@ -125,7 +127,7 @@ func createInitTable(table ...string) (name string) {
 			"passport":    fmt.Sprintf(`user_%d`, i),
 			"password":    fmt.Sprintf(`pass_%d`, i),
 			"nickname":    fmt.Sprintf(`name_%d`, i),
-			"create_time": gtime.Now().String(),
+			"create_time": gtime.Now(),
 		})
 	}
 	result, err := db.Insert(context.Background(), name, array.Slice())
--- a/contrib/drivers/mssql/mssql_z_basic_test.go
+++ b/contrib/drivers/mssql/mssql_z_basic_test.go
@ -120,7 +120,7 @@ func TestDoInsert(t *testing.T) {
 			"passport":    fmt.Sprintf(`t%d`, i),
 			"password":    fmt.Sprintf(`p%d`, i),
 			"nickname":    fmt.Sprintf(`T%d`, i),
-			"create_time": gtime.Now().String(),
+			"create_time": gtime.Now(),
 		}
 		_, err := db.Insert(context.Background(), "t_user", data)
 		gtest.Assert(err, nil)
@ -137,7 +137,7 @@ func TestDoInsert(t *testing.T) {
 			"passport":    fmt.Sprintf(`t%d`, i),
 			"password":    fmt.Sprintf(`p%d`, i),
 			"nickname":    fmt.Sprintf(`T%d`, i),
-			"create_time": gtime.Now().String(),
+			"create_time": gtime.Now(),
 		}
 		_, err := db.Save(context.Background(), "t_user", data, 10)
 		gtest.AssertNE(err, nil)
@ -192,7 +192,7 @@ func Test_DB_Insert(t *testing.T) {
 			"passport":    "t1",
 			"password":    "25d55ad283aa400af464c76d713c07ad",
 			"nickname":    "T1",
-			"create_time": gtime.Now().String(),
+			"create_time": gtime.Now(),
 		})
 		t.AssertNil(err)

@ -202,7 +202,7 @@ func Test_DB_Insert(t *testing.T) {
 			"passport":    "t2",
 			"password":    "25d55ad283aa400af464c76d713c07ad",
 			"nickname":    "name_2",
-			"create_time": gtime.Now().String(),
+			"create_time": gtime.Now(),
 		})
 		t.AssertNil(err)
 		n, _ := result.RowsAffected()
@ -210,19 +210,19 @@ func Test_DB_Insert(t *testing.T) {

 		// struct
 		type User struct {
-			Id         int    `gconv:"id"`
-			Passport   string `json:"passport"`
-			Password   string `gconv:"password"`
-			Nickname   string `gconv:"nickname"`
-			CreateTime string `json:"create_time"`
+			Id         int         `gconv:"id"`
+			Passport   string      `json:"passport"`
+			Password   string      `gconv:"password"`
+			Nickname   string      `gconv:"nickname"`
+			CreateTime *gtime.Time `json:"create_time"`
 		}
-		timeStr := gtime.Now().String()
+		timeNow := gtime.Now()
 		result, err = db.Insert(ctx, table, User{
 			Id:         3,
 			Passport:   "user_3",
 			Password:   "25d55ad283aa400af464c76d713c07ad",
 			Nickname:   "name_3",
-			CreateTime: timeStr,
+			CreateTime: timeNow,
 		})
 		t.AssertNil(err)
 		n, _ = result.RowsAffected()
@ -235,16 +235,16 @@ func Test_DB_Insert(t *testing.T) {
 		t.Assert(one["PASSPORT"].String(), "user_3")
 		t.Assert(one["PASSWORD"].String(), "25d55ad283aa400af464c76d713c07ad")
 		t.Assert(one["NICKNAME"].String(), "name_3")
-		t.Assert(one["CREATE_TIME"].GTime().String(), timeStr)
+		t.Assert(one["CREATE_TIME"].GTime(), timeNow)

 		// *struct
-		timeStr = gtime.Now().String()
+		timeNow = gtime.Now()
 		result, err = db.Insert(ctx, table, &User{
 			Id:         4,
 			Passport:   "t4",
 			Password:   "25d55ad283aa400af464c76d713c07ad",
 			Nickname:   "name_4",
-			CreateTime: timeStr,
+			CreateTime: timeNow,
 		})
 		t.AssertNil(err)
 		n, _ = result.RowsAffected()
@ -256,24 +256,24 @@ func Test_DB_Insert(t *testing.T) {
 		t.Assert(one["PASSPORT"].String(), "t4")
 		t.Assert(one["PASSWORD"].String(), "25d55ad283aa400af464c76d713c07ad")
 		t.Assert(one["NICKNAME"].String(), "name_4")
-		t.Assert(one["CREATE_TIME"].GTime().String(), timeStr)
+		t.Assert(one["CREATE_TIME"].GTime(), timeNow)

 		// batch with Insert
-		timeStr = gtime.Now().String()
+		timeNow = gtime.Now()
 		r, err := db.Insert(ctx, table, g.Slice{
 			g.Map{
 				"id":          200,
 				"passport":    "t200",
 				"password":    "25d55ad283aa400af464c76d71qw07ad",
 				"nickname":    "T200",
-				"create_time": timeStr,
+				"create_time": timeNow,
 			},
 			g.Map{
 				"id":          300,
 				"passport":    "t300",
 				"password":    "25d55ad283aa400af464c76d713c07ad",
 				"nickname":    "T300",
-				"create_time": timeStr,
+				"create_time": timeNow,
 			},
 		})
 		t.AssertNil(err)
@ -286,7 +286,7 @@ func Test_DB_Insert(t *testing.T) {
 		t.Assert(one["PASSPORT"].String(), "t200")
 		t.Assert(one["PASSWORD"].String(), "25d55ad283aa400af464c76d71qw07ad")
 		t.Assert(one["NICKNAME"].String(), "T200")
-		t.Assert(one["CREATE_TIME"].GTime().String(), timeStr)
+		t.Assert(one["CREATE_TIME"].GTime(), timeNow)
 	})
 }

@ -360,14 +360,14 @@ func Test_DB_BatchInsert(t *testing.T) {
 				"passport":    "t2",
 				"password":    "25d55ad283aa400af464c76d713c07ad",
 				"nickname":    "name_2",
-				"create_time": gtime.Now().String(),
+				"create_time": gtime.Now(),
 			},
 			{
 				"id":          3,
 				"passport":    "user_3",
 				"password":    "25d55ad283aa400af464c76d713c07ad",
 				"nickname":    "name_3",
-				"create_time": gtime.Now().String(),
+				"create_time": gtime.Now(),
 			},
 		}, 1)
 		t.AssertNil(err)
@ -386,14 +386,14 @@ func Test_DB_BatchInsert(t *testing.T) {
 				"passport":    "t2",
 				"password":    "25d55ad283aa400af464c76d713c07ad",
 				"nickname":    "name_2",
-				"create_time": gtime.Now().String(),
+				"create_time": gtime.Now(),
 			},
 			g.Map{
 				"id":          3,
 				"passport":    "user_3",
 				"password":    "25d55ad283aa400af464c76d713c07ad",
 				"nickname":    "name_3",
-				"create_time": gtime.Now().String(),
+				"create_time": gtime.Now(),
 			},
 		}, 1)
 		t.AssertNil(err)
@ -410,7 +410,7 @@ func Test_DB_BatchInsert(t *testing.T) {
 			"passport":    "t1",
 			"password":    "p1",
 			"nickname":    "T1",
-			"create_time": gtime.Now().String(),
+			"create_time": gtime.Now(),
 		})
 		t.AssertNil(err)
 		n, _ := result.RowsAffected()
--- a/contrib/drivers/mssql/mssql_z_model_test.go
+++ b/contrib/drivers/mssql/mssql_z_model_test.go
@ -1556,15 +1556,15 @@ func Test_Model_Option_Map(t *testing.T) {
 		t.Assert(n, 1)

 		_, err = db.Model(table).OmitEmptyData().Data(g.Map{"nickname": ""}).Where("id", 2).Update()
-		t.AssertNE(err, nil)
+		t.AssertNil(err)

 		r, err = db.Model(table).OmitEmpty().Data(g.Map{"nickname": "", "password": "123"}).Where("id", 3).Update()
 		t.AssertNil(err)
 		n, _ = r.RowsAffected()
 		t.Assert(n, 1)

-		_, err = db.Model(table).OmitEmpty().Fields("nickname").Data(g.Map{"nickname": "", "password": "123"}).Where("id", 4).Update()
-		t.AssertNE(err, nil)
+		_, err = db.Model(table).OmitEmpty().Fields("nickname", "password").Data(g.Map{"nickname": "", "password": "123", "passport": "123"}).Where("id", 4).Update()
+		t.AssertNil(err)

 		r, err = db.Model(table).OmitEmpty().
 			Fields("password").Data(g.Map{
@ -1639,7 +1639,7 @@ func Test_Model_FieldsEx(t *testing.T) {
 	defer dropTable(table)
 	// Select.
 	gtest.C(t, func(t *gtest.T) {
-		r, err := db.Model(table).FieldsEx("create_time, id").Where("id in (?)", g.Slice{1, 2}).Order("id asc").All()
+		r, err := db.Model(table).FieldsEx("create_time, created_at, updated_at, id").Where("id in (?)", g.Slice{1, 2}).Order("id asc").All()
 		t.AssertNil(err)
 		t.Assert(len(r), 2)
 		t.Assert(len(r[0]), 3)
--- a/contrib/drivers/mysql/go.mod
+++ b/contrib/drivers/mysql/go.mod
@ -4,7 +4,7 @@ go 1.15

 require (
 	github.com/go-sql-driver/mysql v1.6.0
-	github.com/gogf/gf/v2 v2.0.0
+	github.com/gogf/gf/v2 v2.3.3
 )

 replace github.com/gogf/gf/v2 => ../../../
--- a/contrib/drivers/mysql/mysql__test.go
+++ b/contrib/drivers/mysql/mysql__test.go
@ -117,7 +117,7 @@ func createTableWithDb(db gdb.DB, table ...string) (name string) {
 	        passport    varchar(45) NULL,
 	        password    char(32) NULL,
 	        nickname    varchar(45) NULL,
-	        create_time timestamp NULL,
+	        create_time timestamp(6) NULL,
 	        PRIMARY KEY (id)
 	    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 	    `, name,
--- a/contrib/drivers/mysql/mysql_feature_model_builder_test.go
+++ b/contrib/drivers/mysql/mysql_feature_model_builder_test.go
@ -125,3 +125,17 @@ func Test_Model_Builder(t *testing.T) {
 		t.Assert(args, []interface{}{1})
 	})
 }
+
+func Test_Safe_Builder(t *testing.T) {
+	// test whether m.Builder() is chain safe
+	gtest.C(t, func(t *gtest.T) {
+		b := db.Model().Builder()
+		b.Where("id", 1)
+		_, args := b.Build()
+		t.AssertNil(args)
+
+		b = b.Where("id", 1)
+		_, args = b.Build()
+		t.Assert(args, g.Slice{1})
+	})
+}
--- a/contrib/drivers/mysql/mysql_feature_model_do_test.go
+++ b/contrib/drivers/mysql/mysql_feature_model_do_test.go
@ -11,6 +11,7 @@ import (

 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )

 func Test_Model_Insert_Data_DO(t *testing.T) {
@ -46,7 +47,7 @@ func Test_Model_Insert_Data_DO(t *testing.T) {
 	})
 }

-func Test_Model_Insert_Data_LIst_DO(t *testing.T) {
+func Test_Model_Insert_Data_List_DO(t *testing.T) {
 	table := createTable()
 	defer dropTable(table)

@ -124,6 +125,50 @@ func Test_Model_Update_Data_DO(t *testing.T) {
 	})
 }

+func Test_Model_Update_Pointer_Data_DO(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	db.SetDebug(true)
+	gtest.C(t, func(t *gtest.T) {
+		type NN string
+		type Req struct {
+			Id       int
+			Passport *string
+			Password *string
+			Nickname *NN
+		}
+		type UserDo struct {
+			g.Meta     `orm:"do:true"`
+			Id         interface{}
+			Passport   interface{}
+			Password   interface{}
+			Nickname   interface{}
+			CreateTime interface{}
+		}
+		var (
+			nickname = NN("nickname_111")
+			req      = Req{
+				Password: gconv.PtrString("12345678"),
+				Nickname: &nickname,
+			}
+			data = UserDo{
+				Passport: req.Passport,
+				Password: req.Password,
+				Nickname: req.Nickname,
+			}
+		)
+
+		_, err := db.Model(table).Data(data).WherePri(1).Update()
+		t.AssertNil(err)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one[`id`], `1`)
+		t.Assert(one[`password`], `12345678`)
+		t.Assert(one[`nickname`], `nickname_111`)
+	})
+}
+
 func Test_Model_Where_DO(t *testing.T) {
 	table := createInitTable()
 	defer dropTable(table)
@ -183,7 +228,7 @@ func Test_Model_Insert_Data_ForDao(t *testing.T) {
 	})
 }

-func Test_Model_Insert_Data_LIst_ForDao(t *testing.T) {
+func Test_Model_Insert_Data_List_ForDao(t *testing.T) {
 	table := createTable()
 	defer dropTable(table)

--- a/contrib/drivers/mysql/mysql_feature_time_maintain_test.go
+++ b/contrib/drivers/mysql/mysql_feature_time_maintain_test.go
@ -17,15 +17,149 @@ import (
 )

 // CreateAt/UpdateAt/DeleteAt.
-func Test_SoftCreateUpdateDeleteTime(t *testing.T) {
+func Test_SoftCreateUpdateDeleteTimeMicroSecond(t *testing.T) {
 	table := "time_test_table_" + gtime.TimestampNanoStr()
 	if _, err := db.Exec(ctx, fmt.Sprintf(`
 CREATE TABLE %s (
  id        int(11) NOT NULL,
  name      varchar(45) DEFAULT NULL,
-  create_at datetime DEFAULT NULL,
-  update_at datetime DEFAULT NULL,
-  delete_at datetime DEFAULT NULL,
+  create_at datetime(6) DEFAULT NULL,
+  update_at datetime(6) DEFAULT NULL,
+  delete_at datetime(6) DEFAULT NULL,
+  PRIMARY KEY (id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+    `, table)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert
+		dataInsert := g.Map{
+			"id":   1,
+			"name": "name_1",
+		}
+		r, err := db.Model(table).Data(dataInsert).Insert()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 1)
+
+		oneInsert, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(oneInsert["id"].Int(), 1)
+		t.Assert(oneInsert["name"].String(), "name_1")
+		t.Assert(oneInsert["delete_at"].String(), "")
+		t.AssertGE(oneInsert["create_at"].GTime().Timestamp(), gtime.Timestamp()-2)
+		t.AssertGE(oneInsert["update_at"].GTime().Timestamp(), gtime.Timestamp()-2)
+
+		// For time asserting purpose.
+		time.Sleep(2 * time.Second)
+
+		// Save
+		dataSave := g.Map{
+			"id":   1,
+			"name": "name_10",
+		}
+		r, err = db.Model(table).Data(dataSave).Save()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 2)
+
+		oneSave, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(oneSave["id"].Int(), 1)
+		t.Assert(oneSave["name"].String(), "name_10")
+		t.Assert(oneSave["delete_at"].String(), "")
+		t.Assert(oneSave["create_at"].GTime().Timestamp(), oneInsert["create_at"].GTime().Timestamp())
+		t.AssertNE(oneSave["update_at"].GTime().Timestamp(), oneInsert["update_at"].GTime().Timestamp())
+		t.AssertGE(oneSave["update_at"].GTime().Timestamp(), gtime.Timestamp()-2)
+
+		// For time asserting purpose.
+		time.Sleep(2 * time.Second)
+
+		// Update
+		dataUpdate := g.Map{
+			"name": "name_1000",
+		}
+		r, err = db.Model(table).Data(dataUpdate).WherePri(1).Update()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+
+		oneUpdate, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(oneUpdate["id"].Int(), 1)
+		t.Assert(oneUpdate["name"].String(), "name_1000")
+		t.Assert(oneUpdate["delete_at"].String(), "")
+		t.Assert(oneUpdate["create_at"].GTime().Timestamp(), oneInsert["create_at"].GTime().Timestamp())
+		t.AssertGE(oneUpdate["update_at"].GTime().Timestamp(), gtime.Timestamp()-2)
+
+		// Replace
+		dataReplace := g.Map{
+			"id":   1,
+			"name": "name_100",
+		}
+		r, err = db.Model(table).Data(dataReplace).Replace()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 2)
+
+		oneReplace, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(oneReplace["id"].Int(), 1)
+		t.Assert(oneReplace["name"].String(), "name_100")
+		t.Assert(oneReplace["delete_at"].String(), "")
+		t.AssertGE(oneReplace["create_at"].GTime().Timestamp(), oneInsert["create_at"].GTime().Timestamp())
+		t.AssertGE(oneReplace["update_at"].GTime().Timestamp(), oneInsert["update_at"].GTime().Timestamp())
+
+		// For time asserting purpose.
+		time.Sleep(2 * time.Second)
+
+		// Delete
+		r, err = db.Model(table).Delete("id", 1)
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+		// Delete Select
+		one4, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(len(one4), 0)
+		one5, err := db.Model(table).Unscoped().WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one5["id"].Int(), 1)
+		t.AssertGE(one5["delete_at"].GTime().Timestamp(), gtime.Timestamp()-2)
+		// Delete Count
+		i, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(i, 0)
+		i, err = db.Model(table).Unscoped().Count()
+		t.AssertNil(err)
+		t.Assert(i, 1)
+
+		// Delete Unscoped
+		r, err = db.Model(table).Unscoped().Delete("id", 1)
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+		one6, err := db.Model(table).Unscoped().WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(len(one6), 0)
+		i, err = db.Model(table).Unscoped().Count()
+		t.AssertNil(err)
+		t.Assert(i, 0)
+	})
+}
+
+// CreateAt/UpdateAt/DeleteAt.
+func Test_SoftCreateUpdateDeleteTimeSecond(t *testing.T) {
+	table := "time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        int(11) NOT NULL,
+  name      varchar(45) DEFAULT NULL,
+  create_at datetime(0) DEFAULT NULL,
+  update_at datetime(0) DEFAULT NULL,
+  delete_at datetime(0) DEFAULT NULL,
  PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    `, table)); err != nil {
@ -157,9 +291,9 @@ func Test_SoftCreatedUpdatedDeletedTime_Map(t *testing.T) {
 CREATE TABLE %s (
  id        int(11) NOT NULL,
  name      varchar(45) DEFAULT NULL,
-  created_at datetime DEFAULT NULL,
-  updated_at datetime DEFAULT NULL,
-  deleted_at datetime DEFAULT NULL,
+  created_at datetime(6) DEFAULT NULL,
+  updated_at datetime(6) DEFAULT NULL,
+  deleted_at datetime(6) DEFAULT NULL,
  PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    `, table)); err != nil {
@ -291,9 +425,9 @@ func Test_SoftCreatedUpdatedDeletedTime_Struct(t *testing.T) {
 CREATE TABLE %s (
  id        int(11) NOT NULL,
  name      varchar(45) DEFAULT NULL,
-  created_at datetime DEFAULT NULL,
-  updated_at datetime DEFAULT NULL,
-  deleted_at datetime DEFAULT NULL,
+  created_at datetime(6) DEFAULT NULL,
+  updated_at datetime(6) DEFAULT NULL,
+  deleted_at datetime(6) DEFAULT NULL,
  PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    `, table)); err != nil {
@ -431,9 +565,9 @@ func Test_SoftUpdateTime(t *testing.T) {
 CREATE TABLE %s (
  id        int(11) NOT NULL,
  num       int(11) DEFAULT NULL,
-  create_at datetime DEFAULT NULL,
-  update_at datetime DEFAULT NULL,
-  delete_at datetime DEFAULT NULL,
+  create_at datetime(6) DEFAULT NULL,
+  update_at datetime(6) DEFAULT NULL,
+  delete_at datetime(6) DEFAULT NULL,
  PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    `, table)); err != nil {
@ -471,9 +605,9 @@ func Test_SoftUpdateTime_WithDO(t *testing.T) {
 CREATE TABLE %s (
  id        int(11) NOT NULL,
  num       int(11) DEFAULT NULL,
-  created_at datetime DEFAULT NULL,
-  updated_at datetime DEFAULT NULL,
-  deleted_at datetime DEFAULT NULL,
+  created_at datetime(6) DEFAULT NULL,
+  updated_at datetime(6) DEFAULT NULL,
+  deleted_at datetime(6) DEFAULT NULL,
  PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    `, table)); err != nil {
@ -528,9 +662,9 @@ func Test_SoftDelete(t *testing.T) {
 CREATE TABLE %s (
  id        int(11) NOT NULL,
  name      varchar(45) DEFAULT NULL,
-  create_at datetime DEFAULT NULL,
-  update_at datetime DEFAULT NULL,
-  delete_at datetime DEFAULT NULL,
+  create_at datetime(6) DEFAULT NULL,
+  update_at datetime(6) DEFAULT NULL,
+  delete_at datetime(6) DEFAULT NULL,
  PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    `, table)); err != nil {
@ -596,9 +730,9 @@ func Test_SoftDelete_Join(t *testing.T) {
 CREATE TABLE %s (
  id        int(11) NOT NULL,
  name      varchar(45) DEFAULT NULL,
-  create_at datetime DEFAULT NULL,
-  update_at datetime DEFAULT NULL,
-  delete_at datetime DEFAULT NULL,
+  create_at datetime(6) DEFAULT NULL,
+  update_at datetime(6) DEFAULT NULL,
+  delete_at datetime(6) DEFAULT NULL,
  PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    `, table1)); err != nil {
@ -611,9 +745,9 @@ CREATE TABLE %s (
 CREATE TABLE %s (
  id        int(11) NOT NULL,
  name      varchar(45) DEFAULT NULL,
-  createat datetime DEFAULT NULL,
-  updateat datetime DEFAULT NULL,
-  deleteat datetime DEFAULT NULL,
+  createat datetime(6) DEFAULT NULL,
+  updateat datetime(6) DEFAULT NULL,
+  deleteat datetime(6) DEFAULT NULL,
  PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    `, table2)); err != nil {
@ -667,9 +801,9 @@ func Test_SoftDelete_WhereAndOr(t *testing.T) {
 CREATE TABLE %s (
  id        int(11) NOT NULL,
  name      varchar(45) DEFAULT NULL,
-  create_at datetime DEFAULT NULL,
-  update_at datetime DEFAULT NULL,
-  delete_at datetime DEFAULT NULL,
+  create_at datetime(6) DEFAULT NULL,
+  update_at datetime(6) DEFAULT NULL,
+  delete_at datetime(6) DEFAULT NULL,
  PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    `, table)); err != nil {
@ -709,9 +843,9 @@ func Test_CreateUpdateTime_Struct(t *testing.T) {
 CREATE TABLE %s (
  id        int(11) NOT NULL,
  name      varchar(45) DEFAULT NULL,
-  create_at datetime DEFAULT NULL,
-  update_at datetime DEFAULT NULL,
-  delete_at datetime DEFAULT NULL,
+  create_at datetime(6) DEFAULT NULL,
+  update_at datetime(6) DEFAULT NULL,
+  delete_at datetime(6) DEFAULT NULL,
  PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    `, table)); err != nil {
--- a/contrib/drivers/mysql/mysql_issue_test.go
+++ b/contrib/drivers/mysql/mysql_issue_test.go
@ -532,8 +532,8 @@ func Test_Issue2338(t *testing.T) {
 CREATE TABLE %s (
    id        int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'User ID',
    nickname  varchar(45) DEFAULT NULL COMMENT 'User Nickname',
-    create_at datetime DEFAULT NULL COMMENT 'Created Time',
-    update_at datetime DEFAULT NULL COMMENT 'Updated Time',
+    create_at datetime(6) DEFAULT NULL COMMENT 'Created Time',
+    update_at datetime(6) DEFAULT NULL COMMENT 'Updated Time',
    PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 	    `, table1,
@ -544,8 +544,8 @@ CREATE TABLE %s (
 CREATE TABLE %s (
    id        int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'User ID',
    nickname  varchar(45) DEFAULT NULL COMMENT 'User Nickname',
-    create_at datetime DEFAULT NULL COMMENT 'Created Time',
-    update_at datetime DEFAULT NULL COMMENT 'Updated Time',
+    create_at datetime(6) DEFAULT NULL COMMENT 'Created Time',
+    update_at datetime(6) DEFAULT NULL COMMENT 'Updated Time',
    PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 	    `, table2,
@ -585,9 +585,9 @@ CREATE TABLE %s (
 CREATE TABLE %s (
    id        int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'User ID',
    nickname  varchar(45) DEFAULT NULL COMMENT 'User Nickname',
-    create_at datetime DEFAULT NULL COMMENT 'Created Time',
-    update_at datetime DEFAULT NULL COMMENT 'Updated Time',
-    deleted_at datetime DEFAULT NULL COMMENT 'Deleted Time',
+    create_at datetime(6) DEFAULT NULL COMMENT 'Created Time',
+    update_at datetime(6) DEFAULT NULL COMMENT 'Updated Time',
+    deleted_at datetime(6) DEFAULT NULL COMMENT 'Deleted Time',
    PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 	    `, table1,
@ -598,9 +598,9 @@ CREATE TABLE %s (
 CREATE TABLE %s (
    id        int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'User ID',
    nickname  varchar(45) DEFAULT NULL COMMENT 'User Nickname',
-    create_at datetime DEFAULT NULL COMMENT 'Created Time',
-    update_at datetime DEFAULT NULL COMMENT 'Updated Time',
-    deleted_at datetime DEFAULT NULL COMMENT 'Deleted Time',
+    create_at datetime(6) DEFAULT NULL COMMENT 'Created Time',
+    update_at datetime(6) DEFAULT NULL COMMENT 'Updated Time',
+    deleted_at datetime(6) DEFAULT NULL COMMENT 'Deleted Time',
    PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 	    `, table2,
@ -644,8 +644,8 @@ CREATE TABLE %s (
    passport  varchar(45) NOT NULL COMMENT 'User Passport',
    password  varchar(45) NOT NULL COMMENT 'User Password',
    nickname  varchar(45) NOT NULL COMMENT 'User Nickname',
-    create_at datetime DEFAULT NULL COMMENT 'Created Time',
-    update_at datetime DEFAULT NULL COMMENT 'Updated Time',
+    create_at datetime(6) DEFAULT NULL COMMENT 'Created Time',
+    update_at datetime(6) DEFAULT NULL COMMENT 'Updated Time',
    PRIMARY KEY (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 	    `, table,
--- a/contrib/drivers/mysql/mysql_model_test.go
+++ b/contrib/drivers/mysql/mysql_model_test.go
@ -3134,9 +3134,9 @@ func createTableForTimeZoneTest() string {
 	        passport    varchar(45) NULL,
 	        password    char(32) NULL,
 	        nickname    varchar(45) NULL,
-	        created_at timestamp NULL,
- 			updated_at timestamp NULL,
-			deleted_at timestamp NULL,
+	        created_at timestamp(6) NULL,
+ 			updated_at timestamp(6) NULL,
+			deleted_at timestamp(6) NULL,
 	        PRIMARY KEY (id)
 	    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 	    `, tableName,
--- a/contrib/drivers/oracle/go.mod
+++ b/contrib/drivers/oracle/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/drivers/oracle/v2
 go 1.17

 require (
-	github.com/gogf/gf/v2 v2.0.0
+	github.com/gogf/gf/v2 v2.3.3
 	github.com/sijms/go-ora/v2 v2.4.20
 )

--- a/contrib/drivers/pgsql/go.mod
+++ b/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
+	github.com/gogf/gf/v2 v2.3.3
 	github.com/lib/pq v1.10.4
 )

--- a/contrib/drivers/sqlite/go.mod
+++ b/contrib/drivers/sqlite/go.mod
@ -4,7 +4,7 @@ go 1.15

 require (
 	github.com/glebarez/go-sqlite v1.17.3
-	github.com/gogf/gf/v2 v2.0.0
+	github.com/gogf/gf/v2 v2.3.3
 )

 replace github.com/gogf/gf/v2 => ../../../
--- a/contrib/nosql/redis/go.mod
+++ b/contrib/nosql/redis/go.mod
@ -4,7 +4,7 @@ go 1.15

 require (
 	github.com/go-redis/redis/v8 v8.11.5
-	github.com/gogf/gf/v2 v2.0.0
+	github.com/gogf/gf/v2 v2.3.3
 	go.opentelemetry.io/otel v1.7.0
 	go.opentelemetry.io/otel/trace v1.7.0
 )
--- a/contrib/nosql/redis/redis_group_list.go
+++ b/contrib/nosql/redis/redis_group_list.go
@ -118,10 +118,10 @@ func (r GroupList) LPop(ctx context.Context, key string, count ...int) (*gvar.Va
 // depending on the list's length.
 //
 // It returns:
-// - When called without the count argument:
-//   the value of the last element, or nil when key does not exist.
-// - When called with the count argument:
-//   list of popped elements, or nil when key does not exist.
+//   - When called without the count argument:
+//     the value of the last element, or nil when key does not exist.
+//   - When called with the count argument:
+//     list of popped elements, or nil when key does not exist.
 //
 // https://redis.io/commands/rpop
 func (r GroupList) RPop(ctx context.Context, key string, count ...int) (*gvar.Var, error) {
--- a/contrib/nosql/redis/redis_group_set.go
+++ b/contrib/nosql/redis/redis_group_set.go
@ -64,10 +64,10 @@ func (r GroupSet) SIsMember(ctx context.Context, key string, member interface{})
 // argument, the reply will consist of up to count members, depending on the set's cardinality.
 //
 // It returns:
-// - When called without the count argument:
-//   Bulk string reply: the removed member, or nil when key does not exist.
-// - When called with the count argument:
-//   Array reply: the removed members, or an empty array when key does not exist.
+//   - When called without the count argument:
+//     Bulk string reply: the removed member, or nil when key does not exist.
+//   - When called with the count argument:
+//     Array reply: the removed members, or an empty array when key does not exist.
 //
 // https://redis.io/commands/spop/
 func (r GroupSet) SPop(ctx context.Context, key string, count ...int) (*gvar.Var, error) {
@ -86,10 +86,10 @@ func (r GroupSet) SPop(ctx context.Context, key string, count ...int) (*gvar.Var
 // of the specified count.
 //
 // It returns:
-// - Bulk string reply: without the additional count argument, the command returns a Bulk Reply with the
-//   randomly selected element, or nil when key does not exist.
-// - Array reply: when the additional count argument is passed, the command returns an array of elements,
-//   or an empty array when key does not exist.
+//   - Bulk string reply: without the additional count argument, the command returns a Bulk Reply with the
+//     randomly selected element, or nil when key does not exist.
+//   - Array reply: when the additional count argument is passed, the command returns an array of elements,
+//     or an empty array when key does not exist.
 //
 // https://redis.io/commands/srandmember/
 func (r GroupSet) SRandMember(ctx context.Context, key string, count ...int) (*gvar.Var, error) {
@ -212,7 +212,7 @@ func (r GroupSet) SUnion(ctx context.Context, key string, keys ...string) (gvar.

 // SUnionStore is equal to SUnion, but instead of returning the resulting set, it is stored in destination.
 //
-//  If destination already exists, it is overwritten.
+//	If destination already exists, it is overwritten.
 //
 // It returns the number of elements in the resulting set.
 //
--- a/contrib/nosql/redis/redis_group_string.go
+++ b/contrib/nosql/redis/redis_group_string.go
@ -59,8 +59,8 @@ func (r GroupString) SetNX(ctx context.Context, key string, value interface{}) (
 // SetEX sets key to hold the string value and set key to timeout after a given number of seconds.
 // This command is equivalent to executing the following commands:
 //
-//     SET myKey value
-//     EXPIRE myKey seconds
+//	SET myKey value
+//	EXPIRE myKey seconds
 //
 // SetEX is atomic, and can be reproduced by using the previous two commands inside an MULTI / EXEC block.
 // It is provided as a faster alternative to the given sequence of operations, because this operation is very
--- a/contrib/registry/etcd/go.mod
+++ b/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
+	github.com/gogf/gf/v2 v2.3.3
 	go.etcd.io/etcd/client/v3 v3.5.4
 )

--- a/contrib/registry/file/go.mod
+++ b/contrib/registry/file/go.mod
@ -2,6 +2,6 @@ module github.com/gogf/gf/contrib/registry/file/v2

 go 1.15

-require github.com/gogf/gf/v2 v2.0.0
+require github.com/gogf/gf/v2 v2.3.3

 replace github.com/gogf/gf/v2 => ../../../
--- a/contrib/registry/polaris/go.mod
+++ b/contrib/registry/polaris/go.mod
@ -3,8 +3,8 @@ module github.com/gogf/gf/contrib/registry/polaris/v2
 go 1.15

 require (
-	github.com/gogf/gf/v2 v2.0.0
-	github.com/polarismesh/polaris-go v1.2.0-beta.3
+	github.com/gogf/gf/v2 v2.3.3
+	github.com/polarismesh/polaris-go v1.3.0
 )

 replace github.com/gogf/gf/v2 => ../../../
--- a/contrib/registry/polaris/go.sum
+++ b/contrib/registry/polaris/go.sum
@ -227,8 +227,8 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 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/polarismesh/polaris-go v1.2.0-beta.3 h1:sqN50VGign37xVFp9nrN1RoLXacsB0QfRYUtuCWMJGI=
-github.com/polarismesh/polaris-go v1.2.0-beta.3/go.mod h1:HsN0ierETIujHpmnnYJ3qkwQw4QGAECuHvBZTDaw1tI=
+github.com/polarismesh/polaris-go v1.3.0 h1:KZKX//ow4OPPoS5+s7h07ptprg+2AcNVGrN6WakC9QM=
+github.com/polarismesh/polaris-go v1.3.0/go.mod h1:HsN0ierETIujHpmnnYJ3qkwQw4QGAECuHvBZTDaw1tI=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
--- a/contrib/registry/polaris/polaris.go
+++ b/contrib/registry/polaris/polaris.go
@ -10,11 +10,12 @@ package polaris
 import (
 	"time"

+	"github.com/polarismesh/polaris-go"
+	"github.com/polarismesh/polaris-go/pkg/config"
+
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/net/gsvc"
 	"github.com/gogf/gf/v2/os/glog"
-	"github.com/polarismesh/polaris-go"
-	"github.com/polarismesh/polaris-go/pkg/config"
 )

 var (
@ -46,16 +47,19 @@ type options struct {
 	// To show service is healthy or not. Default value is True.
 	Healthy bool

-	// Heartbeat enable .Not in polaris . Default value is True.
+	// Deprecated: Use RegisterInstance instead.
+	// Service registration is performed synchronously,
+	// and heartbeat reporting is automatically performed
+	// Heartbeat enable .Not in polaris. Default value is True.
 	Heartbeat bool

 	// To show service is isolate or not. Default value is False.
 	Isolate bool

-	// TTL timeout. if node needs to use heartbeat to report,required. If not set,server will throw ErrorCode-400141
+	// TTL timeout. if the node needs to use a heartbeat to report, required. If not set,server will throw ErrorCode-400141
 	TTL int

-	// optional, Timeout for single query. Default value is global config
+	// Timeout for the single query. Default value is global config
 	// Total is (1+RetryCount) * Timeout
 	Timeout time.Duration

@ -123,6 +127,7 @@ func WithRetryCount(retryCount int) Option {
 }

 // WithHeartbeat with the Heartbeat option.
+// Deprecated remove in v2.4.0
 func WithHeartbeat(heartbeat bool) Option {
 	return func(o *options) { o.Heartbeat = heartbeat }
 }
--- a/contrib/registry/polaris/polaris_registrar.go
+++ b/contrib/registry/polaris/polaris_registrar.go
@ -10,16 +10,17 @@ import (
 	"context"
 	"time"

+	"github.com/polarismesh/polaris-go"
+	"github.com/polarismesh/polaris-go/pkg/model"
+
 	"github.com/gogf/gf/v2/net/gsvc"
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/polarismesh/polaris-go"
-	"github.com/polarismesh/polaris-go/pkg/model"
 )

 // Register the registration.
 func (r *Registry) Register(ctx context.Context, service gsvc.Service) (gsvc.Service, error) {
-	// Replace input service to custom service type.
+	// Replace input service to custom service types.
 	service = &Service{
 		Service: service,
 	}
@ -47,8 +48,9 @@ func (r *Registry) Register(ctx context.Context, service gsvc.Service) (gsvc.Ser
 				rmd[k] = v
 			}
 		}
-		// Register
-		registeredService, err := r.provider.Register(
+		// Register RegisterInstance Service registration is performed synchronously,
+		// and heartbeat reporting is automatically performed
+		registeredService, err := r.provider.RegisterInstance(
 			&polaris.InstanceRegisterRequest{
 				InstanceRegisterRequest: model.InstanceRegisterRequest{
 					Service:      service.GetPrefix(),
@ -72,7 +74,7 @@ func (r *Registry) Register(ctx context.Context, service gsvc.Service) (gsvc.Ser
 			return nil, err
 		}
 		if r.opt.Heartbeat {
-			r.doHeartBeat(ctx, registeredService.InstanceID, service, endpoint)
+			// r.doHeartBeat(ctx, registeredService.InstanceID, service, endpoint)
 		}
 		ids = append(ids, registeredService.InstanceID)
 	}
@ -83,7 +85,7 @@ func (r *Registry) Register(ctx context.Context, service gsvc.Service) (gsvc.Ser

 // Deregister the registration.
 func (r *Registry) Deregister(ctx context.Context, service gsvc.Service) error {
-	r.c <- struct{}{}
+	// r.c <- struct{}{}
 	var (
 		err   error
 		split = gstr.Split(service.(*Service).ID, instanceIDSeparator)
@ -111,6 +113,7 @@ func (r *Registry) Deregister(ctx context.Context, service gsvc.Service) error {
 	return nil
 }

+// Deprecated .
 func (r *Registry) doHeartBeat(ctx context.Context, instanceID string, service gsvc.Service, endpoint gsvc.Endpoint) {
 	go func() {
 		ticker := time.NewTicker(time.Second * time.Duration(r.opt.TTL))
--- a/contrib/registry/polaris/polaris_service.go
+++ b/contrib/registry/polaris/polaris_service.go
@ -1,3 +1,9 @@
+// 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 polaris

 import (
--- a/contrib/registry/zookeeper/go.mod
+++ b/contrib/registry/zookeeper/go.mod
@ -4,7 +4,7 @@ go 1.15

 require (
 	github.com/go-zookeeper/zk v1.0.3
-	github.com/gogf/gf/v2 v2.2.2
+	github.com/gogf/gf/v2 v2.3.3
 	golang.org/x/sync v0.1.0
 )

--- a/contrib/rpc/grpcx/go.mod
+++ b/contrib/rpc/grpcx/go.mod
@ -3,8 +3,8 @@ module github.com/gogf/gf/contrib/rpc/grpcx/v2
 go 1.15

 require (
-	github.com/gogf/gf/contrib/registry/file/v2 v2.0.0-20230223141509-94b2eae1bec0
-	github.com/gogf/gf/v2 v2.0.0
+	github.com/gogf/gf/contrib/registry/file/v2 v2.3.3
+	github.com/gogf/gf/v2 v2.3.3
 	go.opentelemetry.io/otel v1.10.0
 	go.opentelemetry.io/otel/trace v1.10.0
 	golang.org/x/net v0.0.0-20220919232410-f2f64ebce3c1 // indirect
--- a/contrib/rpc/grpcx/grpcx_grpc_server.go
+++ b/contrib/rpc/grpcx/grpcx_grpc_server.go
@ -75,10 +75,11 @@ func (s modServer) New(conf ...*GrpcServerConfig) *GrpcServer {
 	}
 	grpcServer.config.Options = append([]grpc.ServerOption{
 		s.ChainUnary(
-			s.UnaryRecover,
 			s.UnaryTracing,
-			s.UnaryError,
 			grpcServer.UnaryLogger,
+			s.UnaryRecover,
+			s.UnaryAllowNilRes,
+			s.UnaryError,
 		),
 		s.ChainStream(
 			s.StreamTracing,
@ -222,6 +223,11 @@ func (s *GrpcServer) Stop() {
 	s.Server.GracefulStop()
 }

+// GetConfig returns the configuration of current Server.
+func (s *GrpcServer) GetConfig() *GrpcServerConfig {
+	return s.config
+}
+
 // GetListenedAddress retrieves and returns the address string which are listened by current server.
 func (s *GrpcServer) GetListenedAddress() string {
 	if !gstr.Contains(s.config.Address, FreePortAddress) {
--- a/contrib/rpc/grpcx/grpcx_interceptor_server.go
+++ b/contrib/rpc/grpcx/grpcx_interceptor_server.go
@ -8,6 +8,7 @@ package grpcx

 import (
 	"context"
+	"google.golang.org/protobuf/proto"

 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
@ -76,6 +77,16 @@ func (s modServer) UnaryValidate(
 	return handler(ctx, req)
 }

+func (s modServer) UnaryAllowNilRes(
+	ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler,
+) (interface{}, error) {
+	res, err := handler(ctx, req)
+	if g.IsNil(res) {
+		res = proto.Message(nil)
+	}
+	return res, err
+}
+
 // UnaryTracing is a unary interceptor for adding tracing feature for gRPC server using OpenTelemetry.
 func (s modServer) UnaryTracing(
 	ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler,
--- a/contrib/rpc/grpcx/grpcx_registry_file.go
+++ b/contrib/rpc/grpcx/grpcx_registry_file.go
@ -13,8 +13,6 @@ import (
 	"github.com/gogf/gf/v2/net/gsvc"
 	"github.com/gogf/gf/v2/os/gctx"
 	"github.com/gogf/gf/v2/os/gfile"
-
-	"github.com/gogf/gf/contrib/rpc/grpcx/v2/internal/resolver"
 )

 // autoLoadAndRegisterFileRegistry checks and registers ETCD service as default service registry
@ -30,5 +28,5 @@ func autoLoadAndRegisterFileRegistry() {
 	)

 	g.Log().Debug(ctx, `set default registry using file registry as no custom registry set`)
-	resolver.SetRegistry(fileRegistry)
+	Resolver.Register(fileRegistry)
 }
--- a/contrib/rpc/grpcx/internal/resolver/resolver.go
+++ b/contrib/rpc/grpcx/internal/resolver/resolver.go
@ -25,8 +25,8 @@ func init() {
 	resolver.Register(NewBuilder(gsvc.GetRegistry()))
 }

-// SetRegistry sets the default Registry implements as your own implemented interface.
-func SetRegistry(registry gsvc.Registry) {
+// Register sets the default Registry implements as your own implemented interface.
+func Register(registry gsvc.Registry) {
 	if registry == nil {
 		panic(gerror.New(`invalid Registry value "nil" given`))
 	}
--- a/contrib/rpc/grpcx/internal/resolver/resolver_manager.go
+++ b/contrib/rpc/grpcx/internal/resolver/resolver_manager.go
@ -15,6 +15,12 @@ import (
 // Manager for Builder creating.
 type Manager struct{}

+// New creates and returns a Builder.
 func (m Manager) New(discovery gsvc.Discovery) resolver.Builder {
 	return NewBuilder(discovery)
 }
+
+// Register sets the default Registry implements as your own implemented interface.
+func (m Manager) Register(registry gsvc.Registry) {
+	Register(registry)
+}
--- a/contrib/trace/jaeger/go.mod
+++ b/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
+	github.com/gogf/gf/v2 v2.3.3
 	go.opentelemetry.io/otel v1.7.0
 	go.opentelemetry.io/otel/exporters/jaeger v1.7.0
 	go.opentelemetry.io/otel/sdk v1.7.0
--- a/database/gdb/gdb_model_builder.go
+++ b/database/gdb/gdb_model_builder.go
@ -25,7 +25,7 @@ type WhereHolder struct {
 	Prefix   string        // Field prefix, eg: "user.", "order.".
 }

-// Builder creates and returns a WhereBuilder.
+// Builder creates and returns a WhereBuilder. Please note that the builder is chain-safe.
 func (m *Model) Builder() *WhereBuilder {
 	b := &WhereBuilder{
 		model:       m,
@ -34,8 +34,7 @@ func (m *Model) Builder() *WhereBuilder {
 	return b
 }

-// getBuilder creates and returns a cloned WhereBuilder of current WhereBuilder if `safe` is true,
-// or else it returns the current WhereBuilder.
+// getBuilder creates and returns a cloned WhereBuilder of current WhereBuilder
 func (b *WhereBuilder) getBuilder() *WhereBuilder {
 	return b.Clone()
 }
--- a/database/gdb/gdb_model_delete.go
+++ b/database/gdb/gdb_model_delete.go
@ -63,7 +63,7 @@ func (m *Model) Delete(where ...interface{}) (result sql.Result, err error) {
 			Table:     m.tables,
 			Data:      fmt.Sprintf(`%s=?`, m.db.GetCore().QuoteString(fieldNameDelete)),
 			Condition: conditionStr,
-			Args:      append([]interface{}{gtime.Now().String()}, conditionArgs...),
+			Args:      append([]interface{}{gtime.Now()}, conditionArgs...),
 		}
 		return in.Next(ctx)
 	}
--- a/database/gdb/gdb_model_insert.go
+++ b/database/gdb/gdb_model_insert.go
@ -254,7 +254,7 @@ func (m *Model) doInsertWithOption(ctx context.Context, insertOption int) (resul
 	}
 	var (
 		list            List
-		nowString       = gtime.Now().String()
+		now             = gtime.Now()
 		fieldNameCreate = m.getSoftFieldNameCreated("", m.tablesInit)
 		fieldNameUpdate = m.getSoftFieldNameUpdated("", m.tablesInit)
 	)
@ -338,10 +338,10 @@ func (m *Model) doInsertWithOption(ctx context.Context, insertOption int) (resul
 	if !m.unscoped && (fieldNameCreate != "" || fieldNameUpdate != "") {
 		for k, v := range list {
 			if fieldNameCreate != "" {
-				v[fieldNameCreate] = nowString
+				v[fieldNameCreate] = now
 			}
 			if fieldNameUpdate != "" {
-				v[fieldNameUpdate] = nowString
+				v[fieldNameUpdate] = now
 			}
 			list[k] = v
 		}
--- a/database/gdb/gdb_model_update.go
+++ b/database/gdb/gdb_model_update.go
@ -64,7 +64,7 @@ func (m *Model) Update(dataAndWhere ...interface{}) (result sql.Result, err erro
 		}
 		// Automatically update the record updating time.
 		if fieldNameUpdate != "" {
-			dataMap[fieldNameUpdate] = gtime.Now().String()
+			dataMap[fieldNameUpdate] = gtime.Now()
 		}
 		updateData = dataMap

@ -73,7 +73,8 @@ func (m *Model) Update(dataAndWhere ...interface{}) (result sql.Result, err erro
 		// Automatically update the record updating time.
 		if fieldNameUpdate != "" {
 			if fieldNameUpdate != "" && !gstr.Contains(updates, fieldNameUpdate) {
-				updates += fmt.Sprintf(`,%s='%s'`, fieldNameUpdate, gtime.Now().String())
+				updates += fmt.Sprintf(`,%s=?`, fieldNameUpdate)
+				conditionArgs = append([]interface{}{gtime.Now()}, conditionArgs...)
 			}
 		}
 		updateData = updates
--- a/encoding/gjson/gjson_z_example_test.go
+++ b/encoding/gjson/gjson_z_example_test.go
@ -796,11 +796,11 @@ func ExampleJson_Interfaces() {
 	}

 	infoList := []BaseInfo{
-		BaseInfo{
+		{
 			Name: "John",
 			Age:  18,
 		},
-		BaseInfo{
+		{
 			Name: "Tom",
 			Age:  20,
 		},
--- a/example/balancer/http/client/client.go
+++ b/example/balancer/http/client/client.go
@ -1,9 +1,6 @@
 package main

 import (
-	"fmt"
-	"time"
-
 	"github.com/gogf/gf/contrib/registry/etcd/v2"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/net/gsel"
@ -15,14 +12,9 @@ func main() {
 	gsvc.SetRegistry(etcd.New(`127.0.0.1:2379`))
 	gsel.SetBuilder(gsel.NewBuilderRoundRobin())

-	client := g.Client()
-	for i := 0; i < 100; i++ {
-		res, err := client.Get(gctx.New(), `http://hello.svc/`)
-		if err != nil {
-			panic(err)
-		}
-		fmt.Println(res.ReadAllString())
-		res.Close()
-		time.Sleep(time.Second)
+	for i := 0; i < 10; i++ {
+		ctx := gctx.New()
+		res := g.Client().GetContent(ctx, `http://hello.svc/`)
+		g.Log().Info(ctx, res)
 	}
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
John Guo	5bbec48679	v2.4.0-rc2 (#2575 )	2023-04-12 21:14:03 +08:00
John Guo	d4b9ee4c61	version updates to v2.4.0-rc (#2574 ) version updates	2023-04-12 20:24:20 +08:00
刘志铭	50b5cd50bc	fix issue in New when creating concurrent-safety var for package gvar (#2573 )	2023-04-12 17:38:06 +08:00
John Guo	53afbd0f05	uf case update for contrib/drivers/mysql (#2569 )	2023-04-12 15:36:44 +08:00
star liu	b6874eb66d	update cli build action (#2563 )	2023-04-12 11:54:15 +08:00
John Guo	7ff7de4643	inherit context from http.Request for ghttp.Request (#2550 )	2023-04-12 11:54:06 +08:00
John Guo	5f148632d2	fix missing trace id in gctx.GetInitCtx (#2562 )	2023-04-12 10:35:24 +08:00
wsy998	c1325ef9a3	Add Filter function to garray (#2541 )	2023-04-12 10:15:11 +08:00
John Guo	d788b7ff5e	fix issue #2529 #2487 (#2548 )	2023-04-12 10:14:14 +08:00
alaywn	66d0663dc5	add `clickhouse` support in command `gf gen dao` (#2557 )	2023-04-12 10:14:04 +08:00
John Guo	a56524ee05	add `RemoveValues` for package `garray` (#2568 ) add RemoveValues for package garray	2023-04-12 10:12:28 +08:00
John Guo	1aa9f2809e	improve stream response for http (#2564 )	2023-04-12 10:12:11 +08:00
HaiLaz	261672e84c	feat: automatic update gf for contrib (#2551 )	2023-04-11 21:13:29 +08:00
John Guo	6a4e39e815	change temp dir to os.TempDir for package gfile (#2547 )	2023-03-29 11:58:20 +08:00
dependabot[bot]	4af9ce8a81	Bump golang.org/x/crypto from 0.0.0-20200622213623-75b288015ac9 to 0.1.0 in /cmd/gf (#2546 )	2023-03-28 20:03:07 +08:00
HaiLaz	5f146720fe	fix: unified go.mod dependent version (#2452 )	2023-03-28 09:25:29 +08:00
忆灬凝	67e6772d88	comment updates for gdb.Builder (#2513 )	2023-03-28 09:23:08 +08:00
John Guo	12e9febe9e	fix issue #2516 (#2531 ) * fix issue #2516 * golang ci configuration updates * add example for default value of http request	2023-03-22 20:14:57 +08:00
John Guo	676022eeb6	fix issue #2509 (#2530 )	2023-03-21 22:10:41 +08:00
XG	3a8fc1e70d	optimize the handling of the `SIGUSR1` signal (#2532 ) optimize the handling of the SIGUSR1 signal	2023-03-21 21:26:49 +08:00
hinego	0b6798acb5	add `Quick` mode for gtimer (#2488 )	2023-03-20 10:00:55 +08:00
Wesley Wu	e721124b6c	support microseconds resolution for created_at/updated_at/deleted_at (#2512 )	2023-03-20 09:57:37 +08:00
houseme	b32eb30212	feat: improve polaris register and upgrade polaris-go version v1.3.0 (#2524 )	2023-03-20 09:52:58 +08:00
houseme	967a39ecbe	feat:upgrade polairs-go sdk version v1.3.0 for config (#2525 ) feat:upgrade polairs-go sdk version v1.3.0	2023-03-20 09:52:19 +08:00
John Guo	dfb7f5abfb	improve error message when the router hander definition is not standrad (#2528 )	2023-03-20 09:51:43 +08:00
HaiLaz	56f5d5125b	fix quick exit when double click cli to install/upgrade (#2521 )	2023-03-17 17:56:41 +08:00
HaiLaz	5083174a92	fix goreport for gofmt (#2523 )	2023-03-17 17:54:14 +08:00
John Guo	4a278dfd79	improve grpcx (#2522 )	2023-03-17 17:51:10 +08:00
旺旺碎冰冰	80d57ed8f9	add postForm with multi data content type support (#2508 )	2023-03-14 09:57:22 +08:00
John Guo	b742e222d6	improve command `gen pb` by adding controller go files generating (#2518 )	2023-03-14 09:47:42 +08:00
John Guo	ae86f66545	fix issue #2499 #2515 (#2517 )	2023-03-13 22:16:57 +08:00
HaiLaz	45e4c9e16c	add tag value of `in` support for api definition that has meta info (#2450 )	2023-03-13 19:29:30 +08:00
XG	8c07f1a42c	feat: support graceful shutdown (#2469 ) (#2475 )	2023-03-13 19:21:56 +08:00
Sany	e6c97410ef	fix: cli gen service:BUG #2310 (#2485 )	2023-03-13 19:17:23 +08:00
John Guo	b1a55c7a32	improvement for grpcx (#2510 )	2023-03-13 18:56:19 +08:00