diff --git a/.github/workflows/ci-main.yml b/.github/workflows/ci-main.yml
index 42f9700f4..d3840dd43 100644
--- a/.github/workflows/ci-main.yml
+++ b/.github/workflows/ci-main.yml
@@ -20,6 +20,13 @@ on:
     - feature/**
     - enhance/**
     - fix/**
+  workflow_dispatch:
+    inputs:
+      debug:
+        type: boolean
+        description: 'Enable tmate Debug'
+        required: false
+        default: false
 
 # This allows a subsequently queued workflow run to interrupt previous runs
 concurrency:
@@ -47,7 +54,7 @@ jobs:
     # Service containers to run with `code-test`
     services:
       # Etcd service.
-      # docker run -d --name etcd -p 2379:2379 -e ALLOW_NONE_AUTHENTICATION=yes bitnamilegacy/etcd:3.4.24
+      # docker run -p 2379:2379 -e ALLOW_NONE_AUTHENTICATION=yes bitnamilegacy/etcd:3.4.24
       etcd:
         image: bitnamilegacy/etcd:3.4.24
         env:
@@ -68,7 +75,7 @@ jobs:
           - 6379:6379
 
       # MySQL backend server.
-      # docker run -d --name mysql \
+      # docker run \
       # -p 3306:3306 \
       # -e MYSQL_DATABASE=test \
       # -e MYSQL_ROOT_PASSWORD=12345678 \
@@ -82,7 +89,7 @@ jobs:
           - 3306:3306
 
       # MariaDb backend server.
-      # docker run -d --name mariadb \
+      # docker run \
       # -p 3307:3306 \
       # -e MYSQL_DATABASE=test \
       # -e MYSQL_ROOT_PASSWORD=12345678 \
@@ -96,7 +103,7 @@ jobs:
           - 3307:3306
 
       # PostgreSQL backend server.
-      # docker run -d --name postgres \
+      # docker run \
       # -p 5432:5432 \
       # -e POSTGRES_PASSWORD=12345678 \
       # -e POSTGRES_USER=postgres \
@@ -143,7 +150,7 @@ jobs:
           --health-retries 10
 
       # ClickHouse backend server.
-      # docker run -d --name clickhouse \
+      # docker run \
       # -p 9000:9000 -p 8123:8123 -p 9001:9001 \
       # clickhouse/clickhouse-server:24.11.1.2557-alpine
       clickhouse-server:
@@ -154,7 +161,7 @@ jobs:
           - 9001:9001
 
       # Polaris backend server.
-      # docker run -d --name polaris \
+      # docker run \
       # -p 8090:8090 -p 8091:8091 -p 8093:8093 -p 9090:9090 -p 9091:9091 \
       # polarismesh/polaris-standalone:v1.17.2
       polaris:
@@ -191,6 +198,17 @@ jobs:
         ports:
           - 5236:5236
 
+      # openGauss server
+      # docker run --privileged=true -e GS_PASSWORD=UTpass@1234 -p 9950:5432 opengauss/opengauss:7.0.0-RC1.B023
+      gaussdb:
+        image: opengauss/opengauss:7.0.0-RC1.B023
+        env:
+          GS_PASSWORD: UTpass@1234
+          TZ: Asia/Shanghai
+        ports:
+          - 9950:5432
+
+
       zookeeper:
         image: zookeeper:3.8
         ports:
@@ -207,6 +225,19 @@ jobs:
     - name: Checkout Repository
       uses: actions/checkout@v5
 
+    - name: Setup tmate Session
+      uses: mxschmitt/action-tmate@v3
+      if: ${{ github.event_name == 'workflow_dispatch' && inputs.debug }}
+      with:
+        detached: true
+        limit-access-to-actor: false
+
+    - name: Free Disk Space
+      run: |
+        df -h /
+        sudo rm -rf /usr/share/dotnet /usr/local/lib/android /opt/hostedtoolcache/CodeQL /opt/hostedtoolcache/Python || true
+        df -h /
+
     - name: Start Apollo Containers
       run:  docker compose -f ".github/workflows/apollo/docker-compose.yml" up -d --build
       
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
index 000000000..ca0781379
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,100 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL Advanced"
+
+on:
+  push:
+    branches: [ "master", "develop" ]
+  pull_request:
+    branches: [ "master", "develop" ]
+  schedule:
+    - cron: '0 21 * * *'
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners (GitHub.com only)
+    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # required to fetch internal or private CodeQL packs
+      packages: read
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - language: actions
+          build-mode: none
+        - language: go
+          build-mode: autobuild
+        # CodeQL supports the following values keywords for 'language': 'actions', 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'rust', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Add any setup steps before running the `github/codeql-action/init` action.
+    # This includes steps like installing compilers or runtimes (`actions/setup-node`
+    # or others). This is typically only required for manual builds.
+    # - name: Setup runtime (example)
+    #   uses: actions/setup-example@v1
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        build-mode: ${{ matrix.build-mode }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+    # If the analyze step fails for one of the languages you are analyzing with
+    # "We were unable to automatically build your code", modify the matrix above
+    # to set the build mode to "manual" for that language. Then modify this step
+    # to build your code.
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+    - if: matrix.build-mode == 'manual'
+      shell: bash
+      run: |
+        echo 'If you are using a "manual" build mode for one or more of the' \
+          'languages you are analyzing, replace this with the commands to build' \
+          'your code, for example:'
+        echo '  make bootstrap'
+        echo '  make release'
+        exit 1
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:${{matrix.language}}"
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index c384cb143..fdf1234ff 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -17,11 +17,12 @@ jobs:
     steps:
       - name: Checkout Github Code
         uses: actions/checkout@v5
-      
+
       - name: Set Up Golang Environment
         uses: actions/setup-go@v5
         with:
           go-version: 1.25
+          cache: false
       
       - name: Build CLI Binary
         run: |
@@ -34,7 +35,7 @@ jobs:
       - name: Build CLI Binary For All Platform
         run: |
           cd cmd/gf
-          gf build main.go -n gf -a all -s all -p temp
+          gf build main.go -n gf -a all -s linux,windows,darwin,freebsd,netbsd,openbsd -p temp
 
       - name: Move Files Before Release
         run: |
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
new file mode 100644
index 000000000..23dd94ee8
--- /dev/null
+++ b/.github/workflows/scorecard.yml
@@ -0,0 +1,80 @@
+# This workflow uses actions that are not certified by GitHub. They are provided
+# by a third-party and are governed by separate terms of service, privacy
+# policy, and support documentation.
+
+name: Scorecard supply-chain security
+on:
+  # For Branch-Protection check. Only the default branch is supported. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
+  branch_protection_rule:
+  # To guarantee Maintained check is occasionally updated. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained
+  schedule:
+    - cron: '0 21 * * *'
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+# Declare default permissions as read only.
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    # `publish_results: true` only works when run from the default branch. conditional can be removed if disabled.
+    if: github.event.repository.default_branch == github.ref_name || github.event_name == 'pull_request'
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      # Needed to publish results and get a badge (see publish_results below).
+      id-token: write
+      # Uncomment the permissions below if installing in a private repository.
+      # contents: read
+      # actions: read
+
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@v4.2.2
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@v2.4.1
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # (Optional) "write" PAT token. Uncomment the `repo_token` line below if:
+          # - you want to enable the Branch-Protection check on a *public* repository, or
+          # - you are installing Scorecard on a *private* repository
+          # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action?tab=readme-ov-file#authentication-with-fine-grained-pat-optional.
+          # repo_token: ${{ secrets.SCORECARD_TOKEN }}
+
+          # Public repositories:
+          #   - Publish results to OpenSSF REST API for easy access by consumers
+          #   - Allows the repository to include the Scorecard badge.
+          #   - See https://github.com/ossf/scorecard-action#publishing-results.
+          # For private repositories:
+          #   - `publish_results` will always be set to `false`, regardless
+          #     of the value entered here.
+          publish_results: true
+
+          # (Optional) Uncomment file_mode if you have a .gitattributes with files marked export-ignore
+          # file_mode: git
+
+      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
+      # format to the repository Actions tab.
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@v4.6.1
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # Upload the results to GitHub's code scanning dashboard (optional).
+      # Commenting out will disable upload of results to your repo's Code Scanning dashboard
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: results.sarif
diff --git a/.github/workflows/scripts/before_script.sh b/.github/workflows/scripts/before_script.sh
old mode 100644
new mode 100755
diff --git a/.github/workflows/scripts/ci-main-clean.sh b/.github/workflows/scripts/ci-main-clean.sh
new file mode 100755
index 000000000..b47eba4e8
--- /dev/null
+++ b/.github/workflows/scripts/ci-main-clean.sh
@@ -0,0 +1,250 @@
+#!/usr/bin/env bash
+
+dirpath=$1
+
+# Extract the base directory name for pattern matching
+if [ -n "$dirpath" ]; then
+    dirname=$(basename "$dirpath")
+    echo "Cleaning Docker resources for path: $dirpath (pattern: $dirname)"
+    df -h /
+    
+    # Process containers and images based on the directory
+    case "$dirname" in
+        # "mysql")
+        #     echo "Cleaning mysql resources..."
+        #     containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+        #     if [ -n "$containers" ]; then
+        #         echo "Stopping and removing mysql containers..."
+        #         docker stop $containers 2>/dev/null || true
+        #         docker rm -f $containers 2>/dev/null || true
+        #     fi
+        #     docker rmi -f $(docker images -q mysql 2>/dev/null) 2>/dev/null || true
+        #     ;;
+        "mssql")
+            echo "Cleaning mssql resources..."
+            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+            if [ -n "$containers" ]; then
+                echo "Stopping and removing mssql containers..."
+                docker stop $containers 2>/dev/null || true
+                docker rm -f $containers 2>/dev/null || true
+            fi
+            docker rmi -f $(docker images -q mcr.microsoft.com/mssql/server 2>/dev/null) 2>/dev/null || true
+        ;;
+        "pgsql")
+            echo "Cleaning postgres resources..."
+            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+            if [ -n "$containers" ]; then
+                echo "Stopping and removing postgres containers..."
+                docker stop $containers 2>/dev/null || true
+                docker rm -f $containers 2>/dev/null || true
+            fi
+            docker rmi -f $(docker images -q postgres 2>/dev/null) 2>/dev/null || true
+        ;;
+        "oracle")
+            echo "Cleaning oracle resources..."
+            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+            if [ -n "$containers" ]; then
+                echo "Stopping and removing oracle containers..."
+                docker stop $containers 2>/dev/null || true
+                docker rm -f $containers 2>/dev/null || true
+            fi
+            docker rmi -f $(docker images -q loads/oracle-xe-11g-r2 2>/dev/null) 2>/dev/null || true
+        ;;
+        "dm")
+            echo "Cleaning dm resources..."
+            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+            if [ -n "$containers" ]; then
+                echo "Stopping and removing dm containers..."
+                docker stop $containers 2>/dev/null || true
+                docker rm -f $containers 2>/dev/null || true
+            fi
+            docker rmi -f $(docker images -q loads/dm 2>/dev/null) 2>/dev/null || true
+        ;;
+        "clickhouse")
+            echo "Cleaning clickhouse resources..."
+            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+            if [ -n "$containers" ]; then
+                echo "Stopping and removing clickhouse containers..."
+                docker stop $containers 2>/dev/null || true
+                docker rm -f $containers 2>/dev/null || true
+            fi
+            docker rmi -f $(docker images -q clickhouse/clickhouse-server 2>/dev/null) 2>/dev/null || true
+        ;;
+        # "redis")
+        #     echo "Cleaning redis resources..."
+        #     containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+        #     if [ -n "$containers" ]; then
+        #         echo "Stopping and removing redis containers..."
+        #         docker stop $containers 2>/dev/null || true
+        #         docker rm -f $containers 2>/dev/null || true
+        #     fi
+        #     docker rmi -f $(docker images -q redis loads/redis loads/redis-sentinel 2>/dev/null) 2>/dev/null || true
+        #     ;;
+        "etcd")
+            echo "Cleaning etcd resources..."
+            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+            if [ -n "$containers" ]; then
+                echo "Stopping and removing etcd containers..."
+                docker stop $containers 2>/dev/null || true
+                docker rm -f $containers 2>/dev/null || true
+            fi
+            docker rmi -f $(docker images -q bitnamilegacy/etcd 2>/dev/null) 2>/dev/null || true
+        ;;
+        # "consul")
+        #     echo "Cleaning consul resources..."
+        #     containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+        #     if [ -n "$containers" ]; then
+        #         echo "Stopping and removing consul containers..."
+        #         docker stop $containers 2>/dev/null || true
+        #         docker rm -f $containers 2>/dev/null || true
+        #     fi
+        #     docker rmi -f $(docker images -q consul 2>/dev/null) 2>/dev/null || true
+        #     ;;
+        # "nacos")
+        #     echo "Cleaning nacos resources..."
+        #     containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+        #     if [ -n "$containers" ]; then
+        #         echo "Stopping and removing nacos containers..."
+        #         docker stop $containers 2>/dev/null || true
+        #         docker rm -f $containers 2>/dev/null || true
+        #     fi
+        #     docker rmi -f $(docker images -q nacos/nacos-server 2>/dev/null) 2>/dev/null || true
+        #     ;;
+        # "polaris")
+        #     echo "Cleaning polaris resources..."
+        #     containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+        #     if [ -n "$containers" ]; then
+        #         echo "Stopping and removing polaris containers..."
+        #         docker stop $containers 2>/dev/null || true
+        #         docker rm -f $containers 2>/dev/null || true
+        #     fi
+        #     docker rmi -f $(docker images -q polarismesh/polaris-standalone 2>/dev/null) 2>/dev/null || true
+        #     ;;
+        "zookeeper")
+            echo "Cleaning zookeeper resources..."
+            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+            if [ -n "$containers" ]; then
+                echo "Stopping and removing zookeeper containers..."
+                docker stop $containers 2>/dev/null || true
+                docker rm -f $containers 2>/dev/null || true
+            fi
+            docker rmi -f $(docker images -q zookeeper 2>/dev/null) 2>/dev/null || true
+        ;;
+        # "apollo")
+        #     echo "Cleaning apollo resources..."
+        #     containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
+        #     if [ -n "$containers" ]; then
+        #         echo "Stopping and removing apollo containers..."
+        #         docker stop $containers 2>/dev/null || true
+        #         docker rm -f $containers 2>/dev/null || true
+        #     fi
+        #     docker rmi -f $(docker images -q loads/apollo-quick-start 2>/dev/null) 2>/dev/null || true
+        #     ;;
+        *)
+            # No matching pattern, skip cleanup
+            echo "No specific Docker cleanup rule for '$dirname', skipping cleanup"
+        ;;
+    esac
+    
+    # Remove dangling images and volumes to free up space
+    echo "Removing dangling images and unused volumes..."
+    docker image prune -f 2>/dev/null || true
+    docker volume prune -f 2>/dev/null || true
+    
+    echo "Docker cleanup completed for $dirname"
+    docker system df
+    df -h /
+fi
+
+# df -h /
+# Filesystem      Size  Used Avail Use% Mounted on
+# /dev/root        72G   67G  5.4G  93% /
+# tmpfs           7.9G   84K  7.9G   1% /dev/shm
+# tmpfs           3.2G  2.6M  3.2G   1% /run
+# tmpfs           5.0M     0  5.0M   0% /run/lock
+# /dev/sdb16      881M   62M  758M   8% /boot
+# /dev/sdb15      105M  6.2M   99M   6% /boot/efi
+# /dev/sda1        74G  4.1G   66G   6% /mnt
+# tmpfs           1.6G   12K  1.6G   1% /run/user/1001
+
+# runner@runnervmg1sw1:~/work/gf/gf$ docker system df
+# TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
+# Images          18        11        8.326GB   1.644GB (19%)
+# Containers      11        11        2.692GB   0B (0%)
+# Local Volumes   11        8         665.7MB   211.9MB (31%)
+# Build Cache     0         0         0B        0B
+
+# runner@runnervmg1sw1:~/work/gf/gf$ docker images
+# REPOSITORY                       TAG                               IMAGE ID       CREATED         SIZE
+# alpine/curl                      latest                            99fd43792a61   2 days ago      13.5MB
+# postgres                         17-alpine                         b6bf692a8125   9 days ago      278MB
+# zookeeper                        3.8                               2f26c02b94ca   10 days ago     306MB
+# mariadb                          11.4                              063fb6684f96   10 days ago     332MB
+# mcr.microsoft.com/mssql/server   2022-latest                       a2fbff321505   4 weeks ago     1.61GB
+# clickhouse/clickhouse-server     24.11.1.2557-alpine               2eee9fd3ae74   12 months ago   539MB
+# redis                            7.0                               7705dd2858c1   18 months ago   109MB
+# consul                           1.15                              686495461132   20 months ago   155MB
+# mysql                            5.7                               5107333e08a8   23 months ago   501MB
+# polarismesh/polaris-standalone   v1.17.2                           b7a8cf0a8438   2 years ago     545MB
+# bitnamilegacy/etcd               3.4.24                            74ae5e205ac5   2 years ago     134MB
+# nacos/nacos-server               v2.1.2                            a978644d9246   2 years ago     1.06GB
+# loads/redis                      7.0-sentinel                      6f12d40540ba   3 years ago     114MB
+# loads/dm                         v8.1.2.128_ent_x86_64_ctm_pack4   ccb727ce9dce   3 years ago     432MB
+# loads/redis-sentinel             7.0                               6818c626f5ca   3 years ago     104MB
+# loads/apollo-quick-start         latest                            8490de672148   3 years ago     190MB
+# alpine                           3.8                               c8bccc0af957   5 years ago     4.41MB
+# loads/oracle-xe-11g-r2           11.2.0                            0d19fd2e072e   6 years ago     2.1GB
+
+# runner@runnervmg1sw1:~/work/gf/gf$ docker ps -s
+# CONTAINER ID   IMAGE                                              COMMAND                  CREATED         STATUS                   PORTS                                                                                                                                                                                                                         NAMES                                                                               SIZE
+# 8214f83420c6   zookeeper:3.8                                      "/docker-entrypoint.…"   6 minutes ago   Up 6 minutes             2888/tcp, 3888/tcp, 0.0.0.0:2181->2181/tcp, [::]:2181->2181/tcp, 8080/tcp                                                                                                                                                     d66bac92ae9646f688f70ed4b5176f14_zookeeper38_3a22ef                                 33kB (virtual 306MB)
+# 8938d73842e8   loads/dm:v8.1.2.128_ent_x86_64_ctm_pack4           "/bin/bash /opt/star…"   6 minutes ago   Up 6 minutes             0.0.0.0:5236->5236/tcp, [::]:5236->5236/tcp                                                                                                                                                                                   ca280fbdb86f40c2acf86d7d526c6285_loadsdmv812128_ent_x86_64_ctm_pack4_770a59         844MB (virtual 1.28GB)
+# 0d3a653fe1f2   loads/oracle-xe-11g-r2:11.2.0                      "/bin/sh -c '/usr/sb…"   6 minutes ago   Up 6 minutes             22/tcp, 8080/tcp, 0.0.0.0:1521->1521/tcp, [::]:1521->1521/tcp                                                                                                                                                                 2048856d428c4967b1c35193eb8c9192_loadsoraclexe11gr21120_295d54                      1.3GB (virtual 3.4GB)
+# ca3936189166   polarismesh/polaris-standalone:v1.17.2             "/bin/bash run.sh"       6 minutes ago   Up 6 minutes             0.0.0.0:8090-8091->8090-8091/tcp, [::]:8090-8091->8090-8091/tcp, 8080/tcp, 8100-8101/tcp, 0.0.0.0:8093->8093/tcp, [::]:8093->8093/tcp, 8761/tcp, 15010/tcp, 0.0.0.0:9090-9091->9090-9091/tcp, [::]:9090-9091->9090-9091/tcp   cbd43dceef754e2d8aab507e33167be7_polarismeshpolarisstandalonev1172_ca40b6           299MB (virtual 844MB)
+# 26169dad485e   clickhouse/clickhouse-server:24.11.1.2557-alpine   "/entrypoint.sh"         6 minutes ago   Up 6 minutes             0.0.0.0:8123->8123/tcp, [::]:8123->8123/tcp, 0.0.0.0:9000-9001->9000-9001/tcp, [::]:9000-9001->9000-9001/tcp, 9009/tcp                                                                                                        f1c7766fbe36401792a6f735d7acf123_clickhouseclickhouseserver241112557alpine_cfc034   338kB (virtual 539MB)
+# 04689a1d581f   mcr.microsoft.com/mssql/server:2022-latest         "/opt/mssql/bin/laun…"   6 minutes ago   Up 6 minutes (healthy)   0.0.0.0:1433->1433/tcp, [::]:1433->1433/tcp                                                                                                                                                                                   41d685349a7640b28230db8d0f60efe7_mcrmicrosoftcommssqlserver2022latest_fe29fb        108MB (virtual 1.72GB)
+# d5fbc5f811af   postgres:17-alpine                                 "docker-entrypoint.s…"   6 minutes ago   Up 6 minutes (healthy)   0.0.0.0:5432->5432/tcp, [::]:5432->5432/tcp                                                                                                                                                                                   2783be71b5ce417ab9a31428e7b4d8f2_postgres17alpine_c60840                            63B (virtual 278MB)
+# da96a7ad7a01   mariadb:11.4                                       "docker-entrypoint.s…"   7 minutes ago   Up 7 minutes             0.0.0.0:3307->3306/tcp, [::]:3307->3306/tcp                                                                                                                                                                                   45eed646fa6c4a698893ee11cda95a4c_mariadb114_3a9cd6                                  2B (virtual 332MB)
+# 27ba1904ba3a   mysql:5.7                                          "docker-entrypoint.s…"   7 minutes ago   Up 7 minutes             0.0.0.0:3306->3306/tcp, [::]:3306->3306/tcp, 33060/tcp                                                                                                                                                                        ea6d7a4c207d427a95b5ae0db91fdf56_mysql57_c21053                                     4B (virtual 501MB)
+# 518e785d1bb6   redis:7.0                                          "docker-entrypoint.s…"   7 minutes ago   Up 7 minutes (healthy)   0.0.0.0:6379->6379/tcp, [::]:6379->6379/tcp                                                                                                                                                                                   af6044fc849e441bbc6c48f7a5ec5fec_redis70_b11994                                     0B (virtual 109MB)
+# 7495ec2cd8e3   bitnamilegacy/etcd:3.4.24                          "/opt/bitnami/script…"   7 minutes ago   Up 7 minutes             0.0.0.0:2379->2379/tcp, [::]:2379->2379/tcp, 2380/tcp                                                                                                                                                                         49f2a2a6bf3a4fae842cc950bbc3658a_bitnamilegacyetcd3424_1265e1                       145MB (virtual 279MB)
+
+# runner@runnervmg1sw1:~/work/gf/gf$ du -ah --max-depth=1 /usr | sort -n
+# 4.0K    /usr/games
+# 4.0K    /usr/lib64
+# 6.6G    /usr/lib
+# 9.3G    /usr/share
+# 15M     /usr/lib32
+# 24G     /usr/local
+# 41G     /usr
+# 95M     /usr/sbin
+# 156M    /usr/include
+# 158M    /usr/src
+# 402M    /usr/libexec
+# 841M    /usr/bin
+
+# runner@runnervmg1sw1:~/work/gf/gf$ du -ah --max-depth=1 /opt | sort -n                                                                        
+# 4.0K    /opt/pipx_bin
+# 5.8G    /opt/hostedtoolcache
+# 8.5G    /opt
+# 12K     /opt/containerd
+# 14M     /opt/hca
+# 16K     /opt/post-generation
+# 217M    /opt/runner-cache
+# 243M    /opt/actionarchivecache
+# 374M    /opt/google
+# 515M    /opt/pipx
+# 655M    /opt/az
+# 783M    /opt/microsoft
+
+# runner@runnervmg1sw1:~/work/gf/gf$ du -ah --max-depth=1 /opt/hostedtoolcache/ | sort -n
+# 1.1G    /opt/hostedtoolcache/go
+# 1.6G    /opt/hostedtoolcache/CodeQL
+# 1.9G    /opt/hostedtoolcache/Python
+# 5.8G    /opt/hostedtoolcache/
+# 9.9M    /opt/hostedtoolcache/protoc
+# 24K     /opt/hostedtoolcache/Java_Temurin-Hotspot_jdk
+# 217M    /opt/hostedtoolcache/Ruby
+# 520M    /opt/hostedtoolcache/PyPy
+# 574M    /opt/hostedtoolcache/node
+
diff --git a/.github/workflows/scripts/ci-main.sh b/.github/workflows/scripts/ci-main.sh
old mode 100644
new mode 100755
index 3f3d27a66..45407d071
--- a/.github/workflows/scripts/ci-main.sh
+++ b/.github/workflows/scripts/ci-main.sh
@@ -2,65 +2,58 @@
 
 coverage=$1
 
-# update code of submodules
-git clone https://github.com/gogf/examples
-
-# update go.mod in examples directory to replace github.com/gogf/gf packages with local directory
-bash .github/workflows/scripts/replace_examples_gomod.sh
-
 # find all path that contains go.mod.
 for file in `find . -name go.mod`; do
     dirpath=$(dirname $file)
     echo $dirpath
-
-    # ignore mssql tests as its docker service failed
-    # TODO remove this ignoring codes after the mssql docker service OK
-    if [ "mssql" = $(basename $dirpath) ]; then
-        continue 1
-    fi
-
+    
     # package kubecm was moved to sub ci procedure.
     if [ "kubecm" = $(basename $dirpath) ]; then
         continue 1
     fi
-
-    # Check if it's a contrib directory or examples directory
-    if [[ $dirpath =~ "/contrib/" ]] || [[ $dirpath =~ "/examples/" ]]; then
-        # Check if go version meets the requirement
-        if ! go version | grep -qE "go${LATEST_GO_VERSION}"; then
-            echo "ignore path $dirpath as go version is not ${LATEST_GO_VERSION}: $(go version)"
-            continue 1
-        fi
-        # If it's examples directory, only build without tests
-        if [[ $dirpath =~ "/examples/" ]]; then
-            echo "the examples directory only needs to be built, not unit tests and coverage tests."
-            cd $dirpath
-            go mod tidy
-            go build ./...
-            cd -
-            continue 1
-        fi
+    
+    # examples directory was moved to sub ci procedure.
+    if [[ $dirpath =~ "/examples/" ]]; then
+        continue 1
     fi
-
+    
     if [[ $file =~ "/testdata/" ]]; then
         echo "ignore testdata path $file"
         continue 1
     fi
-
+    
+    # Check if it's a contrib directory
+    if [[ $dirpath =~ "/contrib/" ]]; then
+        # Check if go version meets the requirement
+        if ! go version | grep -qE "go${LATEST_GO_VERSION}"; then
+            echo "ignore path $dirpath as go version is not ${LATEST_GO_VERSION}: $(go version)"
+            # clean docker containers and images to free disk space
+            # bash .github/workflows/scripts/ci-main-clean.sh "$dirpath"
+            continue 1
+        fi
+    fi
+    
+    # if [[ $dirpath = "." ]]; then
+    #     # No space left on device error sometimes occurs in CI pipelines, so clean the cache before tests.
+    #     go clean -cache
+    # fi
+    
     cd $dirpath
     go mod tidy
     go build ./...
-
+    
     # test with coverage
     if [ "${coverage}" = "coverage" ]; then
-      go test ./... -race -coverprofile=coverage.out -covermode=atomic -coverpkg=./...,github.com/gogf/gf/... || exit 1
-
-      if grep -q "/gogf/gf/.*/v2" go.mod; then
-        sed -i "s/gogf\/gf\(\/.*\)\/v2/gogf\/gf\/v2\1/g" coverage.out
-      fi
+        go test ./... -count=1 -race -coverprofile=coverage.out -covermode=atomic -coverpkg=./...,github.com/gogf/gf/... || exit 1
+        
+        if grep -q "/gogf/gf/.*/v2" go.mod; then
+            sed -i "s/gogf\/gf\(\/.*\)\/v2/gogf\/gf\/v2\1/g" coverage.out
+        fi
     else
-      go test ./... -race || exit 1
+        go test ./... -count=1 -race || exit 1
     fi
-
+    
     cd -
+    # clean docker containers and images to free disk space
+    # bash .github/workflows/scripts/ci-main-clean.sh "$dirpath"
 done
diff --git a/.github/workflows/scripts/ci-sub.sh b/.github/workflows/scripts/ci-sub.sh
old mode 100644
new mode 100755
index 70e1f13b5..9683b355e
--- a/.github/workflows/scripts/ci-sub.sh
+++ b/.github/workflows/scripts/ci-sub.sh
@@ -2,6 +2,12 @@
 
 coverage=$1
 
+# update code of submodules
+git clone https://github.com/gogf/examples
+
+# update go.mod in examples directory to replace github.com/gogf/gf packages with local directory
+bash .github/workflows/scripts/replace_examples_gomod.sh
+
 # Function to compare version numbers
 version_compare() {
     local ver1=$1
@@ -35,7 +41,19 @@ for file in `find . -name go.mod`; do
     dirpath=$(dirname $file)
     echo "Processing: $dirpath"
 
-    # Only process kubecm directory, skip others
+    # Only process examples and kubecm directories  
+
+    # Process examples directory (only build, no tests)
+    if [[ $dirpath =~ "/examples/" ]]; then
+        echo "  the examples directory only needs to be built, not unit tests."
+        cd $dirpath
+        go mod tidy
+        go build ./...
+        cd -
+        continue 1
+    fi
+    
+    # Process kubecm directory
     if [ "kubecm" != $(basename $dirpath) ]; then
         echo "  Skipping: not kubecm directory"
         continue
diff --git a/.github/workflows/scripts/docker-services.sh b/.github/workflows/scripts/docker-services.sh
new file mode 100755
index 000000000..1ffbe13c2
--- /dev/null
+++ b/.github/workflows/scripts/docker-services.sh
@@ -0,0 +1,785 @@
+#!/usr/bin/env bash
+#
+# GoFrame Docker Services Manager
+# For managing Docker services used in local development and testing
+#
+
+set -e
+
+# Container name prefix
+PREFIX="goframe"
+
+# Color definitions
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+# Service definitions
+declare -A SERVICES
+declare -A SERVICE_PORTS
+declare -A SERVICE_ENVS
+declare -A SERVICE_OPTS
+
+# Basic services
+SERVICES["etcd"]="bitnamilegacy/etcd:3.4.24"
+SERVICE_PORTS["etcd"]="2379:2379"
+SERVICE_ENVS["etcd"]="-e ALLOW_NONE_AUTHENTICATION=yes"
+
+SERVICES["redis"]="redis:7.0"
+SERVICE_PORTS["redis"]="6379:6379"
+SERVICE_OPTS["redis"]="--health-cmd 'redis-cli ping' --health-interval 10s --health-timeout 5s --health-retries 5"
+
+SERVICES["mysql"]="mysql:5.7"
+SERVICE_PORTS["mysql"]="3306:3306"
+SERVICE_ENVS["mysql"]="-e MYSQL_DATABASE=test -e MYSQL_ROOT_PASSWORD=12345678"
+
+SERVICES["mariadb"]="mariadb:11.4"
+SERVICE_PORTS["mariadb"]="3307:3306"
+SERVICE_ENVS["mariadb"]="-e MARIADB_DATABASE=test -e MARIADB_ROOT_PASSWORD=12345678"
+
+SERVICES["postgres"]="postgres:17-alpine"
+SERVICE_PORTS["postgres"]="5432:5432"
+SERVICE_ENVS["postgres"]="-e POSTGRES_PASSWORD=12345678 -e POSTGRES_USER=postgres -e POSTGRES_DB=test -e TZ=Asia/Shanghai"
+SERVICE_OPTS["postgres"]="--health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5"
+
+SERVICES["mssql"]="mcr.microsoft.com/mssql/server:2022-latest"
+SERVICE_PORTS["mssql"]="1433:1433"
+SERVICE_ENVS["mssql"]="-e TZ=Asia/Shanghai -e ACCEPT_EULA=Y -e MSSQL_SA_PASSWORD=LoremIpsum86"
+
+SERVICES["clickhouse"]="clickhouse/clickhouse-server:24.11.1.2557-alpine"
+SERVICE_PORTS["clickhouse"]="9000:9000 -p 8123:8123 -p 9001:9001"
+
+SERVICES["polaris"]="polarismesh/polaris-standalone:v1.17.2"
+SERVICE_PORTS["polaris"]="8090:8090 -p 8091:8091 -p 8093:8093 -p 9090:9090 -p 9091:9091"
+
+SERVICES["oracle"]="loads/oracle-xe-11g-r2:11.2.0"
+SERVICE_PORTS["oracle"]="1521:1521"
+SERVICE_ENVS["oracle"]="-e ORACLE_ALLOW_REMOTE=true -e ORACLE_SID=XE -e ORACLE_DB_USER_NAME=system -e ORACLE_DB_PASSWORD=oracle"
+
+SERVICES["dm"]="loads/dm:v8.1.2.128_ent_x86_64_ctm_pack4"
+SERVICE_PORTS["dm"]="5236:5236"
+
+SERVICES["gaussdb"]="opengauss/opengauss:7.0.0-RC1.B023"
+SERVICE_PORTS["gaussdb"]="9950:5432"
+SERVICE_ENVS["gaussdb"]="-e GS_PASSWORD=UTpass@1234 -e TZ=Asia/Shanghai"
+SERVICE_OPTS["gaussdb"]="--privileged=true"
+
+SERVICES["zookeeper"]="zookeeper:3.8"
+SERVICE_PORTS["zookeeper"]="2181:2181"
+
+# Service groups
+GROUP_DB="mysql mariadb postgres mssql oracle dm gaussdb clickhouse"
+GROUP_CACHE="redis etcd"
+GROUP_REGISTRY="polaris zookeeper"
+GROUP_ALL="etcd redis mysql mariadb postgres mssql clickhouse polaris oracle dm gaussdb zookeeper"
+
+# Working directories
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+WORKFLOW_DIR="$PROJECT_ROOT/.github/workflows"
+
+# Print colored messages
+print_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[OK]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Check if Docker is available
+check_docker() {
+    if ! command -v docker &> /dev/null; then
+        print_error "Docker is not installed or not in PATH"
+        exit 1
+    fi
+    if ! docker info &> /dev/null; then
+        print_error "Docker service is not running"
+        exit 1
+    fi
+}
+
+# Get container name
+get_container_name() {
+    echo "${PREFIX}-$1"
+}
+
+# Start a single service
+start_service() {
+    local service=$1
+    local container_name=$(get_container_name "$service")
+    local image="${SERVICES[$service]}"
+    local ports="${SERVICE_PORTS[$service]}"
+    local envs="${SERVICE_ENVS[$service]}"
+    local opts="${SERVICE_OPTS[$service]}"
+
+    if [ -z "$image" ]; then
+        print_error "Unknown service: $service"
+        return 1
+    fi
+
+    # Check if container already exists
+    if docker ps -a --format '{{.Names}}' | grep -q "^${container_name}$"; then
+        if docker ps --format '{{.Names}}' | grep -q "^${container_name}$"; then
+            print_warning "$service is already running"
+            return 0
+        else
+            print_info "Starting existing container $service..."
+            docker start "$container_name" > /dev/null
+            print_success "$service started"
+            return 0
+        fi
+    fi
+
+    print_info "Starting $service..."
+    
+    # Build docker run command
+    local cmd="docker run -d --name $container_name"
+    
+    # Add port mappings
+    for port in $ports; do
+        cmd="$cmd -p $port"
+    done
+    
+    # Add environment variables
+    if [ -n "$envs" ]; then
+        cmd="$cmd $envs"
+    fi
+    
+    # Add other options
+    if [ -n "$opts" ]; then
+        cmd="$cmd $opts"
+    fi
+    
+    cmd="$cmd $image"
+    
+    if eval "$cmd" > /dev/null 2>&1; then
+        print_success "$service started (container: $container_name)"
+    else
+        print_error "Failed to start $service"
+        return 1
+    fi
+}
+
+# Stop a single service
+stop_service() {
+    local service=$1
+    local container_name=$(get_container_name "$service")
+
+    if docker ps --format '{{.Names}}' | grep -q "^${container_name}$"; then
+        print_info "Stopping $service..."
+        docker stop "$container_name" > /dev/null
+        print_success "$service stopped"
+    else
+        print_warning "$service is not running"
+    fi
+}
+
+# Remove a single service
+remove_service() {
+    local service=$1
+    local container_name=$(get_container_name "$service")
+
+    if docker ps -a --format '{{.Names}}' | grep -q "^${container_name}$"; then
+        print_info "Removing $service..."
+        docker rm -f "$container_name" > /dev/null
+        print_success "$service removed"
+    else
+        print_warning "$service container does not exist"
+    fi
+}
+
+# View service logs
+logs_service() {
+    local service=$1
+    local container_name=$(get_container_name "$service")
+    local lines=${2:-100}
+
+    if docker ps -a --format '{{.Names}}' | grep -q "^${container_name}$"; then
+        docker logs --tail "$lines" -f "$container_name"
+    else
+        print_error "$service container does not exist"
+        return 1
+    fi
+}
+
+# Start docker-compose service
+start_compose_service() {
+    local service=$1
+    local compose_file=""
+    
+    case $service in
+        apollo)
+            compose_file="$WORKFLOW_DIR/apollo/docker-compose.yml"
+            ;;
+        nacos)
+            compose_file="$WORKFLOW_DIR/nacos/docker-compose.yml"
+            ;;
+        redis-cluster)
+            compose_file="$WORKFLOW_DIR/redis/docker-compose.yml"
+            ;;
+        consul)
+            compose_file="$WORKFLOW_DIR/consul/docker-compose.yml"
+            ;;
+        *)
+            print_error "Unknown compose service: $service"
+            return 1
+            ;;
+    esac
+    
+    if [ -f "$compose_file" ]; then
+        print_info "Starting $service (docker-compose)..."
+        docker compose -f "$compose_file" up -d
+        print_success "$service started"
+    else
+        print_error "Compose file does not exist: $compose_file"
+        return 1
+    fi
+}
+
+# Stop docker-compose service
+stop_compose_service() {
+    local service=$1
+    local compose_file=""
+    
+    case $service in
+        apollo)
+            compose_file="$WORKFLOW_DIR/apollo/docker-compose.yml"
+            ;;
+        nacos)
+            compose_file="$WORKFLOW_DIR/nacos/docker-compose.yml"
+            ;;
+        redis-cluster)
+            compose_file="$WORKFLOW_DIR/redis/docker-compose.yml"
+            ;;
+        consul)
+            compose_file="$WORKFLOW_DIR/consul/docker-compose.yml"
+            ;;
+        *)
+            print_error "Unknown compose service: $service"
+            return 1
+            ;;
+    esac
+    
+    if [ -f "$compose_file" ]; then
+        print_info "Stopping $service (docker-compose)..."
+        docker compose -f "$compose_file" down
+        print_success "$service stopped"
+    else
+        print_error "Compose file does not exist: $compose_file"
+        return 1
+    fi
+}
+
+# Show service status
+show_status() {
+    echo ""
+    echo -e "${CYAN}========== GoFrame Docker Services Status ==========${NC}"
+    echo ""
+    printf "%-15s %-12s %-30s %s\n" "SERVICE" "STATUS" "CONTAINER" "PORTS"
+    echo "--------------------------------------------------------------------------------"
+    
+    for service in $GROUP_ALL; do
+        local container_name=$(get_container_name "$service")
+        local status="stopped"
+        local ports="-"
+        
+        if docker ps --format '{{.Names}}' 2>/dev/null | grep -q "^${container_name}$"; then
+            status="${GREEN}running${NC}"
+            ports=$(docker port "$container_name" 2>/dev/null | tr '\n' ' ' || echo "-")
+        elif docker ps -a --format '{{.Names}}' 2>/dev/null | grep -q "^${container_name}$"; then
+            status="${YELLOW}stopped${NC}"
+        else
+            status="${RED}not created${NC}"
+        fi
+        
+        printf "%-15s %-22b %-30s %s\n" "$service" "$status" "$container_name" "$ports"
+    done
+    
+    echo ""
+    echo -e "${CYAN}========== Compose Services ==========${NC}"
+    echo ""
+    
+    for compose_svc in apollo nacos redis-cluster consul; do
+        local running=0
+        case $compose_svc in
+            apollo)
+                running=$(docker ps --filter "name=apollo" --format '{{.Names}}' 2>/dev/null | wc -l)
+                ;;
+            nacos)
+                running=$(docker ps --filter "name=nacos" --format '{{.Names}}' 2>/dev/null | wc -l)
+                ;;
+            redis-cluster)
+                running=$(docker ps --filter "name=redis-" --format '{{.Names}}' 2>/dev/null | wc -l)
+                ;;
+            consul)
+                running=$(docker ps --filter "name=consul" --format '{{.Names}}' 2>/dev/null | wc -l)
+                ;;
+        esac
+        
+        if [ "$running" -gt 0 ]; then
+            printf "%-15s ${GREEN}running${NC} (%d containers)\n" "$compose_svc" "$running"
+        else
+            printf "%-15s ${RED}stopped${NC}\n" "$compose_svc"
+        fi
+    done
+    
+    echo ""
+}
+
+# Show service information
+show_service_info() {
+    echo ""
+    echo -e "${CYAN}========== Available Services ==========${NC}"
+    echo ""
+    echo -e "${YELLOW}Basic Services (standalone containers):${NC}"
+    echo ""
+    printf "%-15s %-50s %s\n" "SERVICE" "IMAGE" "PORTS"
+    echo "--------------------------------------------------------------------------------"
+    
+    for service in $GROUP_ALL; do
+        printf "%-15s %-50s %s\n" "$service" "${SERVICES[$service]}" "${SERVICE_PORTS[$service]}"
+    done
+    
+    echo ""
+    echo -e "${YELLOW}Compose Services (multi-container):${NC}"
+    echo "  apollo        - Apollo Config Center (8080, 8070, 8060, 13306)"
+    echo "  nacos         - Nacos Registry (8848, 9848, 9555)"
+    echo "  redis-cluster - Redis Primary-Replica + Sentinel Cluster (6380-6382, 26379-26381)"
+    echo "  consul        - Consul Service Discovery (8500, 8600)"
+    echo ""
+    echo -e "${YELLOW}Service Groups:${NC}"
+    echo "  db       - Databases: $GROUP_DB"
+    echo "  cache    - Cache: $GROUP_CACHE"
+    echo "  registry - Registry: $GROUP_REGISTRY"
+    echo "  all      - All basic services"
+    echo ""
+}
+
+# Show help
+show_help() {
+    echo ""
+    echo -e "${CYAN}GoFrame Docker Services Manager${NC}"
+    echo ""
+    echo "Usage: $0 <command> [service|group] [options]"
+    echo ""
+    echo "Commands:"
+    echo "  start <service|group>    Start service or service group"
+    echo "  stop <service|group>     Stop service or service group"
+    echo "  restart <service|group>  Restart service or service group"
+    echo "  remove <service|group>   Remove service container"
+    echo "  logs <service> [lines]   View service logs (default 100 lines)"
+    echo "  status                   Show all service status"
+    echo "  info                     Show available service information"
+    echo "  clean                    Remove all goframe containers"
+    echo "  pull [service]           Pull images"
+    echo ""
+    echo "Services:"
+    echo "  Basic: etcd, redis, mysql, mariadb, postgres, mssql,"
+    echo "         clickhouse, polaris, oracle, dm, gaussdb, zookeeper"
+    echo "  Compose: apollo, nacos, redis-cluster, consul"
+    echo ""
+    echo "Service Groups:"
+    echo "  db       - All database services"
+    echo "  cache    - Cache services (redis, etcd)"
+    echo "  registry - Registry services (polaris, zookeeper)"
+    echo "  all      - All basic services"
+    echo ""
+    echo "Examples:"
+    echo "  $0 start mysql           # Start MySQL"
+    echo "  $0 start db              # Start all databases"
+    echo "  $0 start all             # Start all basic services"
+    echo "  $0 start apollo          # Start Apollo (compose)"
+    echo "  $0 stop all              # Stop all basic services"
+    echo "  $0 logs mysql 50         # View last 50 lines of MySQL logs"
+    echo "  $0 status                # View service status"
+    echo ""
+}
+
+# Parse service groups
+parse_services() {
+    local input=$1
+    case $input in
+        db)
+            echo "$GROUP_DB"
+            ;;
+        cache)
+            echo "$GROUP_CACHE"
+            ;;
+        registry)
+            echo "$GROUP_REGISTRY"
+            ;;
+        all)
+            echo "$GROUP_ALL"
+            ;;
+        *)
+            echo "$input"
+            ;;
+    esac
+}
+
+# Check if it's a compose service
+is_compose_service() {
+    local service=$1
+    case $service in
+        apollo|nacos|redis-cluster|consul)
+            return 0
+            ;;
+        *)
+            return 1
+            ;;
+    esac
+}
+
+# Pull images
+pull_images() {
+    local services=$1
+    
+    if [ -z "$services" ]; then
+        services="$GROUP_ALL"
+    fi
+    
+    for service in $services; do
+        if [ -n "${SERVICES[$service]}" ]; then
+            print_info "Pulling image: ${SERVICES[$service]}"
+            docker pull "${SERVICES[$service]}"
+        fi
+    done
+}
+
+# Clean all goframe containers
+clean_all() {
+    print_info "Removing all $PREFIX containers..."
+    local containers=$(docker ps -a --filter "name=$PREFIX" --format '{{.Names}}')
+    
+    if [ -n "$containers" ]; then
+        for container in $containers; do
+            docker rm -f "$container" > /dev/null
+            print_success "Removed: $container"
+        done
+    else
+        print_info "No $PREFIX containers found"
+    fi
+}
+
+# Get service status mark
+get_service_status_mark() {
+    local service=$1
+    local container_name=$(get_container_name "$service")
+    
+    if docker ps --format '{{.Names}}' 2>/dev/null | grep -q "^${container_name}$"; then
+        echo -e "${GREEN}*${NC}"
+    else
+        echo " "
+    fi
+}
+
+# Get compose service status mark
+get_compose_status_mark() {
+    local service=$1
+    local running=0
+    
+    case $service in
+        apollo)
+            running=$(docker ps --filter "name=apollo" --format '{{.Names}}' 2>/dev/null | wc -l)
+            ;;
+        nacos)
+            running=$(docker ps --filter "name=nacos" --format '{{.Names}}' 2>/dev/null | wc -l)
+            ;;
+        redis-cluster)
+            running=$(docker ps --filter "name=redis-" --format '{{.Names}}' 2>/dev/null | wc -l)
+            ;;
+        consul)
+            running=$(docker ps --filter "name=consul" --format '{{.Names}}' 2>/dev/null | wc -l)
+            ;;
+    esac
+    
+    if [ "$running" -gt 0 ]; then
+        echo -e "${GREEN}*${NC}"
+    else
+        echo " "
+    fi
+}
+
+# Service selection menu
+select_service_menu() {
+    local action=$1
+    local action_name=$2
+    
+    echo ""
+    echo -e "${CYAN}========== Select Service to ${action_name} ==========${NC}"
+    
+    # Show running status for stop/restart/logs operations
+    if [[ "$action" == "stop" || "$action" == "restart" || "$action" == "logs" ]]; then
+        echo -e "  (${GREEN}*${NC} indicates running)"
+    fi
+    echo ""
+    echo -e "${YELLOW}Basic Services:${NC}"
+    printf "  %b1) etcd         %b2) redis        %b3) mysql\n" \
+        "$(get_service_status_mark etcd)" "$(get_service_status_mark redis)" "$(get_service_status_mark mysql)"
+    printf "  %b4) mariadb      %b5) postgres     %b6) mssql\n" \
+        "$(get_service_status_mark mariadb)" "$(get_service_status_mark postgres)" "$(get_service_status_mark mssql)"
+    printf "  %b7) clickhouse   %b8) polaris      %b9) oracle\n" \
+        "$(get_service_status_mark clickhouse)" "$(get_service_status_mark polaris)" "$(get_service_status_mark oracle)"
+    printf " %b10) dm          %b11) gaussdb     %b12) zookeeper\n" \
+        "$(get_service_status_mark dm)" "$(get_service_status_mark gaussdb)" "$(get_service_status_mark zookeeper)"
+    echo ""
+    echo -e "${YELLOW}Compose Services:${NC}"
+    printf " %b13) apollo      %b14) nacos       %b15) redis-cluster\n" \
+        "$(get_compose_status_mark apollo)" "$(get_compose_status_mark nacos)" "$(get_compose_status_mark redis-cluster)"
+    printf " %b16) consul\n" "$(get_compose_status_mark consul)"
+    echo ""
+    echo -e "${YELLOW}Service Groups:${NC}"
+    echo "  17) db (all databases)    18) cache (cache services)"
+    echo "  19) registry (registry services) 20) all (all basic services)"
+    echo ""
+    echo "   0) Back to main menu"
+    echo ""
+    read -p "Select [0-20]: " svc_choice
+    
+    local svc=""
+    case $svc_choice in
+        1) svc="etcd" ;;
+        2) svc="redis" ;;
+        3) svc="mysql" ;;
+        4) svc="mariadb" ;;
+        5) svc="postgres" ;;
+        6) svc="mssql" ;;
+        7) svc="clickhouse" ;;
+        8) svc="polaris" ;;
+        9) svc="oracle" ;;
+        10) svc="dm" ;;
+        11) svc="gaussdb" ;;
+        12) svc="zookeeper" ;;
+        13) svc="apollo" ;;
+        14) svc="nacos" ;;
+        15) svc="redis-cluster" ;;
+        16) svc="consul" ;;
+        17) svc="db" ;;
+        18) svc="cache" ;;
+        19) svc="registry" ;;
+        20) svc="all" ;;
+        0) return ;;
+        *)
+            print_error "Invalid selection"
+            return
+            ;;
+    esac
+    
+    case $action in
+        start)
+            if is_compose_service "$svc"; then
+                start_compose_service "$svc"
+            else
+                for s in $(parse_services "$svc"); do
+                    start_service "$s"
+                done
+            fi
+            ;;
+        stop)
+            if is_compose_service "$svc"; then
+                stop_compose_service "$svc"
+            else
+                for s in $(parse_services "$svc"); do
+                    stop_service "$s"
+                done
+            fi
+            ;;
+        restart)
+            if is_compose_service "$svc"; then
+                stop_compose_service "$svc"
+                start_compose_service "$svc"
+            else
+                for s in $(parse_services "$svc"); do
+                    stop_service "$s"
+                    start_service "$s"
+                done
+            fi
+            ;;
+        remove)
+            for s in $(parse_services "$svc"); do
+                remove_service "$s"
+            done
+            ;;
+        logs)
+            if is_compose_service "$svc"; then
+                print_error "For Compose services, please use 'docker compose logs'"
+            else
+                read -p "Number of lines (default 100): " lines
+                lines=${lines:-100}
+                logs_service "$svc" "$lines"
+            fi
+            ;;
+        pull)
+            pull_images "$(parse_services "$svc")"
+            ;;
+    esac
+}
+
+# Interactive menu
+interactive_menu() {
+    while true; do
+        echo ""
+        echo -e "${CYAN}========== GoFrame Docker Services Manager ==========${NC}"
+        echo ""
+        echo "  1) Start Service"
+        echo "  2) Stop Service"
+        echo "  3) Restart Service"
+        echo "  4) Remove Service"
+        echo "  5) View Logs"
+        echo "  6) View Status"
+        echo "  7) Service Info"
+        echo "  8) Clean All Containers"
+        echo "  9) Pull Images"
+        echo "  0) Exit"
+        echo ""
+        read -p "Select operation [0-9]: " choice
+        
+        case $choice in
+            1)
+                select_service_menu "start" "Start"
+                ;;
+            2)
+                select_service_menu "stop" "Stop"
+                ;;
+            3)
+                select_service_menu "restart" "Restart"
+                ;;
+            4)
+                select_service_menu "remove" "Remove"
+                ;;
+            5)
+                select_service_menu "logs" "View Logs"
+                ;;
+            6)
+                show_status
+                ;;
+            7)
+                show_service_info
+                ;;
+            8)
+                read -p "Confirm removing all goframe containers? [y/N]: " confirm
+                if [[ "$confirm" =~ ^[Yy]$ ]]; then
+                    clean_all
+                fi
+                ;;
+            9)
+                select_service_menu "pull" "Pull Images"
+                ;;
+            0)
+                echo "Goodbye!"
+                exit 0
+                ;;
+            *)
+                print_error "Invalid selection"
+                ;;
+        esac
+    done
+}
+
+# Main function
+main() {
+    check_docker
+    
+    if [ $# -eq 0 ]; then
+        interactive_menu
+        exit 0
+    fi
+    
+    local command=$1
+    local target=$2
+    local extra=$3
+    
+    case $command in
+        start)
+            if [ -z "$target" ]; then
+                print_error "Please specify service name or service group"
+                exit 1
+            fi
+            if is_compose_service "$target"; then
+                start_compose_service "$target"
+            else
+                for service in $(parse_services "$target"); do
+                    start_service "$service"
+                done
+            fi
+            ;;
+        stop)
+            if [ -z "$target" ]; then
+                print_error "Please specify service name or service group"
+                exit 1
+            fi
+            if is_compose_service "$target"; then
+                stop_compose_service "$target"
+            else
+                for service in $(parse_services "$target"); do
+                    stop_service "$service"
+                done
+            fi
+            ;;
+        restart)
+            if [ -z "$target" ]; then
+                print_error "Please specify service name or service group"
+                exit 1
+            fi
+            if is_compose_service "$target"; then
+                stop_compose_service "$target"
+                start_compose_service "$target"
+            else
+                for service in $(parse_services "$target"); do
+                    stop_service "$service"
+                    start_service "$service"
+                done
+            fi
+            ;;
+        remove|rm)
+            if [ -z "$target" ]; then
+                print_error "Please specify service name or service group"
+                exit 1
+            fi
+            for service in $(parse_services "$target"); do
+                remove_service "$service"
+            done
+            ;;
+        logs)
+            if [ -z "$target" ]; then
+                print_error "Please specify service name"
+                exit 1
+            fi
+            logs_service "$target" "${extra:-100}"
+            ;;
+        status|ps)
+            show_status
+            ;;
+        info|list)
+            show_service_info
+            ;;
+        clean)
+            clean_all
+            ;;
+        pull)
+            pull_images "$target"
+            ;;
+        help|--help|-h)
+            show_help
+            ;;
+        *)
+            print_error "Unknown command: $command"
+            show_help
+            exit 1
+            ;;
+    esac
+}
+
+main "$@"
diff --git a/.github/workflows/sonarcloud.yaml b/.github/workflows/sonarcloud.yaml
deleted file mode 100644
index d88af5109..000000000
--- a/.github/workflows/sonarcloud.yaml
+++ /dev/null
@@ -1,53 +0,0 @@
-name: Sonarcloud Scan
-
-on:
-  schedule:
-    # Weekly on Saturdays.
-    - cron: '30 1 * * 6'
-  push:
-    branches: [ master ]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-# Declare default permissions as read only.
-permissions: read
-
-jobs:
-  analysis:
-    name: Scorecards analysis
-    runs-on: ubuntu-latest
-    permissions:
-      # Needed to upload the results to code-scanning dashboard.
-      security-events: write
-      # Used to receive a badge. (Upcoming feature)
-      id-token: write
-      # Needs for private repositories.
-      contents: read
-      actions: read
-
-    steps:
-      - name: "Checkout code"
-        uses: actions/checkout@v5
-        with:
-          persist-credentials: false
-
-      - name: "Run analysis"
-        uses: ossf/scorecard-action@v2.4.0 # v2.4.0
-        with:
-          results_file: results.sarif
-          results_format: sarif
-          publish_results: true
-
-      - name: "Upload artifact"
-        uses: actions/upload-artifact@v4
-        with:
-          name: SARIF file
-          path: results.sarif
-          retention-days: 5
-
-      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@3ebbd71c74ef574dbc558c82f70e52732c8b44fe # v2.2.1
-        with:
-          sarif_file: results.sarif
diff --git a/.gitignore b/.gitignore
index 964d5fdd0..be381afce 100644
--- a/.gitignore
+++ b/.gitignore
@@ -24,4 +24,5 @@ node_modules
 .docusaurus
 output
 .example/
-.golangci.bck.yml
\ No newline at end of file
+.golangci.bck.yml
+*.exe
\ No newline at end of file
diff --git a/.gitmodules b/.gitmodules
index 895782dad..e69de29bb 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +0,0 @@
-[submodule "examples"]
-	path = examples
-	url = git@github.com:gogf/examples.git
diff --git a/.make_tidy.sh b/.make_tidy.sh
index e14d2dd85..62ac53009 100755
--- a/.make_tidy.sh
+++ b/.make_tidy.sh
@@ -26,6 +26,8 @@ for file in `find ${workdir} -name go.mod`; do
     fi
 
     cd $goModPath
+    # Remove indirect dependencies
+    sed -i '/\/\/ indirect/d' go.mod
     go mod tidy
     # Remove toolchain line if exists
     sed -i '' '/^toolchain/d' go.mod
diff --git a/.make_version.sh b/.make_version.sh
index 14e314d0e..4d759fb2a 100755
--- a/.make_version.sh
+++ b/.make_version.sh
@@ -80,6 +80,8 @@ for file in `find ${workdir} -name go.mod`; do
         go mod edit -replace github.com/gogf/gf/contrib/drivers/pgsql/v2=../../contrib/drivers/pgsql
         go mod edit -replace github.com/gogf/gf/contrib/drivers/sqlite/v2=../../contrib/drivers/sqlite
     fi
+    # Remove indirect dependencies
+    sed -i '/\/\/ indirect/d' go.mod
     go mod tidy
     # Remove toolchain line if exists
     $SED_INPLACE '/^toolchain/d' go.mod
@@ -88,6 +90,8 @@ for file in `find ${workdir} -name go.mod`; do
     # it may not be possible to successfully upgrade. Please confirm before submitting the code
     go list -f "{{if and (not .Indirect) (not .Main)}}{{.Path}}@${newVersion}{{end}}" -m all | grep "^github.com/gogf/gf"
     go list -f "{{if and (not .Indirect) (not .Main)}}{{.Path}}@${newVersion}{{end}}" -m all | grep "^github.com/gogf/gf" | xargs -L1 go get -v 
+    # Remove indirect dependencies
+    sed -i '/\/\/ indirect/d' go.mod
     go mod tidy
     # Remove toolchain line if exists
     $SED_INPLACE '/^toolchain/d' go.mod
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 1d26a21f2..573a11e29 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -3,11 +3,13 @@
 Thanks for taking the time to join our community and start contributing!
 
 ## With issues
+
 - Use the search tool before opening a new issue.
 - Please provide source code and commit sha if you found a bug.
 - Review existing issues and provide feedback or react to them.
 
 ## With pull requests
+
 - Open your pull request against `master`
 - Your pull request should have no more than two commits, if not you should squash them.
 - It should pass all tests in the available continuous integrations systems such as GitHub CI.
diff --git a/Makefile b/Makefile
index d0cd1cc8e..4b5d0b5e8 100644
--- a/Makefile
+++ b/Makefile
@@ -6,10 +6,29 @@ tidy:
 	./.make_tidy.sh
 
 # execute "golangci-lint" to check code style
+# go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest
 .PHONY: lint
 lint:
 	golangci-lint run -c .golangci.yml
 
+# make branch to=v2.4.0
+.PHONY: branch
+branch:
+	@set -e; \
+	newVersion=$(to); \
+	if [ -z "$$newVersion" ]; then \
+		echo "Error: 'to' variable is required. Usage: make branch to=vX.Y.Z"; \
+		exit 1; \
+	fi; \
+	branchName=fix/$$newVersion; \
+	echo "Switching to master branch..."; \
+	git checkout master; \
+	echo "Pulling latest changes from master..."; \
+	git pull origin master; \
+	echo "Creating and switching to branch $$branchName from master..."; \
+	git checkout -b $$branchName; \
+	echo "Branch $$branchName created successfully!"
+
 # make version to=v2.4.0
 .PHONY: version
 version:
@@ -18,6 +37,20 @@ version:
 	./.make_version.sh ./ $$newVersion; \
 	echo "make version to=$(to) done"
 
+# make tag to=v2.4.0
+.PHONY: tag
+tag:
+	@set -e; \
+	newVersion=$(to); \
+	echo "Switching to master branch..."; \
+	git checkout master; \
+	echo "Pulling latest changes from master..."; \
+	git pull origin master; \
+	echo "Creating annotated tag $$newVersion..."; \
+	git tag -a $$newVersion -m "Release $$newVersion"; \
+	echo "Pushing tag $$newVersion..."; \
+	git push origin $$newVersion; \
+	echo "Tag $$newVersion created and pushed successfully!"
 
 # update submodules
 .PHONY: subup
@@ -43,3 +76,13 @@ subsync: subup
 		git push origin; \
 	fi; \
 	cd ..;
+
+# manage docker services for local development
+# usage: make docker or make docker cmd=start svc=mysql
+.PHONY: docker
+docker:
+	@if [ -z "$(cmd)" ]; then \
+		./.github/workflows/scripts/docker-services.sh; \
+	else \
+		./.github/workflows/scripts/docker-services.sh $(cmd) $(svc) $(extra); \
+	fi
diff --git a/README.MD b/README.MD
index e958919c2..d06eda44a 100644
--- a/README.MD
+++ b/README.MD
@@ -1,3 +1,4 @@
+English | [简体中文](README.zh_CN.MD)
 
 <div align=center>
 <img src="https://goframe.org/img/logo_full.png" width="300" alt="goframe gf logo"/>
@@ -23,24 +24,30 @@
 
 A powerful framework for faster, easier, and more efficient project development.
 
+## Installation
 
-# Documentation
+```bash
+go get -u github.com/gogf/gf/v2
+```
 
-- GoFrame Official Site: [https://goframe.org](https://goframe.org)
-- GoFrame Official Site(en): [https://goframe.org/en](https://goframe.org/en)
-- GoFrame Mirror Site(中文): [https://goframe.org.cn](https://goframe.org.cn)
-- GoFrame Mirror Site(github pages): [https://pages.goframe.org](https://pages.goframe.org)
+## Documentation
+
+- Official Site: [https://goframe.org](https://goframe.org)
+- Official Site(en): [https://goframe.org/en](https://goframe.org/en)
+- 国内镜像: [https://goframe.org.cn](https://goframe.org.cn)
+- Mirror Site: [Github Pages](https://pages.goframe.org)
+- Mirror Site: [Offline Docs](https://github.com/gogf/goframe.org-pdf?tab=readme-ov-file#%E6%9C%80%E6%96%B0%E7%89%88%E6%9C%AC)
 - GoDoc API: [https://pkg.go.dev/github.com/gogf/gf/v2](https://pkg.go.dev/github.com/gogf/gf/v2)
+- Doc Source: [https://github.com/gogf/gf-site](https://github.com/gogf/gf-site)
 
-
-# Contributors
+## Contributors
 
 💖 [Thanks to all the contributors who made GoFrame possible](https://github.com/gogf/gf/graphs/contributors) 💖
 
 <a href="https://github.com/gogf/gf/graphs/contributors">
-<img src="https://goframe.org/img/contributors.svg?version=v2.9.3" alt="goframe contributors"/>
+<img src="https://goframe.org/img/contributors.svg?version=v2.9.8" alt="goframe contributors"/>
 </a>
 
-# License
+## License
 
 `GoFrame` is licensed under the [MIT License](LICENSE), 100% free and open-source, forever.
diff --git a/README.zh_CN.MD b/README.zh_CN.MD
new file mode 100644
index 000000000..f707b1a97
--- /dev/null
+++ b/README.zh_CN.MD
@@ -0,0 +1,53 @@
+[English](README.MD) | 简体中文
+
+<div align=center>
+<img src="https://goframe.org/img/logo_full.png" width="300" alt="goframe gf logo"/>
+
+[![Go Reference](https://pkg.go.dev/badge/github.com/gogf/gf/v2.svg)](https://pkg.go.dev/github.com/gogf/gf/v2)
+[![GoFrame CI](https://github.com/gogf/gf/actions/workflows/ci-main.yml/badge.svg)](https://github.com/gogf/gf/actions/workflows/ci-main.yml)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/gogf/gf/badge)](https://scorecard.dev/viewer/?uri=github.com/gogf/gf)
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/9233/badge)](https://bestpractices.coreinfrastructure.org/projects/9233)
+[![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?style=flat)](https://github.com/gogf/gf)
+[![License](https://img.shields.io/github/license/gogf/gf.svg?style=flat)](https://github.com/gogf/gf)
+
+[![Release](https://img.shields.io/github/v/release/gogf/gf?style=flat)](https://github.com/gogf/gf/releases)
+[![GitHub pull requests](https://img.shields.io/github/issues-pr/gogf/gf?style=flat)](https://github.com/gogf/gf/pulls)
+[![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/gogf/gf?style=flat)](https://github.com/gogf/gf/pulls?q=is%3Apr+is%3Aclosed)
+[![GitHub issues](https://img.shields.io/github/issues/gogf/gf?style=flat)](https://github.com/gogf/gf/issues)
+[![GitHub closed issues](https://img.shields.io/github/issues-closed/gogf/gf?style=flat)](https://github.com/gogf/gf/issues?q=is%3Aissue+is%3Aclosed)
+![Stars](https://img.shields.io/github/stars/gogf/gf?style=flat)
+![Forks](https://img.shields.io/github/forks/gogf/gf?style=flat)
+
+</div>
+
+一个强大的框架，为了更快、更轻松、更高效的项目开发。
+
+## 安装
+
+```bash
+go get -u github.com/gogf/gf/v2
+```
+
+## 文档
+
+- 官方网站: [https://goframe.org](https://goframe.org)
+- 官方网站(en): [https://goframe.org/en](https://goframe.org/en)
+- 国内镜像: [https://goframe.org.cn](https://goframe.org.cn)
+- 镜像网站: [Github Pages](https://pages.goframe.org)
+- 镜像网站: [离线文档](https://github.com/gogf/goframe.org-pdf?tab=readme-ov-file#%E6%9C%80%E6%96%B0%E7%89%88%E6%9C%AC)
+- Go包文档: [https://pkg.go.dev/github.com/gogf/gf/v2](https://pkg.go.dev/github.com/gogf/gf/v2)
+- 文档源码: [https://github.com/gogf/gf-site](https://github.com/gogf/gf-site)
+
+## 贡献者
+
+💖 [感谢所有使 GoFrame 成为可能的贡献者](https://github.com/gogf/gf/graphs/contributors) 💖
+
+<a href="https://github.com/gogf/gf/graphs/contributors">
+<img src="https://goframe.org/img/contributors.svg?version=v2.9.5" alt="goframe contributors"/>
+</a>
+
+## 许可证
+
+`GoFrame` 采用 [MIT License](LICENSE) 许可，100% 免费和开源，永久保持。
diff --git a/cmd/gf/README.MD b/cmd/gf/README.MD
index 863644d44..2e45e451e 100644
--- a/cmd/gf/README.MD
+++ b/cmd/gf/README.MD
@@ -1,3 +1,5 @@
+English | [简体中文](README.zh_CN.MD)
+
 # gf
 
 `gf` is a powerful CLI tool for building [GoFrame](https://goframe.org) application with convenience.
@@ -21,18 +23,18 @@ You can also install `gf` tool using pre-built binaries: <https://github.com/gog
 
 3. Database support
 
-   |     DB     | builtin support |                                                                             remarks                                                                              |
-   |:----------:|:---------------:|:----------------------------------------------------------------------------------------------------------------------------------------------------------------:|
-   |   mysql    |       yes       |                                                                                -                                                                                 |
-   |  mariadb   |       yes       |                                                                                -                                                                                 |
-   |    tidb    |       yes       |                                                                                -                                                                                 |
-   |   mssql    |       yes       |                                                                                -                                                                                 |
-   |   oracle   |       yes       |                                                                                -                                                                                 |
-   |   pgsql    |       yes       |                                                                                -                                                                                 |
-   |   sqlite   |       yes       |                                                                                -                                                                                 |
-   | sqlitecgo  |       no        | to support sqlite database on 32bit architecture systems, manually add package import to the [source codes](./internal/cmd/cmd_gen_dao.go) and do the building.  |
-   | clickhouse |       no        |                              manually add package import to the [source codes](./internal/cmd/cmd_gen_dao.go) and do the building.                               |
-   |     dm     |       no        |                              manually add package import to the [source codes](./internal/cmd/cmd_gen_dao.go) and do the building.                               |
+   |     DB     | builtin support |                                                                             remarks                                                                             |
+   | :--------: | :-------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+   |   mysql    |       yes       |                                                                                -                                                                                |
+   |  mariadb   |       yes       |                                                                                -                                                                                |
+   |    tidb    |       yes       |                                                                                -                                                                                |
+   |   mssql    |       yes       |                                                                                -                                                                                |
+   |   oracle   |       yes       |                                                                                -                                                                                |
+   |   pgsql    |       yes       |                                                                                -                                                                                |
+   |   sqlite   |       yes       |                                                                                -                                                                                |
+   | sqlitecgo  |       no        | to support sqlite database on 32bit architecture systems, manually add package import to the [source codes](./internal/cmd/cmd_gen_dao.go) and do the building. |
+   | clickhouse |       yes       |                                                                                -                                                                                |
+   |     dm     |       no        |                              manually add package import to the [source codes](./internal/cmd/cmd_gen_dao.go) and do the building.                              |
 
 ## 2) Manually Install
 
@@ -43,30 +45,31 @@ go install github.com/gogf/gf/cmd/gf/v2@v2.5.5 # certain version(should be >= v2
 
 ## 2. Commands
 
-```html
-$ gf
+```shell
+$ gf -h
 USAGE
     gf COMMAND [OPTION]
 
 COMMAND
-   up         upgrade GoFrame version/tool to latest one in current project
-   env        show current Golang environment variables
-   fix        auto fixing codes after upgrading to new GoFrame version
-   run        running go codes with hot-compiled-like feature
-   gen        automatically generate go files for dao/do/entity/pb/pbentity
-   tpl        template parsing and building commands
-   init       create and initialize an empty GoFrame project
-   pack       packing any file/directory to a resource file, or a go file
-   build      cross-building go project for lots of platforms
-   docker     build docker image for current GoFrame project
-   install    install gf binary to system (might need root/admin permission)
-   version    show version information of current binary
+    up         upgrade GoFrame version/tool to latest one in current project
+    env        show current Golang environment variables
+    fix        auto fixing codes after upgrading to new GoFrame version
+    run        running go codes with hot-compiled-like feature
+    gen        automatically generate go files for dao/do/entity/pb/pbentity
+    tpl        template parsing and building commands
+    init       create and initialize an empty GoFrame project
+    pack       packing any file/directory to a resource file, or a go file
+    build      cross-building go project for lots of platforms
+    docker     build docker image for current GoFrame project
+    install    install gf binary to system (might need root/admin permission)
+    version    show version information of current binary
+    doc        download https://pages.goframe.org/ to run locally
 
 OPTION
-   -y, --yes       all yes for all command without prompt ask
-   -v, --version   show version information of current binary
-   -d, --debug     show internal detailed debugging information
-   -h, --help      more information about this command
+    -y, --yes       all yes for all command without prompt ask
+    -v, --version   show version information of current binary
+    -d, --debug     show internal detailed debugging information
+    -h, --help      more information about this command
 
 ADDITIONAL
     Use "gf COMMAND -h" for details about a command.
diff --git a/cmd/gf/README.zh_CN.MD b/cmd/gf/README.zh_CN.MD
new file mode 100644
index 000000000..062798544
--- /dev/null
+++ b/cmd/gf/README.zh_CN.MD
@@ -0,0 +1,82 @@
+[English](README.MD) | 简体中文
+
+# gf
+
+`gf` 是一个强大的 CLI 工具，用于便捷地构建 [GoFrame](https://goframe.org) 应用程序。
+
+## 1. 安装
+
+## 1) 预编译二进制文件
+
+您也可以使用预构建的二进制文件安装 `gf` 工具：<https://github.com/gogf/gf/releases>
+
+1. `Mac` & `Linux`
+
+   ```shell
+    wget -O gf https://github.com/gogf/gf/releases/latest/download/gf_$(go env GOOS)_$(go env GOARCH) && chmod +x gf && ./gf install -y && rm ./gf
+   ```
+
+   > 如果您使用 `zsh`，您可能需要通过命令 `alias gf=gf` 重命名别名以解决 `gf` 和 `git fetch` 之间的冲突。
+
+2. `Windows`
+   手动下载，在命令行中执行，然后按照说明操作。
+
+3. 数据库支持
+
+   |     数据库     | 内置支持 |                                                                             说明                                                                             |
+   | :--------: | :-------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+   |   mysql    |       是       |                                                                                -                                                                                |
+   |  mariadb   |       是       |                                                                                -                                                                                |
+   |    tidb    |       是       |                                                                                -                                                                                |
+   |   mssql    |       是       |                                                                                -                                                                                |
+   |   oracle   |       是       |                                                                                -                                                                                |
+   |   pgsql    |       是       |                                                                                -                                                                                |
+   |   sqlite   |       是       |                                                                                -                                                                                |
+   | sqlitecgo  |       否        | 要在 32 位架构系统上支持 sqlite 数据库，请手动向[源代码](./internal/cmd/cmd_gen_dao.go)添加包导入并进行构建。 |
+   | clickhouse |       是        |                                                                                -                                                                                |
+   |     dm     |       否        |                              手动向[源代码](./internal/cmd/cmd_gen_dao.go)添加包导入并进行构建。                              |
+
+## 2) 手动安装
+
+```shell
+go install github.com/gogf/gf/cmd/gf/v2@latest # 最新版本
+go install github.com/gogf/gf/cmd/gf/v2@v2.5.5 # 特定版本(应该 >= v2.5.5)
+```
+
+## 2. 命令
+
+```shell
+$ gf -h
+用法
+    gf 命令 [选项]
+
+命令
+    up         升级项目中的 GoFrame 版本/工具到最新版本
+    env        显示当前 Golang 环境变量
+    fix        升级到新 GoFrame 版本后自动修复代码
+    run        运行 go 代码，具有热编译功能
+    gen        自动生成 dao/do/entity/pb/pbentity 的 go 文件
+    tpl        模板解析和构建命令
+    init       创建并初始化一个空的 GoFrame 项目
+    pack       将任何文件/目录打包到资源文件或 go 文件
+    build      为多个平台交叉编译 go 项目
+    docker     为当前 GoFrame 项目构建 docker 镜像
+    install    将 gf 二进制文件安装到系统(可能需要 root/admin 权限)
+    version    显示当前二进制文件的版本信息
+    doc        下载 https://pages.goframe.org/ 本地运行
+
+选项
+    -y, --yes       对所有命令都使用 yes，不再提示
+    -v, --version   显示当前二进制文件的版本信息
+    -d, --debug     显示内部详细的调试信息
+    -h, --help      显示此命令的更多信息
+
+附加信息
+    使用 "gf 命令 -h" 获取有关命令的详细信息。
+```
+
+## 3. 常见问题
+
+### 1). 命令 `gf run` 返回 `pipe: too many open files`
+
+请使用 `ulimit -n 65535` 扩大系统配置以增加当前终端 shell 会话的最大打开文件数，然后再运行 `gf run`。
diff --git a/cmd/gf/go.mod b/cmd/gf/go.mod
index 322fc52df..1f50688fa 100644
--- a/cmd/gf/go.mod
+++ b/cmd/gf/go.mod
@@ -3,18 +3,18 @@ module github.com/gogf/gf/cmd/gf/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.3
-	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.3
-	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.3
-	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.3
-	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.3
-	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.3
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.8
+	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.8
+	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.8
+	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.8
+	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.8
+	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.8
+	github.com/gogf/gf/v2 v2.9.8
 	github.com/gogf/selfupdate v0.0.0-20231215043001-5c48c528462f
-	github.com/olekukonko/tablewriter v1.0.9
+	github.com/olekukonko/tablewriter v1.1.0
 	github.com/schollz/progressbar/v3 v3.15.0
-	golang.org/x/mod v0.26.0
-	golang.org/x/tools v0.35.0
+	golang.org/x/mod v0.25.0
+	golang.org/x/tools v0.26.0
 )
 
 require (
@@ -23,7 +23,7 @@ require (
 	github.com/ClickHouse/clickhouse-go/v2 v2.0.15 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/glebarez/go-sqlite v1.21.2 // indirect
@@ -37,7 +37,7 @@ require (
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/lib/pq v1.10.9 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/microsoft/go-mssqldb v1.7.1 // indirect
@@ -51,16 +51,16 @@ require (
 	github.com/shopspring/decimal v1.3.1 // indirect
 	github.com/sijms/go-ora/v2 v2.7.10 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/crypto v0.41.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
-	golang.org/x/sync v0.16.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/crypto v0.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/sync v0.14.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/term v0.34.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/term v0.32.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	modernc.org/libc v1.22.5 // indirect
 	modernc.org/mathutil v1.5.0 // indirect
diff --git a/cmd/gf/go.sum b/cmd/gf/go.sum
index 85f3ac948..a596009f1 100644
--- a/cmd/gf/go.sum
+++ b/cmd/gf/go.sum
@@ -27,8 +27,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -46,20 +46,20 @@ github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiU
 github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
 github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
-github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.3 h1:/Nw0Tg7X4zlF8x72e2slQidiY0J+kqDpLuejNSmaLWk=
-github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.3/go.mod h1:NkdRgePcrg6/PD7SUqedtfr3a4E4n3uwVLZ+Xdnq2VU=
-github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.3 h1:kfDQVyHpbpUBS4cZ/8YbAnzqh6KaKP019nXl0FTplZE=
-github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.3/go.mod h1:c/rS7hbTqfTsZdqt6jOE59jeqsPrnYTaUwW2XB+N0kI=
-github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.3 h1:P4jrnp+Vmh3kDeaH/kyHPI6rfoMmQD+sPJa716aMbS0=
-github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.3/go.mod h1:yEhfx78wgpxUJhH9C9bWJ7I3JLcVCzUg11A4ORYTKeg=
-github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.3 h1:TKpjp/jFF2tiOMsKH2PTxZbGFctsi8+CN+dsTA70VEc=
-github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.3/go.mod h1:v10xiQ7LA2dF4RNHa2pojCPgAoXCJEKK1Iw0DRvMwzQ=
-github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.3 h1:8QgjRauacL7nOKxEHxNiHGL+041ke9lXHe93NIvPYw8=
-github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.3/go.mod h1:umGqltjrzpY2Il2GF0GX1/TQAk8Xz6vYQM4/q3BuqIo=
-github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.3 h1:xXOneBClGz9UQmgjc1qRRufPPTtbASDJv32oSdFz+D0=
-github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.3/go.mod h1:97jRMN7LgWrNgJB3DorP0zlSchGicLO2W6gXk2tffW8=
-github.com/gogf/gf/v2 v2.9.3 h1:qjN4s55FfUzxZ1AE8vUHNDX3V0eIOUGXhF2DjRTVZQ4=
-github.com/gogf/gf/v2 v2.9.3/go.mod h1:w6rcfD13SmO7FKI80k9LSLiSMGqpMYp50Nfkrrc2sEE=
+github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.8 h1:L72OB2HPuZSHtJ2ipBzI+62rGGDRdwYjequ1v+zctpg=
+github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.8/go.mod h1:D0UySg70Bd264F5AScYmz1Hl8vjzlUJ7YvqBJc5OFbo=
+github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.8 h1:DT5zHfo9/VkbJ+TF7kUasvv4dbU5uctoj+JGbrzgdYE=
+github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.8/go.mod h1:cDd91Zd8LxFF+xxOflRRqw0WTTCpAJ0nf0KKRA+nvTE=
+github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.8 h1:XZ4Ya/50xpjf81+4genr33iJXR2dxJmqYKxGyXlLRqA=
+github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.8/go.mod h1:wtm2NJb/L3CbDOmyUc7TsOpWHTCMakg1QRG7B/oKrRs=
+github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.8 h1:ZrqABJsUnhNDz8VAem1XXONBTywl6r+GHQH05i+4W1g=
+github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.8/go.mod h1:YTFyeVk2Rgu/JMUhFxkjYzWaBc+yZ6wAvY54XVZoNko=
+github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.8 h1:Dc227FD1uf9nNBPFEjMEgIoAJbAgeYeNrOrjviDgPzY=
+github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.8/go.mod h1:o3EpB4Ti3+x/axzRMJg2k7TrLiWZiSTxP0v64LBkk5k=
+github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.8 h1:LHEhzsBfIo8xHvOUuLDQW1q7Qix1vnBabH/iivCRghs=
+github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.8/go.mod h1:SX6dRONaJGafzCoMIrn8CkRM4fIvtmJRt/aYclUHy3Q=
+github.com/gogf/gf/v2 v2.9.8 h1:El0HwksTzeRk0DQV4Lh7S9DbsIwKInhHSHGcH7qJumM=
+github.com/gogf/gf/v2 v2.9.8/go.mod h1:Svl1N+E8G/QshU2DUbh/3J/AJauqCgUnxHurXWR4Qx0=
 github.com/gogf/selfupdate v0.0.0-20231215043001-5c48c528462f h1:7xfXR/BhG3JDqO1s45n65Oyx9t4E/UqDOXep6jXdLCM=
 github.com/gogf/selfupdate v0.0.0-20231215043001-5c48c528462f/go.mod h1:HnYoio6S7VaFJdryKcD/r9HgX+4QzYfr00XiXUo/xz0=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
@@ -100,8 +100,9 @@ github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
 github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -116,8 +117,8 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/paulmach/orb v0.7.1 h1:Zha++Z5OX/l168sqHK3k4z18LDvr+YAO/VjK0ReQ9rU=
 github.com/paulmach/orb v0.7.1/go.mod h1:FWRlTgl88VI1RBx/MkrwWDRhQ96ctqMCh8boXhmqB/A=
 github.com/paulmach/protoscan v0.2.1/go.mod h1:SpcSwydNLrxUGSDvXvO0P7g7AuhJ7lcKfDlhJCDw2gY=
@@ -134,8 +135,8 @@ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qq
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/schollz/progressbar/v3 v3.15.0 h1:cNZmcNiVyea6oofBTg80ZhVXxf3wG/JoAhqCCwopkQo=
 github.com/schollz/progressbar/v3 v3.15.0/go.mod h1:ncBdc++eweU0dQoeZJ3loXoAc+bjaallHRIm8pVVeQM=
 github.com/shirou/gopsutil v2.19.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
@@ -150,8 +151,8 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/tklauser/go-sysconf v0.3.10/go.mod h1:C8XykCvCb+Gn0oNCWPIlcb0RuglQTYaQ2hGm7jmxEFk=
 github.com/tklauser/numcpus v0.4.0/go.mod h1:1+UI3pD8NW14VMwdgJNJ1ESk2UnwhAnz5hMwiKKqXCQ=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -160,38 +161,40 @@ github.com/yusufpapurcu/wmi v1.2.2/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQ
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
 go.opentelemetry.io/otel v1.7.0/go.mod h1:5BdUoMIz5WEs0vt0CUEMtSSaTSHBBVwrhnz7+nrD5xk=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
 go.opentelemetry.io/otel/trace v1.7.0/go.mod h1:fzLSB9nqR2eXzxPXb2JW9IKE+ScyXA48yyE4TNvoHqU=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
-golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.26.0 h1:EGMPT//Ezu+ylkCijjPc+f4Aih7sZvaAr+O3EHBxvZg=
-golang.org/x/mod v0.26.0/go.mod h1:/j6NAhSk8iQ723BGAUyoAcn7SlD7s15Dp9Nd/SfeaFQ=
+golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
+golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
-golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
+golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -201,24 +204,25 @@ golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210228012217-479acdf4ea46/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220429233432-b5fbb4746d32/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8=
-golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4=
-golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
 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.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.35.0 h1:mBffYraMEf7aa0sB+NuKnuCy8qI/9Bughn8dC2Gu5r0=
-golang.org/x/tools v0.35.0/go.mod h1:NKdj5HkL/73byiZSJjqJgKn3ep7KjFkBOkR/Hps3VPw=
+golang.org/x/tools v0.26.0 h1:v/60pFQmzmT9ExmjDv2gGIfi3OqfKoEP6I5+umXlbnQ=
+golang.org/x/tools v0.26.0/go.mod h1:TPVVj70c7JJ3WCazhD8OdXcZg/og+b9+tH/KxylGwH0=
 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=
diff --git a/cmd/gf/go.work b/cmd/gf/go.work
index edf43a26c..f5326281d 100644
--- a/cmd/gf/go.work
+++ b/cmd/gf/go.work
@@ -14,5 +14,9 @@ replace (
 	github.com/gogf/gf/contrib/drivers/oracle/v2 => ../../contrib/drivers/oracle
 	github.com/gogf/gf/contrib/drivers/pgsql/v2 => ../../contrib/drivers/pgsql
 	github.com/gogf/gf/contrib/drivers/sqlite/v2 => ../../contrib/drivers/sqlite
+	github.com/gogf/gf/contrib/drivers/mariadb/v2 => ../../contrib/drivers/mariadb
+	github.com/gogf/gf/contrib/drivers/tidb/v2 => ../../contrib/drivers/tidb
+	github.com/gogf/gf/contrib/drivers/oceanbase/v2 => ../../contrib/drivers/oceanbase
+	github.com/gogf/gf/contrib/drivers/gaussdb/v2 => ../../contrib/drivers/gaussdb
 	github.com/gogf/gf/v2 => ../../
 )
diff --git a/cmd/gf/internal/cmd/cmd_build.go b/cmd/gf/internal/cmd/cmd_build.go
index 2454da574..b39232efa 100644
--- a/cmd/gf/internal/cmd/cmd_build.go
+++ b/cmd/gf/internal/cmd/cmd_build.go
@@ -30,12 +30,10 @@ import (
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 )
 
-var (
-	Build = cBuild{
-		nodeNameInConfigFile: "gfcli.build",
-		packedGoFileName:     "internal/packed/build_pack_data.go",
-	}
-)
+var Build = cBuild{
+	nodeNameInConfigFile: "gfcli.build",
+	packedGoFileName:     "internal/packed/build_pack_data.go",
+}
 
 type cBuild struct {
 	g.Meta               `name:"build" brief:"{cBuildBrief}" dc:"{cBuildDc}" eg:"{cBuildEg}" ad:"{cBuildAd}"`
@@ -65,45 +63,67 @@ It provides much more features for building binary:
 `
 	cBuildAd = `
 PLATFORMS
+    aix       ppc64
+    android   386,amd64,arm,arm64
     darwin    amd64,arm64
+    dragonfly amd64
     freebsd   386,amd64,arm
-    linux     386,amd64,arm,arm64,ppc64,ppc64le,mips,mipsle,mips64,mips64le
+    illumos   amd64
+    ios       arm64
+    js        wasm
+    linux     386,amd64,arm,arm64,loong64,mips,mipsle,mips64,mips64le,ppc64,ppc64le,riscv64,s390x
     netbsd    386,amd64,arm
-    openbsd   386,amd64,arm
-    windows   386,amd64
+    openbsd   386,amd64,arm,arm64
+    plan9     386,amd64,arm
+    solaris   amd64
+    wasip1    wasm
+    windows   386,amd64,arm,arm64
 `
 	// https://golang.google.cn/doc/install/source
 	cBuildPlatforms = `
+aix       ppc64
+android   386
+android   amd64
+android   arm
+android   arm64
 darwin    amd64
 darwin    arm64
-ios       amd64
-ios       arm64
+dragonfly amd64
 freebsd   386
 freebsd   amd64
 freebsd   arm
+illumos   amd64
+ios       arm64
+js        wasm
 linux     386
 linux     amd64
 linux     arm
 linux     arm64
-linux     ppc64
-linux     ppc64le
+linux     loong64
 linux     mips
 linux     mipsle
 linux     mips64
 linux     mips64le
+linux     ppc64
+linux     ppc64le
+linux     riscv64
+linux     s390x
 netbsd    386
 netbsd    amd64
 netbsd    arm
 openbsd   386
 openbsd   amd64
 openbsd   arm
-windows   386
-windows   amd64
-android   arm
-dragonfly amd64
+openbsd   arm64
 plan9     386
 plan9     amd64
+plan9     arm
 solaris   amd64
+wasip1    wasm
+windows   386
+windows   amd64
+windows   arm
+windows   arm64
 `
 )
 
diff --git a/cmd/gf/internal/cmd/cmd_env.go b/cmd/gf/internal/cmd/cmd_env.go
index 8c48be62e..52153bade 100644
--- a/cmd/gf/internal/cmd/cmd_env.go
+++ b/cmd/gf/internal/cmd/cmd_env.go
@@ -37,11 +37,13 @@ type cEnvInput struct {
 type cEnvOutput struct{}
 
 func (c cEnv) Index(ctx context.Context, in cEnvInput) (out *cEnvOutput, err error) {
-	result, err := gproc.ShellExec(ctx, "go env")
-	if err != nil {
-		mlog.Fatal(err)
-	}
+	result, execErr := gproc.ShellExec(ctx, "go env")
+	// Note: go env may return non-zero exit code when there are warnings (e.g., invalid characters in env vars),
+	// but it still outputs valid environment variables. So we only fail if result is empty.
 	if result == "" {
+		if execErr != nil {
+			mlog.Fatal(execErr)
+		}
 		mlog.Fatal(`retrieving Golang environment variables failed, did you install Golang?`)
 	}
 	var (
@@ -59,7 +61,9 @@ func (c cEnv) Index(ctx context.Context, in cEnvInput) (out *cEnvOutput, err err
 		}
 		match, _ := gregex.MatchString(`(.+?)=(.*)`, line)
 		if len(match) < 3 {
-			mlog.Fatalf(`invalid Golang environment variable: "%s"`, line)
+			// Skip lines that don't match key=value format (e.g., warning messages from go env)
+			mlog.Debugf(`invalid Golang environment variable: "%s"`, line)
+			continue
 		}
 		array = append(array, []string{gstr.Trim(match[1]), gstr.Trim(match[2])})
 	}
diff --git a/cmd/gf/internal/cmd/cmd_init.go b/cmd/gf/internal/cmd/cmd_init.go
index 5b583345d..e027cc034 100644
--- a/cmd/gf/internal/cmd/cmd_init.go
+++ b/cmd/gf/internal/cmd/cmd_init.go
@@ -7,9 +7,11 @@
 package cmd
 
 import (
+	"bufio"
 	"context"
 	"fmt"
 	"os"
+	"strconv"
 	"strings"
 
 	"github.com/gogf/gf/v2/frame/g"
@@ -20,6 +22,7 @@ import (
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gtag"
 
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/geninit"
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/allyes"
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
@@ -44,6 +47,13 @@ const (
 gf init my-project
 gf init my-mono-repo -m
 gf init my-mono-repo -a
+gf init my-project -u
+gf init my-project -g "github.com/myorg/myproject"
+gf init -r github.com/gogf/template-single my-project
+gf init -r github.com/gogf/examples/httpserver/jwt my-jwt
+gf init -r github.com/gogf/gf/cmd/gf/v2@v2.9.7 mygf
+gf init -r github.com/gogf/gf/cmd/gf/v2 mygf -s
+gf init -i
 `
 	cInitNameBrief = `
 name for the project. It will create a folder with NAME in current directory.
@@ -55,6 +65,16 @@ The NAME will also be the module name for the project.
 	cInitGitignore = ".gitignore"
 )
 
+// defaultTemplates is the list of predefined templates for interactive selection
+var defaultTemplates = []struct {
+	Name string
+	Repo string
+	Desc string
+}{
+	{"template-single", "github.com/gogf/template-single", "Single project template"},
+	{"template-mono", "github.com/gogf/template-mono", "Mono-repo project template"},
+}
+
 func init() {
 	gtag.Sets(g.MapStrStr{
 		`cInitBrief`:     cInitBrief,
@@ -64,17 +84,86 @@ func init() {
 }
 
 type cInitInput struct {
-	g.Meta  `name:"init"`
-	Name    string `name:"NAME" arg:"true" v:"required" brief:"{cInitNameBrief}"`
-	Mono    bool   `name:"mono" short:"m" brief:"initialize a mono-repo instead a single-repo" orphan:"true"`
-	MonoApp bool   `name:"monoApp" short:"a" brief:"initialize a mono-repo-app instead a single-repo" orphan:"true"`
-	Update  bool   `name:"update" short:"u" brief:"update to the latest goframe version" orphan:"true"`
-	Module  string `name:"module" short:"g" brief:"custom go module"`
+	g.Meta      `name:"init"`
+	Name        string `name:"NAME" arg:"true" brief:"{cInitNameBrief}"`
+	Mono        bool   `name:"mono" short:"m" brief:"initialize a mono-repo instead a single-repo" orphan:"true"`
+	MonoApp     bool   `name:"monoApp" short:"a" brief:"initialize a mono-repo-app instead a single-repo" orphan:"true"`
+	Update      bool   `name:"update" short:"u" brief:"update to the latest goframe version" orphan:"true"`
+	Module      string `name:"module" short:"g" brief:"custom go module"`
+	Repo        string `name:"repo" short:"r" brief:"remote repository URL for template download"`
+	SelectVer   bool   `name:"select" short:"s" brief:"enable interactive version selection for remote template" orphan:"true"`
+	Interactive bool   `name:"interactive" short:"i" brief:"enable interactive mode to select template" orphan:"true"`
 }
 
 type cInitOutput struct{}
 
 func (c cInit) Index(ctx context.Context, in cInitInput) (out *cInitOutput, err error) {
+	// Check if using remote template mode
+	if in.Repo != "" || in.Interactive {
+		return c.initFromRemote(ctx, in)
+	}
+
+	// If no name provided and no remote mode, enter interactive mode
+	if in.Name == "" {
+		return c.initInteractive(ctx, in)
+	}
+
+	// Default: use built-in template
+	return c.initFromBuiltin(ctx, in)
+}
+
+// initFromRemote initializes project from remote repository
+func (c cInit) initFromRemote(ctx context.Context, in cInitInput) (out *cInitOutput, err error) {
+	repo := in.Repo
+	name := in.Name
+
+	// If interactive mode and no repo specified, let user select
+	if in.Interactive && repo == "" {
+		var modPath string
+		var upgradeDeps bool
+		repo, name, modPath, upgradeDeps, err = interactiveSelectTemplate()
+		if err != nil {
+			return nil, err
+		}
+		if modPath != "" {
+			in.Module = modPath
+		}
+		if upgradeDeps {
+			in.Update = true
+		}
+	}
+
+	if repo == "" {
+		return nil, fmt.Errorf("repository URL is required for remote template mode")
+	}
+
+	// Default name to repo basename if empty
+	if name == "" {
+		name = gfile.Basename(repo)
+		mlog.Printf("Using repository basename as project name: %s", name)
+	}
+
+	mlog.Print("initializing from remote template...")
+
+	opts := &geninit.ProcessOptions{
+		SelectVersion: in.SelectVer,
+		ModulePath:    in.Module,
+		UpgradeDeps:   in.Update,
+	}
+
+	if err = geninit.Process(ctx, repo, name, opts); err != nil {
+		return nil, err
+	}
+
+	mlog.Print("initialization done!")
+	if name != "" && name != "." {
+		mlog.Printf(`you can now run "cd %s && gf run main.go" to start your journey, enjoy!`, name)
+	}
+	return
+}
+
+// initFromBuiltin initializes project from built-in template
+func (c cInit) initFromBuiltin(ctx context.Context, in cInitInput) (out *cInitOutput, err error) {
 	var overwrote = false
 	if !gfile.IsEmpty(in.Name) && !allyes.Check() {
 		s := gcmd.Scanf(`the folder "%s" is not empty, files might be overwrote, continue? [y/n]: `, in.Name)
@@ -149,6 +238,9 @@ func (c cInit) Index(ctx context.Context, in cInitInput) (out *cInitOutput, err
 		return
 	}
 
+	// Format the generated Go files.
+	utils.GoFmt(in.Name)
+
 	// Update the GoFrame version.
 	if in.Update {
 		mlog.Print("update goframe...")
@@ -180,3 +272,170 @@ func (c cInit) Index(ctx context.Context, in cInitInput) (out *cInitOutput, err
 	}
 	return
 }
+
+// initInteractive enters interactive mode when no arguments provided
+func (c cInit) initInteractive(ctx context.Context, in cInitInput) (out *cInitOutput, err error) {
+	reader := bufio.NewReader(os.Stdin)
+
+	// Ask user which mode to use
+	fmt.Println("\nPlease select initialization mode:")
+	fmt.Println(strings.Repeat("-", 50))
+	fmt.Println("  [1] Built-in template (default)")
+	fmt.Println("  [2] Remote template")
+	fmt.Println(strings.Repeat("-", 50))
+
+	fmt.Print("Select mode [1-2] (default: 1): ")
+	input, err := reader.ReadString('\n')
+	if err != nil {
+		mlog.Fatalf("failed to read input: %v", err)
+		return
+	}
+	input = strings.TrimSpace(input)
+
+	if input == "2" {
+		in.Interactive = true
+		return c.initFromRemote(ctx, in)
+	}
+
+	// Built-in template mode
+	fmt.Println("\nPlease select project type:")
+	fmt.Println(strings.Repeat("-", 50))
+	fmt.Println("  [1] Single project (default)")
+	fmt.Println("  [2] Mono-repo project")
+	fmt.Println("  [3] Mono-repo app")
+	fmt.Println(strings.Repeat("-", 50))
+
+	fmt.Print("Select type [1-3] (default: 1): ")
+	input, err = reader.ReadString('\n')
+	if err != nil {
+		mlog.Fatalf("failed to read input: %v", err)
+		return
+	}
+	input = strings.TrimSpace(input)
+
+	switch input {
+	case "2":
+		in.Mono = true
+	case "3":
+		in.MonoApp = true
+	}
+
+	// Get project name
+	for {
+		fmt.Print("Enter project name: ")
+		input, err = reader.ReadString('\n')
+		if err != nil {
+			mlog.Fatalf("failed to read input: %v", err)
+			return
+		}
+		in.Name = strings.TrimSpace(input)
+		if in.Name != "" {
+			break
+		}
+		fmt.Println("Project name cannot be empty")
+	}
+
+	// Get module path (optional)
+	fmt.Printf("Enter Go module path (leave empty to use \"%s\"): ", in.Name)
+	input, err = reader.ReadString('\n')
+	if err != nil {
+		mlog.Fatalf("failed to read input: %v", err)
+		return
+	}
+	in.Module = strings.TrimSpace(input)
+
+	// Ask about update
+	fmt.Print("Update to latest GoFrame version? [y/N]: ")
+	input, err = reader.ReadString('\n')
+	if err != nil {
+		mlog.Fatalf("failed to read input: %v", err)
+		return
+	}
+	input = strings.TrimSpace(strings.ToLower(input))
+	in.Update = input == "y" || input == "yes"
+
+	fmt.Println()
+	return c.initFromBuiltin(ctx, in)
+}
+
+// interactiveSelectTemplate prompts user to select a template interactively
+func interactiveSelectTemplate() (repo, name, modPath string, upgradeDeps bool, err error) {
+	reader := bufio.NewReader(os.Stdin)
+
+	// 1. Select template
+	fmt.Println("\nPlease select a project template:")
+	fmt.Println(strings.Repeat("-", 50))
+	for i, t := range defaultTemplates {
+		fmt.Printf("  [%d] %s - %s\n", i+1, t.Name, t.Desc)
+	}
+	fmt.Printf("  [%d] Custom repository URL\n", len(defaultTemplates)+1)
+	fmt.Println(strings.Repeat("-", 50))
+
+	for {
+		fmt.Printf("Select template [1-%d]: ", len(defaultTemplates)+1)
+		input, err := reader.ReadString('\n')
+		if err != nil {
+			return "", "", "", false, fmt.Errorf("failed to read template selection: %w", err)
+		}
+		input = strings.TrimSpace(input)
+
+		idx, e := strconv.Atoi(input)
+		if e != nil || idx < 1 || idx > len(defaultTemplates)+1 {
+			fmt.Printf("Invalid selection, please enter a number between 1-%d\n", len(defaultTemplates)+1)
+			continue
+		}
+
+		if idx <= len(defaultTemplates) {
+			repo = defaultTemplates[idx-1].Repo
+			fmt.Printf("Selected: %s\n\n", repo)
+		} else {
+			// Custom URL
+			fmt.Print("Enter repository URL: ")
+			input, err = reader.ReadString('\n')
+			if err != nil {
+				return "", "", "", false, fmt.Errorf("failed to read repository URL: %w", err)
+			}
+			repo = strings.TrimSpace(input)
+			if repo == "" {
+				fmt.Println("Repository URL cannot be empty")
+				continue
+			}
+		}
+		break
+	}
+
+	// 2. Enter project name
+	for {
+		fmt.Print("Enter project name: ")
+		input, err := reader.ReadString('\n')
+		if err != nil {
+			return "", "", "", false, fmt.Errorf("failed to read project name: %w", err)
+		}
+		name = strings.TrimSpace(input)
+		if name == "" {
+			fmt.Println("Project name cannot be empty")
+			continue
+		}
+		break
+	}
+
+	// 3. Enter module path (optional)
+	fmt.Printf("Enter Go module path (leave empty to use \"%s\"): ", name)
+	input, err := reader.ReadString('\n')
+	if err != nil {
+		return "", "", "", false, fmt.Errorf("failed to read module path: %w", err)
+	}
+	modPath = strings.TrimSpace(input)
+
+	// 4. Ask about upgrade
+	fmt.Print("Upgrade dependencies to latest (go get -u)? [y/N]: ")
+	input, err = reader.ReadString('\n')
+	if err != nil {
+		return "", "", "", false, fmt.Errorf("failed to read upgrade confirmation: %w", err)
+	}
+	input = strings.TrimSpace(strings.ToLower(input))
+	upgradeDeps = input == "y" || input == "yes"
+
+	fmt.Println()
+	return repo, name, modPath, upgradeDeps, nil
+}
diff --git a/cmd/gf/internal/cmd/cmd_run.go b/cmd/gf/internal/cmd/cmd_run.go
index 490a93a8b..7306b7e5e 100644
--- a/cmd/gf/internal/cmd/cmd_run.go
+++ b/cmd/gf/internal/cmd/cmd_run.go
@@ -13,6 +13,7 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
+	"time"
 
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/frame/g"
@@ -26,20 +27,24 @@ import (
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 )
 
-var (
-	Run = cRun{}
-)
+var Run = cRun{}
 
 type cRun struct {
 	g.Meta `name:"run" usage:"{cRunUsage}" brief:"{cRunBrief}" eg:"{cRunEg}" dc:"{cRunDc}"`
 }
 
+type watchPath struct {
+	Path      string
+	Recursive bool
+}
+
 type cRunApp struct {
-	File       string   // Go run file name.
-	Path       string   // Directory storing built binary.
-	Options    string   // Extra "go run" options.
-	Args       string   // Custom arguments.
-	WatchPaths []string // Watch paths for live reload.
+	File           string   // Go run file name.
+	Path           string   // Directory storing built binary.
+	Options        string   // Extra "go run" options.
+	Args           string   // Custom arguments.
+	WatchPaths     []string // Watch paths for live reload.
+	IgnorePatterns []string // Custom ignore patterns.
 }
 
 const (
@@ -49,45 +54,47 @@ const (
 gf run main.go
 gf run main.go --args "server -p 8080"
 gf run main.go -mod=vendor
-gf run main.go -w "manifest/config/*.yaml"
+gf run main.go -w internal,api
+gf run main.go -i ".git,node_modules"
 `
 	cRunDc = `
 The "run" command is used for running go codes with hot-compiled-like feature,
 which compiles and runs the go codes asynchronously when codes change.
 `
-	cRunFileBrief       = `building file path.`
-	cRunPathBrief       = `output directory path for built binary file. it's "./" in default`
-	cRunExtraBrief      = `the same options as "go run"/"go build" except some options as follows defined`
-	cRunArgsBrief       = `custom arguments for your process`
-	cRunWatchPathsBrief = `watch additional paths for live reload, separated by ",". i.e. "manifest/config/*.yaml"`
+	cRunFileBrief          = `building file path.`
+	cRunPathBrief          = `output directory path for built binary file. it's "./" in default`
+	cRunExtraBrief         = `the same options as "go run"/"go build" except some options as follows defined`
+	cRunArgsBrief          = `custom arguments for your process`
+	cRunWatchPathsBrief    = `watch additional paths for live reload, separated by ",". i.e. "internal,api"`
+	cRunIgnorePatternBrief = `custom ignore patterns for watch, separated by ",". i.e. ".git,node_modules". default patterns: node_modules, vendor, .*, _*. Glob syntax: "*" matches any chars, "?" matches single char, "[abc]" matches char class. Note: patterns match directory names only, not paths`
 )
 
-var (
-	process *gproc.Process
-)
+var process *gproc.Process
 
 func init() {
 	gtag.Sets(g.MapStrStr{
-		`cRunUsage`:           cRunUsage,
-		`cRunBrief`:           cRunBrief,
-		`cRunEg`:              cRunEg,
-		`cRunDc`:              cRunDc,
-		`cRunFileBrief`:       cRunFileBrief,
-		`cRunPathBrief`:       cRunPathBrief,
-		`cRunExtraBrief`:      cRunExtraBrief,
-		`cRunArgsBrief`:       cRunArgsBrief,
-		`cRunWatchPathsBrief`: cRunWatchPathsBrief,
+		`cRunUsage`:              cRunUsage,
+		`cRunBrief`:              cRunBrief,
+		`cRunEg`:                 cRunEg,
+		`cRunDc`:                 cRunDc,
+		`cRunFileBrief`:          cRunFileBrief,
+		`cRunPathBrief`:          cRunPathBrief,
+		`cRunExtraBrief`:         cRunExtraBrief,
+		`cRunArgsBrief`:          cRunArgsBrief,
+		`cRunWatchPathsBrief`:    cRunWatchPathsBrief,
+		`cRunIgnorePatternBrief`: cRunIgnorePatternBrief,
 	})
 }
 
 type (
 	cRunInput struct {
-		g.Meta     `name:"run" config:"gfcli.run"`
-		File       string   `name:"FILE"       arg:"true" brief:"{cRunFileBrief}" v:"required"`
-		Path       string   `name:"path"       short:"p"  brief:"{cRunPathBrief}" d:"./"`
-		Extra      string   `name:"extra"      short:"e"  brief:"{cRunExtraBrief}"`
-		Args       string   `name:"args"       short:"a"  brief:"{cRunArgsBrief}"`
-		WatchPaths []string `name:"watchPaths" short:"w"  brief:"{cRunWatchPathsBrief}"`
+		g.Meta         `name:"run" config:"gfcli.run"`
+		File           string   `name:"FILE"           arg:"true" brief:"{cRunFileBrief}" v:"required"`
+		Path           string   `name:"path"           short:"p"  brief:"{cRunPathBrief}" d:"./"`
+		Extra          string   `name:"extra"          short:"e"  brief:"{cRunExtraBrief}"`
+		Args           string   `name:"args"           short:"a"  brief:"{cRunArgsBrief}"`
+		WatchPaths     []string `name:"watchPaths"     short:"w"  brief:"{cRunWatchPathsBrief}"`
+		IgnorePatterns []string `name:"ignorePatterns" short:"i"  brief:"{cRunIgnorePatternBrief}"`
 	}
 	cRunOutput struct{}
 )
@@ -104,22 +111,35 @@ func (c cRun) Index(ctx context.Context, in cRunInput) (out *cRunOutput, err err
 		mlog.Fatalf(`command "go" not found in your environment, please install golang first to proceed this command`)
 	}
 
-	if len(in.WatchPaths) == 1 {
-		in.WatchPaths = strings.Split(in.WatchPaths[0], ",")
+	// Parse comma-separated values in WatchPaths
+	if len(in.WatchPaths) > 0 {
+		in.WatchPaths = parseCommaSeparatedArgs(in.WatchPaths)
 		mlog.Printf("watchPaths: %v", in.WatchPaths)
 	}
 
+	// Parse comma-separated values in IgnorePatterns
+	if len(in.IgnorePatterns) > 0 {
+		in.IgnorePatterns = parseCommaSeparatedArgs(in.IgnorePatterns)
+		mlog.Printf("ignorePatterns: %v", in.IgnorePatterns)
+	}
+
 	app := &cRunApp{
-		File:       in.File,
-		Path:       filepath.FromSlash(in.Path),
-		Options:    in.Extra,
-		Args:       in.Args,
-		WatchPaths: in.WatchPaths,
+		File:           in.File,
+		Path:           filepath.FromSlash(in.Path),
+		Options:        in.Extra,
+		Args:           in.Args,
+		WatchPaths:     in.WatchPaths,
+		IgnorePatterns: in.IgnorePatterns,
 	}
 	dirty := gtype.NewBool()
 
-	var outputPath = app.genOutputPath()
+	outputPath := app.genOutputPath()
 	callbackFunc := func(event *gfsnotify.Event) {
+		if !event.IsWrite() && !event.IsCreate() && !event.IsRemove() && !event.IsRename() {
+			return
+		}
+
+		// Check if the file extension is 'go'.
 		if gfile.ExtName(event.Path) != "go" {
 			return
 		}
@@ -137,15 +157,11 @@ func (c cRun) Index(ctx context.Context, in cRunInput) (out *cRunOutput, err err
 		})
 	}
 
-	if len(app.WatchPaths) > 0 {
-		for _, path := range app.WatchPaths {
-			_, err = gfsnotify.Add(gfile.RealPath(path), callbackFunc)
-			if err != nil {
-				mlog.Fatal(err)
-			}
-		}
-	} else {
-		_, err = gfsnotify.Add(gfile.RealPath("."), callbackFunc)
+	// Get directories to watch (recursive or non-recursive monitoring).
+	watchPaths := app.getWatchPaths()
+	for _, wp := range watchPaths {
+		option := gfsnotify.WatchOption{NoRecursive: !wp.Recursive}
+		_, err = gfsnotify.Add(wp.Path, callbackFunc, option)
 		if err != nil {
 			mlog.Fatal(err)
 		}
@@ -207,8 +223,37 @@ func (app *cRunApp) End(ctx context.Context, sig os.Signal, outputPath string) {
 	// Delete the binary file.
 	// firstly, kill the process.
 	if process != nil {
-		if err := process.Kill(); err != nil {
-			mlog.Debugf("kill process error: %s", err.Error())
+		if sig != nil && runtime.GOOS != "windows" {
+			if err := process.Signal(sig); err != nil {
+				mlog.Debugf("send signal to process error: %s", err.Error())
+				if err := process.Kill(); err != nil {
+					mlog.Debugf("kill process error: %s", err.Error())
+				}
+			} else {
+				waitCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
+				defer cancel()
+				done := make(chan error, 1)
+				go func() {
+					select {
+					case <-waitCtx.Done():
+						done <- waitCtx.Err()
+					case done <- process.Wait():
+					}
+				}()
+				err := <-done
+				if err != nil {
+					mlog.Debugf("process wait error: %s", err.Error())
+					if err := process.Kill(); err != nil {
+						mlog.Debugf("kill process error: %s", err.Error())
+					}
+				} else {
+					mlog.Debug("process exited gracefully")
+				}
+			}
+		} else {
+			if err := process.Kill(); err != nil {
+				mlog.Debugf("kill process error: %s", err.Error())
+			}
 		}
 	}
 	if err := gfile.RemoveFile(outputPath); err != nil {
@@ -219,35 +264,181 @@ func (app *cRunApp) End(ctx context.Context, sig os.Signal, outputPath string) {
 }
 
 func (app *cRunApp) genOutputPath() (outputPath string) {
-	var renamePath string
 	outputPath = gfile.Join(app.Path, gfile.Name(app.File))
 	if runtime.GOOS == "windows" {
 		outputPath += ".exe"
 		if gfile.Exists(outputPath) {
-			renamePath = outputPath + "~"
+			renamePath := outputPath + "~"
 			if err := gfile.Rename(outputPath, renamePath); err != nil {
 				mlog.Print(err)
 			}
+			// Clean up the renamed old binary file
+			defer func() {
+				if gfile.Exists(renamePath) {
+					_ = gfile.Remove(renamePath)
+				}
+			}()
 		}
 	}
 	return filepath.FromSlash(outputPath)
 }
 
-func matchWatchPaths(watchPaths []string, eventPath string) bool {
-	for _, path := range watchPaths {
-		absPath, err := filepath.Abs(path)
-		if err != nil {
-			mlog.Printf("match watchPath '%s' error: %s", path, err.Error())
+// getWatchPaths uses DFS to find the minimal set of directories to watch.
+// Rule: if a directory and all its descendants have no ignored subdirectories, watch it;
+// otherwise, recurse into valid children and watch the current directory non-recursively.
+func (app *cRunApp) getWatchPaths() []watchPath {
+	roots := []string{"."}
+	if len(app.WatchPaths) > 0 {
+		roots = app.WatchPaths
+	}
+
+	// Use custom ignore patterns if provided, otherwise use default.
+	ignorePatterns := defaultIgnorePatterns
+	if len(app.IgnorePatterns) > 0 {
+		ignorePatterns = app.IgnorePatterns
+	}
+
+	var watchPaths []watchPath
+
+	for _, root := range roots {
+		absRoot := gfile.RealPath(root)
+		if absRoot == "" {
+			mlog.Printf("watch path '%s' not found, skipping", root)
 			continue
 		}
-		matched, err := filepath.Match(absPath, eventPath)
-		if err != nil {
-			mlog.Printf("match watchPath '%s' error: %s", path, err.Error())
+		if isIgnoredDirName(absRoot, ignorePatterns) {
 			continue
 		}
-		if matched {
+		app.collectWatchPaths(absRoot, ignorePatterns, &watchPaths)
+	}
+
+	if len(watchPaths) == 0 {
+		mlog.Printf("no directories to watch, using current directory")
+		if absCur := gfile.RealPath("."); absCur != "" {
+			return []watchPath{{Path: absCur, Recursive: true}}
+		}
+		return []watchPath{{Path: ".", Recursive: true}}
+	}
+
+	mlog.Printf("watching %d paths", len(watchPaths))
+	for _, wp := range watchPaths {
+		recursiveStr := "recursive"
+		if !wp.Recursive {
+			recursiveStr = "non-recursive"
+		}
+		mlog.Debugf("  - %s (%s)", wp.Path, recursiveStr)
+	}
+	return watchPaths
+}
+
+// collectWatchPaths performs a DFS traversal to collect the minimal set of directories to watch.
+// Returns true if the directory or any of its descendants contains ignored directories.
+// Rule: if a directory has no ignored descendants at any depth, watch it recursively;
+// otherwise, watch it non-recursively and recurse into valid children.
+func (app *cRunApp) collectWatchPaths(dir string, ignorePatterns []string, watchPaths *[]watchPath) bool {
+	entries, err := gfile.ScanDir(dir, "*", false)
+	if err != nil {
+		mlog.Printf("scan directory '%s' error: %s", dir, err.Error())
+		// If we can't scan the directory, add it to watch list as fallback
+		*watchPaths = append(*watchPaths, watchPath{Path: dir, Recursive: true})
+		return false
+	}
+
+	// First pass: identify valid subdirectories and check for directly ignored children
+	var validSubDirs []string
+	hasIgnoredChild := false
+	for _, entry := range entries {
+		if !gfile.IsDir(entry) {
+			continue
+		}
+		if isIgnoredDirName(entry, ignorePatterns) {
+			hasIgnoredChild = true
+		} else {
+			validSubDirs = append(validSubDirs, entry)
+		}
+	}
+
+	// If already has ignored child, we know this dir needs non-recursive watch
+	if hasIgnoredChild {
+		*watchPaths = append(*watchPaths, watchPath{Path: dir, Recursive: false})
+		for _, subDir := range validSubDirs {
+			app.collectWatchPaths(subDir, ignorePatterns, watchPaths)
+		}
+		return true
+	}
+
+	// No ignored children, but need to check descendants recursively
+	// Collect results from all subdirectories first
+	subResults := make([]bool, len(validSubDirs))
+	subWatchPaths := make([][]watchPath, len(validSubDirs))
+	hasIgnoredDescendant := false
+
+	for i, subDir := range validSubDirs {
+		var subPaths []watchPath
+		subResults[i] = app.collectWatchPaths(subDir, ignorePatterns, &subPaths)
+		subWatchPaths[i] = subPaths
+		if subResults[i] {
+			hasIgnoredDescendant = true
+		}
+	}
+
+	if !hasIgnoredDescendant {
+		// No ignored descendants at any depth, watch this directory recursively
+		*watchPaths = append(*watchPaths, watchPath{Path: dir, Recursive: true})
+		return false
+	}
+
+	// Has ignored descendants, watch current directory non-recursively
+	// and add all collected subdirectory watch paths
+	*watchPaths = append(*watchPaths, watchPath{Path: dir, Recursive: false})
+	for _, subPaths := range subWatchPaths {
+		*watchPaths = append(*watchPaths, subPaths...)
+	}
+	return true
+}
+
+// defaultIgnorePatterns contains glob patterns for directory names that should be ignored when watching.
+// These directories typically contain third-party code or non-source files.
+// Supported glob syntax (filepath.Match):
+//   - "*" matches any sequence of non-separator characters
+//   - "?" matches any single non-separator character
+//   - "[abc]" matches any character in the bracket
+//   - "[a-z]" matches any character in the range
+//   - "[^abc]" or "[!abc]" matches any character not in the bracket
+//
+// Note: patterns match directory base names only, not full paths (no "/" or path separators allowed).
+var defaultIgnorePatterns = []string{
+	"node_modules",
+	"vendor",
+	".*", // All hidden directories (covers .git, .svn, .hg, .idea, .vscode, etc.)
+	"_*", // Directories starting with underscore
+}
+
+// isIgnoredDirName checks if a directory name matches any ignored pattern.
+// It accepts either a full path or just the directory name, but only matches against the base name.
+// Note: patterns should not contain "/" as they only match directory names, not paths.
+func isIgnoredDirName(name string, ignorePatterns []string) bool {
+	baseName := gfile.Basename(name)
+	for _, pattern := range ignorePatterns {
+		if matched, _ := filepath.Match(pattern, baseName); matched {
 			return true
 		}
 	}
 	return false
 }
+
+// parseCommaSeparatedArgs parses command line arguments that may contain comma-separated values.
+// It handles both single argument with commas (e.g., "a,b,c") and multiple arguments.
+func parseCommaSeparatedArgs(args []string) []string {
+	var result []string
+	for _, arg := range args {
+		parts := strings.Split(arg, ",")
+		for _, part := range parts {
+			trimmed := strings.TrimSpace(part)
+			if trimmed != "" {
+				result = append(result, trimmed)
+			}
+		}
+	}
+	return result
+}
diff --git a/cmd/gf/internal/cmd/cmd_up.go b/cmd/gf/internal/cmd/cmd_up.go
index 4a43e5b6a..a0ab6c2b0 100644
--- a/cmd/gf/internal/cmd/cmd_up.go
+++ b/cmd/gf/internal/cmd/cmd_up.go
@@ -15,6 +15,7 @@ import (
 
 	"github.com/gogf/gf/v2/container/gset"
 	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/genv"
 	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/os/gproc"
 	"github.com/gogf/gf/v2/text/gstr"
@@ -39,7 +40,11 @@ gf up
 gf up -a
 gf up -c
 gf up -cf
+gf up -a -m=install
+gf up -a -m=install -p=github.com/gogf/gf/cmd/gf/v2@latest
 `
+	cliMethodHttpDownload = "http"
+	cliMethodGoInstall    = "install"
 )
 
 func init() {
@@ -49,10 +54,14 @@ func init() {
 }
 
 type cUpInput struct {
-	g.Meta `name:"up" config:"gfcli.up"`
-	All    bool `name:"all" short:"a" brief:"upgrade both version and cli, auto fix codes" orphan:"true"`
-	Cli    bool `name:"cli" short:"c" brief:"also upgrade CLI tool" orphan:"true"`
-	Fix    bool `name:"fix" short:"f" brief:"auto fix codes(it only make sense if cli is to be upgraded)" orphan:"true"`
+	g.Meta               `name:"up" config:"gfcli.up"`
+	All                  bool   `name:"all" short:"a" brief:"upgrade both version and cli, auto fix codes" orphan:"true"`
+	Cli                  bool   `name:"cli" short:"c" brief:"also upgrade CLI tool" orphan:"true"`
+	Fix                  bool   `name:"fix" short:"f" brief:"auto fix codes(it only make sense if cli is to be upgraded)" orphan:"true"`
+	CliDownloadingMethod string `name:"cli-download-method" short:"m" brief:"cli upgrade method: http=download binary via HTTP GET, install=upgrade via go install" d:"http"`
+	// CliModulePath specifies the module path for CLI installation via go install.
+	// This is used when CliDownloadingMethod is set to "install".
+	CliModulePath string `name:"cli-module-path" short:"p" brief:"custom cli module path for upgrade CLI tool with go install method" d:"github.com/gogf/gf/cmd/gf/v2@latest"`
 }
 
 type cUpOutput struct{}
@@ -76,7 +85,7 @@ func (c cUp) Index(ctx context.Context, in cUpInput) (out *cUpOutput, err error)
 	}
 
 	if in.Cli {
-		if err = c.doUpgradeCLI(ctx); err != nil {
+		if err = c.doUpgradeCLI(ctx, in); err != nil {
 			return nil, err
 		}
 	}
@@ -170,8 +179,22 @@ func (c cUp) doUpgradeVersion(ctx context.Context, in cUpInput) (out *doUpgradeV
 }
 
 // doUpgradeCLI downloads the new version binary with process.
-func (c cUp) doUpgradeCLI(ctx context.Context) (err error) {
+func (c cUp) doUpgradeCLI(ctx context.Context, in cUpInput) (err error) {
 	mlog.Print(`start upgrading cli...`)
+	fmt.Println(` cli upgrade method:`, in.CliDownloadingMethod)
+	switch in.CliDownloadingMethod {
+	case cliMethodHttpDownload:
+		return c.doUpgradeCLIWithHttpDownload(ctx)
+	case cliMethodGoInstall:
+		return c.doUpgradeCLIWithGoInstall(ctx, in)
+	default:
+		mlog.Fatalf(`invalid cli upgrade method: "%s", please use "http" or "install"`, in.CliDownloadingMethod)
+	}
+	return
+}
+
+func (c cUp) doUpgradeCLIWithHttpDownload(ctx context.Context) (err error) {
+	mlog.Print(`start upgrading cli with http get download...`)
 	var (
 		downloadUrl = fmt.Sprintf(
 			`https://github.com/gogf/gf/releases/latest/download/gf_%s_%s`,
@@ -213,6 +236,41 @@ func (c cUp) doUpgradeCLI(ctx context.Context) (err error) {
 	return
 }
 
+func (c cUp) doUpgradeCLIWithGoInstall(ctx context.Context, in cUpInput) (err error) {
+	mlog.Print(`upgrading cli with go install...`)
+	if !genv.Contains("GOPATH") {
+		mlog.Fatal(`"GOPATH" environment variable does not exist, please check your go installation`)
+	}
+
+	command := fmt.Sprintf(`go install %s`, in.CliModulePath)
+	mlog.Printf(`running command: %s`, command)
+	err = gproc.ShellRun(ctx, command)
+	if err != nil {
+		return err
+	}
+
+	cliFilePath := gfile.Join(genv.Get("GOPATH").String(), "bin/gf")
+	if runtime.GOOS == "windows" {
+		cliFilePath += ".exe"
+	}
+
+	// It fails if file not exist or its size is less than 1MB.
+	if !gfile.Exists(cliFilePath) || gfile.Size(cliFilePath) < 1024*1024 {
+		mlog.Fatalf(`go install %s failed, "%s" does not exist or its size is less than 1MB`, in.CliModulePath, cliFilePath)
+	}
+
+	newFile, err := gfile.Open(cliFilePath)
+	if err != nil {
+		return err
+	}
+	// selfupdate
+	err = selfupdate.Apply(newFile, selfupdate.Options{})
+	if err != nil {
+		return err
+	}
+	return
+}
+
 func (c cUp) doAutoFixing(ctx context.Context, dirPath string, version string) (err error) {
 	mlog.Printf(`auto fixing directory path "%s" from version "%s" ...`, dirPath, version)
 	command := fmt.Sprintf(`gf fix -p %s`, dirPath)
diff --git a/cmd/gf/internal/cmd/cmd_z_init_test.go b/cmd/gf/internal/cmd/cmd_z_init_test.go
index 1e71cbd8b..d066a2599 100644
--- a/cmd/gf/internal/cmd/cmd_z_init_test.go
+++ b/cmd/gf/internal/cmd/cmd_z_init_test.go
@@ -15,9 +15,11 @@ import (
 )
 
 var (
-	ctx    = context.Background()
-	testDB gdb.DB
-	link   = "mysql:root:12345678@tcp(127.0.0.1:3306)/test?loc=Local&parseTime=true"
+	ctx      = context.Background()
+	testDB   gdb.DB
+	testPgDB gdb.DB
+	link     = "mysql:root:12345678@tcp(127.0.0.1:3306)/test?loc=Local&parseTime=true"
+	linkPg   = "pgsql:postgres:12345678@tcp(127.0.0.1:5432)/test"
 )
 
 func init() {
@@ -28,6 +30,10 @@ func init() {
 	if err != nil {
 		panic(err)
 	}
+	// PostgreSQL connection (optional, may not be available in all environments)
+	testPgDB, _ = gdb.New(gdb.ConfigNode{
+		Link: linkPg,
+	})
 }
 
 func dropTableWithDb(db gdb.DB, table string) {
@@ -36,3 +42,11 @@ func dropTableWithDb(db gdb.DB, table string) {
 		gtest.Error(err)
 	}
 }
+
+// dropTableStd uses standard SQL syntax compatible with MySQL and PostgreSQL.
+func dropTableStd(db gdb.DB, table string) {
+	dropTableStmt := fmt.Sprintf("DROP TABLE IF EXISTS %s", table)
+	if _, err := db.Exec(ctx, dropTableStmt); err != nil {
+		gtest.Error(err)
+	}
+}
diff --git a/cmd/gf/internal/cmd/cmd_z_unit_env_test.go b/cmd/gf/internal/cmd/cmd_z_unit_env_test.go
new file mode 100644
index 000000000..cecb67edc
--- /dev/null
+++ b/cmd/gf/internal/cmd/cmd_z_unit_env_test.go
@@ -0,0 +1,84 @@
+// Copyright GoFrame gf 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 cmd
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+)
+
+func Test_Env_Index(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test that env command runs without error
+		_, err := Env.Index(ctx, cEnvInput{})
+		t.AssertNil(err)
+	})
+}
+
+func Test_Env_ParseGoEnvOutput(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test parsing normal go env output
+		lines := []string{
+			"set GOPATH=C:\\Users\\test\\go",
+			"set GOROOT=C:\\Go",
+			"set GOOS=windows",
+			"GOARCH=amd64", // Unix format without "set " prefix
+			"CGO_ENABLED=0",
+		}
+
+		for _, line := range lines {
+			line = gstr.Trim(line)
+			if gstr.Pos(line, "set ") == 0 {
+				line = line[4:]
+			}
+			match, _ := gregex.MatchString(`(.+?)=(.*)`, line)
+			t.Assert(len(match) >= 3, true)
+		}
+	})
+}
+
+func Test_Env_ParseGoEnvOutput_WithWarnings(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test parsing go env output that contains warning messages
+		// These lines should be skipped without causing errors
+		lines := []string{
+			"go: stripping unprintable or unescapable characters from %\"GOPROXY\"%",
+			"go: warning: some warning message",
+			"# this is a comment",
+			"",
+			"set GOPATH=C:\\Users\\test\\go",
+			"set GOOS=windows",
+		}
+
+		array := make([][]string, 0)
+		for _, line := range lines {
+			line = gstr.Trim(line)
+			if line == "" {
+				continue
+			}
+			if gstr.Pos(line, "set ") == 0 {
+				line = line[4:]
+			}
+			match, _ := gregex.MatchString(`(.+?)=(.*)`, line)
+			if len(match) < 3 {
+				// Skip lines that don't match key=value format (e.g., warning messages)
+				continue
+			}
+			array = append(array, []string{gstr.Trim(match[1]), gstr.Trim(match[2])})
+		}
+
+		// Should have parsed 2 valid environment variables
+		t.Assert(len(array), 2)
+		t.Assert(array[0][0], "GOPATH")
+		t.Assert(array[0][1], "C:\\Users\\test\\go")
+		t.Assert(array[1][0], "GOOS")
+		t.Assert(array[1][1], "windows")
+	})
+}
diff --git a/cmd/gf/internal/cmd/cmd_z_unit_fix_test.go b/cmd/gf/internal/cmd/cmd_z_unit_fix_test.go
index ad53e4129..bd456f786 100644
--- a/cmd/gf/internal/cmd/cmd_z_unit_fix_test.go
+++ b/cmd/gf/internal/cmd/cmd_z_unit_fix_test.go
@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/text/gstr"
 )
 
 func Test_Fix_doFixV25Content(t *testing.T) {
@@ -22,3 +23,82 @@ func Test_Fix_doFixV25Content(t *testing.T) {
 		t.AssertNil(err)
 	})
 }
+
+func Test_Fix_doFixV25Content_WithReplacement(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			f       = cFix{}
+			content = `s.BindHookHandlerByMap("/path", map[string]ghttp.HandlerFunc{
+				ghttp.HookBeforeServe: func(r *ghttp.Request) {},
+			})`
+		)
+		newContent, err := f.doFixV25Content(content)
+		t.AssertNil(err)
+		// Verify the replacement was made
+		t.Assert(gstr.Contains(newContent, "map[ghttp.HookName]ghttp.HandlerFunc"), true)
+		t.Assert(gstr.Contains(newContent, "map[string]ghttp.HandlerFunc"), false)
+	})
+}
+
+func Test_Fix_doFixV25Content_NoMatch(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			f       = cFix{}
+			content = `package main
+
+func main() {
+	fmt.Println("Hello World")
+}
+`
+		)
+		newContent, err := f.doFixV25Content(content)
+		t.AssertNil(err)
+		// Content should remain unchanged
+		t.Assert(newContent, content)
+	})
+}
+
+func Test_Fix_doFixV25Content_MultipleMatches(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			f       = cFix{}
+			content = `
+s.BindHookHandlerByMap("/path1", map[string]ghttp.HandlerFunc{})
+s.BindHookHandlerByMap("/path2", map[string]ghttp.HandlerFunc{})
+`
+		)
+		newContent, err := f.doFixV25Content(content)
+		t.AssertNil(err)
+		// Both should be replaced
+		count := gstr.Count(newContent, "map[ghttp.HookName]ghttp.HandlerFunc")
+		t.Assert(count, 2)
+	})
+}
+
+func Test_Fix_doFixV25Content_EmptyContent(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			f       = cFix{}
+			content = ""
+		)
+		newContent, err := f.doFixV25Content(content)
+		t.AssertNil(err)
+		t.Assert(newContent, "")
+	})
+}
+
+func Test_Fix_doFixV25Content_ComplexPath(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			f       = cFix{}
+			content = `s.BindHookHandlerByMap("/api/v1/user/{id}/profile", map[string]ghttp.HandlerFunc{
+				ghttp.HookBeforeServe: func(r *ghttp.Request) {
+					r.Response.Write("before")
+				},
+			})`
+		)
+		newContent, err := f.doFixV25Content(content)
+		t.AssertNil(err)
+		t.Assert(gstr.Contains(newContent, "map[ghttp.HookName]ghttp.HandlerFunc"), true)
+	})
+}
diff --git a/cmd/gf/internal/cmd/cmd_z_unit_gen_ctrl_test.go b/cmd/gf/internal/cmd/cmd_z_unit_gen_ctrl_test.go
index 55986b480..3fd9dfd1d 100644
--- a/cmd/gf/internal/cmd/cmd_z_unit_gen_ctrl_test.go
+++ b/cmd/gf/internal/cmd/cmd_z_unit_gen_ctrl_test.go
@@ -22,7 +22,7 @@ func Test_Gen_Ctrl_Default(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (
 			path      = gfile.Temp(guid.S())
-			apiFolder = gtest.DataPath("genctrl", "api")
+			apiFolder = gtest.DataPath("genctrl", "default", "api")
 			in        = genctrl.CGenCtrlInput{
 				SrcFolder:     apiFolder,
 				DstFolder:     path,
@@ -39,7 +39,7 @@ func Test_Gen_Ctrl_Default(t *testing.T) {
 
 		err = gfile.Mkdir(path)
 		t.AssertNil(err)
-		defer gfile.Remove(path)
+		defer gfile.RemoveAll(path)
 
 		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
 		t.AssertNil(err)
@@ -49,7 +49,7 @@ func Test_Gen_Ctrl_Default(t *testing.T) {
 			genApi       = apiFolder + filepath.FromSlash("/article/article.go")
 			genApiExpect = apiFolder + filepath.FromSlash("/article/article_expect.go")
 		)
-		defer gfile.Remove(genApi)
+		defer gfile.RemoveAll(genApi)
 		t.Assert(gfile.GetContents(genApi), gfile.GetContents(genApiExpect))
 
 		// files
@@ -67,7 +67,7 @@ func Test_Gen_Ctrl_Default(t *testing.T) {
 		})
 
 		// content
-		testPath := gtest.DataPath("genctrl", "controller")
+		testPath := gtest.DataPath("genctrl", "default", "controller")
 		expectFiles := []string{
 			testPath + filepath.FromSlash("/article/article.go"),
 			testPath + filepath.FromSlash("/article/article_new.go"),
@@ -84,6 +84,104 @@ func Test_Gen_Ctrl_Default(t *testing.T) {
 	})
 }
 
+func Test_Gen_Ctrl_Default_Multi(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			path      = gfile.Temp(guid.S())
+			apiFolder = gtest.DataPath("genctrl", "multi", "api")
+			in        = genctrl.CGenCtrlInput{
+				SrcFolder:     apiFolder,
+				DstFolder:     path,
+				WatchFile:     "",
+				SdkPath:       "",
+				SdkStdVersion: false,
+				SdkNoV1:       false,
+				Clear:         false,
+				Merge:         false,
+			}
+		)
+
+		err := gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+		defer gfile.RemoveAll(path)
+
+		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
+		t.AssertNil(err)
+
+		// apiInterface file
+		var (
+			genApiSlice = []string{
+				apiFolder + filepath.FromSlash("/admin/article/article.go"),
+				apiFolder + filepath.FromSlash("/admin/user/user.go"),
+				apiFolder + filepath.FromSlash("/app/user/user.go"),
+				apiFolder + filepath.FromSlash("/app/user/user_ext/user_ext.go"),
+			}
+			genApiSliceExpect = []string{
+				apiFolder + filepath.FromSlash("/admin/article/article_expect.go"),
+				apiFolder + filepath.FromSlash("/admin/user/user_expect.go"),
+				apiFolder + filepath.FromSlash("/app/user/user_expect.go"),
+				apiFolder + filepath.FromSlash("/app/user/user_ext/user_ext_expect.go"),
+			}
+		)
+
+		for i := range genApiSlice {
+			t.Assert(gfile.GetContents(genApiSlice[i]), gfile.GetContents(genApiSliceExpect[i]))
+			gfile.RemoveAll(genApiSlice[i])
+		}
+
+		// files
+		files, err := gfile.ScanDir(path, "*.go", true)
+		t.AssertNil(err)
+		t.Assert(files, []string{
+			path + filepath.FromSlash("/admin/article/article.go"),
+			path + filepath.FromSlash("/admin/article/article_new.go"),
+			path + filepath.FromSlash("/admin/article/article_v1_create.go"),
+
+			path + filepath.FromSlash("/admin/user/user.go"),
+			path + filepath.FromSlash("/admin/user/user_new.go"),
+			path + filepath.FromSlash("/admin/user/user_v1_create.go"),
+
+			path + filepath.FromSlash("/app/user/user.go"),
+			path + filepath.FromSlash("/app/user/user_ext/user_ext.go"),
+			path + filepath.FromSlash("/app/user/user_ext/user_ext_new.go"),
+			path + filepath.FromSlash("/app/user/user_ext/user_ext_v1_create.go"),
+			path + filepath.FromSlash("/app/user/user_ext/user_ext_v1_update.go"),
+
+			path + filepath.FromSlash("/app/user/user_new.go"),
+			path + filepath.FromSlash("/app/user/user_v1_create.go"),
+			path + filepath.FromSlash("/app/user/user_v1_update.go"),
+		})
+
+		// content
+		testPath := gtest.DataPath("genctrl", "multi", "controller")
+		expectFiles := []string{
+			testPath + filepath.FromSlash("/admin/article/article.go"),
+			testPath + filepath.FromSlash("/admin/article/article_new.go"),
+			testPath + filepath.FromSlash("/admin/article/article_v1_create.go"),
+
+			testPath + filepath.FromSlash("/admin/user/user.go"),
+			testPath + filepath.FromSlash("/admin/user/user_new.go"),
+			testPath + filepath.FromSlash("/admin/user/user_v1_create.go"),
+
+			testPath + filepath.FromSlash("/app/user/user.go"),
+			testPath + filepath.FromSlash("/app/user/user_ext/user_ext.go"),
+			testPath + filepath.FromSlash("/app/user/user_ext/user_ext_new.go"),
+			testPath + filepath.FromSlash("/app/user/user_ext/user_ext_v1_create.go"),
+			testPath + filepath.FromSlash("/app/user/user_ext/user_ext_v1_update.go"),
+
+			testPath + filepath.FromSlash("/app/user/user_new.go"),
+			testPath + filepath.FromSlash("/app/user/user_v1_create.go"),
+			testPath + filepath.FromSlash("/app/user/user_v1_update.go"),
+		}
+		for i := range files {
+			t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
+		}
+	})
+}
+
 func expectFilesContent(t *gtest.T, paths []string, expectPaths []string) {
 	for i, expectFile := range expectPaths {
 		val := gfile.GetContents(paths[i])
@@ -98,8 +196,8 @@ func Test_Gen_Ctrl_UseMerge_AddNewFile(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (
 			ctrlPath = gfile.Temp(guid.S())
-			//ctrlPath  = gtest.DataPath("issue", "3460", "controller")
-			apiFolder = gtest.DataPath("genctrl-merge", "add_new_file", "api")
+			// ctrlPath  = gtest.DataPath("issue", "3460", "controller")
+			apiFolder = gtest.DataPath("genctrl", "merge", "add_new_file", "api")
 			in        = genctrl.CGenCtrlInput{
 				SrcFolder: apiFolder,
 				DstFolder: ctrlPath,
@@ -118,7 +216,7 @@ type DictTypeAddRes struct {
 
 		err := gfile.Mkdir(ctrlPath)
 		t.AssertNil(err)
-		defer gfile.Remove(ctrlPath)
+		defer gfile.RemoveAll(ctrlPath)
 
 		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
 		t.AssertNil(err)
@@ -127,7 +225,7 @@ type DictTypeAddRes struct {
 			genApi       = filepath.Join(apiFolder, "/dict/dict.go")
 			genApiExpect = filepath.Join(apiFolder, "/dict/dict_expect.go")
 		)
-		defer gfile.Remove(genApi)
+		defer gfile.RemoveAll(genApi)
 		t.Assert(gfile.GetContents(genApi), gfile.GetContents(genApiExpect))
 
 		genCtrlFiles, err := gfile.ScanDir(ctrlPath, "*.go", true)
@@ -138,7 +236,7 @@ type DictTypeAddRes struct {
 			filepath.Join(ctrlPath, "/dict/dict_v1_dict_type.go"),
 		})
 
-		expectCtrlPath := gtest.DataPath("genctrl-merge", "add_new_file", "controller")
+		expectCtrlPath := gtest.DataPath("genctrl", "merge", "add_new_file", "controller")
 		expectFiles := []string{
 			filepath.Join(expectCtrlPath, "/dict/dict.go"),
 			filepath.Join(expectCtrlPath, "/dict/dict_new.go"),
@@ -152,7 +250,7 @@ type DictTypeAddRes struct {
 		newApiFilePath := filepath.Join(apiFolder, "/dict/v1/test_new.go")
 		err = gfile.PutContents(newApiFilePath, testNewApiFile)
 		t.AssertNil(err)
-		defer gfile.Remove(newApiFilePath)
+		defer gfile.RemoveAll(newApiFilePath)
 
 		// Then execute the command
 		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
@@ -179,8 +277,8 @@ func Test_Gen_Ctrl_UseMerge_AddNewCtrl(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (
 			ctrlPath = gfile.Temp(guid.S())
-			//ctrlPath  = gtest.DataPath("issue", "3460", "controller")
-			apiFolder = gtest.DataPath("genctrl-merge", "add_new_ctrl", "api")
+			// ctrlPath  = gtest.DataPath("issue", "3460", "controller")
+			apiFolder = gtest.DataPath("genctrl", "merge", "add_new_ctrl", "api")
 			in        = genctrl.CGenCtrlInput{
 				SrcFolder: apiFolder,
 				DstFolder: ctrlPath,
@@ -190,7 +288,7 @@ func Test_Gen_Ctrl_UseMerge_AddNewCtrl(t *testing.T) {
 
 		err := gfile.Mkdir(ctrlPath)
 		t.AssertNil(err)
-		defer gfile.Remove(ctrlPath)
+		defer gfile.RemoveAll(ctrlPath)
 
 		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
 		t.AssertNil(err)
@@ -199,7 +297,7 @@ func Test_Gen_Ctrl_UseMerge_AddNewCtrl(t *testing.T) {
 			genApi       = filepath.Join(apiFolder, "/dict/dict.go")
 			genApiExpect = filepath.Join(apiFolder, "/dict/dict_expect.go")
 		)
-		defer gfile.Remove(genApi)
+		defer gfile.RemoveAll(genApi)
 		t.Assert(gfile.GetContents(genApi), gfile.GetContents(genApiExpect))
 
 		genCtrlFiles, err := gfile.ScanDir(ctrlPath, "*.go", true)
@@ -210,7 +308,7 @@ func Test_Gen_Ctrl_UseMerge_AddNewCtrl(t *testing.T) {
 			filepath.Join(ctrlPath, "/dict/dict_v1_dict_type.go"),
 		})
 
-		expectCtrlPath := gtest.DataPath("genctrl-merge", "add_new_ctrl", "controller")
+		expectCtrlPath := gtest.DataPath("genctrl", "merge", "add_new_ctrl", "controller")
 		expectFiles := []string{
 			filepath.Join(expectCtrlPath, "/dict/dict.go"),
 			filepath.Join(expectCtrlPath, "/dict/dict_new.go"),
@@ -236,7 +334,7 @@ type DictTypeAddRes struct {
 		err = gfile.PutContentsAppend(dictModuleFileName, testNewApiFile)
 		t.AssertNil(err)
 
-		//==================================
+		// ==================================
 		// Then execute the command
 		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
 		t.AssertNil(err)
@@ -262,7 +360,7 @@ func Test_Gen_Ctrl_UseMerge_Issue3460(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (
 			ctrlPath = gfile.Temp(guid.S())
-			//ctrlPath  = gtest.DataPath("issue", "3460", "controller")
+			// ctrlPath  = gtest.DataPath("issue", "3460", "controller")
 			apiFolder = gtest.DataPath("issue", "3460", "api")
 			in        = genctrl.CGenCtrlInput{
 				SrcFolder:     apiFolder,
@@ -278,7 +376,7 @@ func Test_Gen_Ctrl_UseMerge_Issue3460(t *testing.T) {
 
 		err := gfile.Mkdir(ctrlPath)
 		t.AssertNil(err)
-		defer gfile.Remove(ctrlPath)
+		defer gfile.RemoveAll(ctrlPath)
 
 		_, err = genctrl.CGenCtrl{}.Ctrl(ctx, in)
 		t.AssertNil(err)
diff --git a/cmd/gf/internal/cmd/cmd_z_unit_gen_dao_issue_test.go b/cmd/gf/internal/cmd/cmd_z_unit_gen_dao_issue_test.go
index 1ed9853e5..3a8421fda 100644
--- a/cmd/gf/internal/cmd/cmd_z_unit_gen_dao_issue_test.go
+++ b/cmd/gf/internal/cmd/cmd_z_unit_gen_dao_issue_test.go
@@ -66,6 +66,7 @@ func Test_Gen_Dao_Issue2572(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping:        nil,
 				FieldMapping:       nil,
 			}
@@ -155,6 +156,7 @@ func Test_Gen_Dao_Issue2616(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping:        nil,
 				FieldMapping:       nil,
 			}
@@ -266,6 +268,7 @@ func Test_Gen_Dao_Issue2746(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping:        nil,
 				FieldMapping:       nil,
 			}
@@ -338,6 +341,7 @@ func Test_Gen_Dao_Issue3459(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping:        nil,
 			}
 		)
@@ -456,3 +460,398 @@ func Test_Gen_Dao_Issue3749(t *testing.T) {
 		}
 	})
 }
+
+// https://github.com/gogf/gf/issues/4629
+// Test tables pattern matching with * wildcard.
+func Test_Gen_Dao_Issue4629_TablesPattern_Star(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testDB
+			table1      = "trade_order"
+			table2      = "trade_item"
+			table3      = "user_info"
+			table4      = "user_log"
+			table5      = "config"
+			sqlFilePath = gtest.DataPath(`gendao`, `tables_pattern.sql`)
+		)
+		dropTableStd(db, table1)
+		dropTableStd(db, table2)
+		dropTableStd(db, table3)
+		dropTableStd(db, table4)
+		dropTableStd(db, table5)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableStd(db, table1)
+		defer dropTableStd(db, table2)
+		defer dropTableStd(db, table3)
+		defer dropTableStd(db, table4)
+		defer dropTableStd(db, table5)
+
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:   path,
+				Link:   link,
+				Group:  group,
+				Tables: "trade_*", // Should match trade_order, trade_item
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 2 dao files: trade_order.go, trade_item.go
+		generatedFiles, err := gfile.ScanDir(gfile.Join(path, "dao"), "*.go", false)
+		t.AssertNil(err)
+		t.Assert(len(generatedFiles), 2)
+
+		// Verify the correct files are generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_order.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_item.go")), true)
+		// user_* and config should NOT be generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_info.go")), false)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_log.go")), false)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "config.go")), false)
+	})
+}
+
+// https://github.com/gogf/gf/issues/4629
+// Test tables pattern matching with multiple patterns.
+func Test_Gen_Dao_Issue4629_TablesPattern_Multiple(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testDB
+			table1      = "trade_order"
+			table2      = "trade_item"
+			table3      = "user_info"
+			table4      = "user_log"
+			table5      = "config"
+			sqlFilePath = gtest.DataPath(`gendao`, `tables_pattern.sql`)
+		)
+		dropTableStd(db, table1)
+		dropTableStd(db, table2)
+		dropTableStd(db, table3)
+		dropTableStd(db, table4)
+		dropTableStd(db, table5)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableStd(db, table1)
+		defer dropTableStd(db, table2)
+		defer dropTableStd(db, table3)
+		defer dropTableStd(db, table4)
+		defer dropTableStd(db, table5)
+
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:   path,
+				Link:   link,
+				Group:  group,
+				Tables: "trade_*,user_*", // Should match trade_order, trade_item, user_info, user_log
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 4 dao files
+		generatedFiles, err := gfile.ScanDir(gfile.Join(path, "dao"), "*.go", false)
+		t.AssertNil(err)
+		t.Assert(len(generatedFiles), 4)
+
+		// Verify the correct files are generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_order.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_item.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_info.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_log.go")), true)
+		// config should NOT be generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "config.go")), false)
+	})
+}
+
+// https://github.com/gogf/gf/issues/4629
+// Test tables pattern mixed with exact table name.
+func Test_Gen_Dao_Issue4629_TablesPattern_Mixed(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testDB
+			table1      = "trade_order"
+			table2      = "trade_item"
+			table3      = "user_info"
+			table4      = "user_log"
+			table5      = "config"
+			sqlFilePath = gtest.DataPath(`gendao`, `tables_pattern.sql`)
+		)
+		dropTableStd(db, table1)
+		dropTableStd(db, table2)
+		dropTableStd(db, table3)
+		dropTableStd(db, table4)
+		dropTableStd(db, table5)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableStd(db, table1)
+		defer dropTableStd(db, table2)
+		defer dropTableStd(db, table3)
+		defer dropTableStd(db, table4)
+		defer dropTableStd(db, table5)
+
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:   path,
+				Link:   link,
+				Group:  group,
+				Tables: "trade_*,config", // Pattern + exact name
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 3 dao files: trade_order.go, trade_item.go, config.go
+		generatedFiles, err := gfile.ScanDir(gfile.Join(path, "dao"), "*.go", false)
+		t.AssertNil(err)
+		t.Assert(len(generatedFiles), 3)
+
+		// Verify the correct files are generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_order.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_item.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "config.go")), true)
+		// user_* should NOT be generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_info.go")), false)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_log.go")), false)
+	})
+}
+
+// https://github.com/gogf/gf/issues/4629
+// Test tables pattern with ? wildcard (single character match).
+func Test_Gen_Dao_Issue4629_TablesPattern_Question(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testDB
+			table1      = "trade_order"
+			table2      = "trade_item"
+			table3      = "user_info"
+			table4      = "user_log"
+			table5      = "config"
+			sqlFilePath = gtest.DataPath(`gendao`, `tables_pattern.sql`)
+		)
+		dropTableStd(db, table1)
+		dropTableStd(db, table2)
+		dropTableStd(db, table3)
+		dropTableStd(db, table4)
+		dropTableStd(db, table5)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableStd(db, table1)
+		defer dropTableStd(db, table2)
+		defer dropTableStd(db, table3)
+		defer dropTableStd(db, table4)
+		defer dropTableStd(db, table5)
+
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:   path,
+				Link:   link,
+				Group:  group,
+				Tables: "user_???", // ? matches single char: user_log (3 chars) but not user_info (4 chars)
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 1 dao file: user_log.go (3 chars after user_)
+		generatedFiles, err := gfile.ScanDir(gfile.Join(path, "dao"), "*.go", false)
+		t.AssertNil(err)
+		t.Assert(len(generatedFiles), 1)
+
+		// Verify only user_log is generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_log.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_info.go")), false) // 4 chars, doesn't match
+	})
+}
+
+// https://github.com/gogf/gf/issues/4629
+// Test that exact table names still work (backward compatibility).
+func Test_Gen_Dao_Issue4629_TablesPattern_ExactNames(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testDB
+			table1      = "trade_order"
+			table2      = "trade_item"
+			table3      = "user_info"
+			table4      = "user_log"
+			table5      = "config"
+			sqlFilePath = gtest.DataPath(`gendao`, `tables_pattern.sql`)
+		)
+		dropTableStd(db, table1)
+		dropTableStd(db, table2)
+		dropTableStd(db, table3)
+		dropTableStd(db, table4)
+		dropTableStd(db, table5)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableStd(db, table1)
+		defer dropTableStd(db, table2)
+		defer dropTableStd(db, table3)
+		defer dropTableStd(db, table4)
+		defer dropTableStd(db, table5)
+
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:   path,
+				Link:   link,
+				Group:  group,
+				Tables: "trade_order,config", // Exact names, no patterns
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 2 dao files
+		generatedFiles, err := gfile.ScanDir(gfile.Join(path, "dao"), "*.go", false)
+		t.AssertNil(err)
+		t.Assert(len(generatedFiles), 2)
+
+		// Verify exactly the specified tables are generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_order.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "config.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_item.go")), false)
+	})
+}
+
+// https://github.com/gogf/gf/issues/4629
+// Test tables pattern matching with PostgreSQL.
+func Test_Gen_Dao_Issue4629_TablesPattern_PgSql(t *testing.T) {
+	if testPgDB == nil {
+		t.Skip("PostgreSQL database not available, skipping test")
+		return
+	}
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testPgDB
+			table1      = "trade_order"
+			table2      = "trade_item"
+			table3      = "user_info"
+			table4      = "user_log"
+			table5      = "config"
+			sqlFilePath = gtest.DataPath(`gendao`, `tables_pattern.sql`)
+		)
+		dropTableStd(db, table1)
+		dropTableStd(db, table2)
+		dropTableStd(db, table3)
+		dropTableStd(db, table4)
+		dropTableStd(db, table5)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableStd(db, table1)
+		defer dropTableStd(db, table2)
+		defer dropTableStd(db, table3)
+		defer dropTableStd(db, table4)
+		defer dropTableStd(db, table5)
+
+		// Test tables pattern with tablesEx pattern
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:     path,
+				Link:     linkPg,
+				Group:    group,
+				Tables:   "trade_*,user_*,config", // Match only our test tables
+				TablesEx: "user_*",                // Exclude user_* tables
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 3 dao files: trade_order, trade_item, config (user_* excluded by tablesEx)
+		generatedFiles, err := gfile.ScanDir(gfile.Join(path, "dao"), "*.go", false)
+		t.AssertNil(err)
+		t.Assert(len(generatedFiles), 3)
+
+		// Verify the correct files are generated
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_order.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "trade_item.go")), true)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "config.go")), true)
+		// user_* should NOT be generated (excluded by tablesEx)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_info.go")), false)
+		t.Assert(gfile.Exists(gfile.Join(path, "dao", "user_log.go")), false)
+	})
+}
diff --git a/cmd/gf/internal/cmd/cmd_z_unit_gen_dao_sharding_test.go b/cmd/gf/internal/cmd/cmd_z_unit_gen_dao_sharding_test.go
index 5a3989667..df2a7a45d 100644
--- a/cmd/gf/internal/cmd/cmd_z_unit_gen_dao_sharding_test.go
+++ b/cmd/gf/internal/cmd/cmd_z_unit_gen_dao_sharding_test.go
@@ -18,6 +18,92 @@ import (
 	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/gendao"
 )
 
+// Test_Gen_Dao_Sharding_Overlapping tests the fix for issue #4603.
+// When sharding patterns have overlapping prefixes (like "a_?", "a_b_?", "a_c_?"),
+// longer (more specific) patterns should be matched first.
+// https://github.com/gogf/gf/issues/4603
+func Test_Gen_Dao_Sharding_Overlapping(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err         error
+			db          = testDB
+			tableA1     = "a_1"
+			tableA2     = "a_2"
+			tableAB1    = "a_b_1"
+			tableAB2    = "a_b_2"
+			tableAC1    = "a_c_1"
+			tableAC2    = "a_c_2"
+			sqlFilePath = gtest.DataPath(`gendao`, `sharding`, `sharding_overlapping.sql`)
+		)
+		dropTableWithDb(db, tableA1)
+		dropTableWithDb(db, tableA2)
+		dropTableWithDb(db, tableAB1)
+		dropTableWithDb(db, tableAB2)
+		dropTableWithDb(db, tableAC1)
+		dropTableWithDb(db, tableAC2)
+		t.AssertNil(execSqlFile(db, sqlFilePath))
+		defer dropTableWithDb(db, tableA1)
+		defer dropTableWithDb(db, tableA2)
+		defer dropTableWithDb(db, tableAB1)
+		defer dropTableWithDb(db, tableAB2)
+		defer dropTableWithDb(db, tableAC1)
+		defer dropTableWithDb(db, tableAC2)
+
+		var (
+			path  = gfile.Temp(guid.S())
+			group = "test"
+			in    = gendao.CGenDaoInput{
+				Path:   path,
+				Link:   link,
+				Group:  group,
+				Prefix: "",
+				// Patterns with overlapping prefixes - order should not matter due to sorting fix
+				ShardingPattern: []string{
+					`a_?`,   // shortest, matches a_1, a_2 but also a_b_1, a_c_1 without fix
+					`a_b_?`, // longer, should match a_b_1, a_b_2
+					`a_c_?`, // longer, should match a_c_1, a_c_2
+				},
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+
+		pwd := gfile.Pwd()
+		err = gfile.Chdir(path)
+		t.AssertNil(err)
+		defer gfile.Chdir(pwd)
+		defer gfile.RemoveAll(path)
+
+		_, err = gendao.CGenDao{}.Dao(ctx, in)
+		t.AssertNil(err)
+
+		// Should generate 3 dao files: a.go, a_b.go, a_c.go (plus internal versions)
+		generatedFiles, err := gfile.ScanDir(path, "*.go", true)
+		t.AssertNil(err)
+		// 3 sharding groups * 4 files each (dao, internal, do, entity) = 12 files
+		t.Assert(len(generatedFiles), 12)
+
+		var (
+			daoAContent  = gfile.GetContents(gfile.Join(path, "dao", "a.go"))
+			daoABContent = gfile.GetContents(gfile.Join(path, "dao", "a_b.go"))
+			daoACContent = gfile.GetContents(gfile.Join(path, "dao", "a_c.go"))
+		)
+
+		// Verify each sharding group has correct dao file generated
+		t.Assert(gstr.Contains(daoAContent, "aShardingHandler"), true)
+		t.Assert(gstr.Contains(daoAContent, "m.Sharding(gdb.ShardingConfig{"), true)
+
+		t.Assert(gstr.Contains(daoABContent, "aBShardingHandler"), true)
+		t.Assert(gstr.Contains(daoABContent, "m.Sharding(gdb.ShardingConfig{"), true)
+
+		t.Assert(gstr.Contains(daoACContent, "aCShardingHandler"), true)
+		t.Assert(gstr.Contains(daoACContent, "m.Sharding(gdb.ShardingConfig{"), true)
+	})
+}
+
 func Test_Gen_Dao_Sharding(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (
diff --git a/cmd/gf/internal/cmd/cmd_z_unit_gen_dao_test.go b/cmd/gf/internal/cmd/cmd_z_unit_gen_dao_test.go
index bbe18735d..863c1090e 100644
--- a/cmd/gf/internal/cmd/cmd_z_unit_gen_dao_test.go
+++ b/cmd/gf/internal/cmd/cmd_z_unit_gen_dao_test.go
@@ -69,6 +69,7 @@ func Test_Gen_Dao_Default(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping:        nil,
 				FieldMapping:       nil,
 			}
@@ -161,6 +162,7 @@ func Test_Gen_Dao_TypeMapping(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping: map[gendao.DBFieldTypeName]gendao.CustomAttributeType{
 					"int": {
 						Type:   "int64",
@@ -263,6 +265,7 @@ func Test_Gen_Dao_FieldMapping(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping: map[gendao.DBFieldTypeName]gendao.CustomAttributeType{
 					"int": {
 						Type:   "int64",
diff --git a/cmd/gf/internal/cmd/cmd_z_unit_gen_enums_test.go b/cmd/gf/internal/cmd/cmd_z_unit_gen_enums_test.go
new file mode 100644
index 000000000..1cee880a7
--- /dev/null
+++ b/cmd/gf/internal/cmd/cmd_z_unit_gen_enums_test.go
@@ -0,0 +1,158 @@
+// Copyright GoFrame gf 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 cmd
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/guid"
+	"github.com/gogf/gf/v2/util/gutil"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/genenums"
+)
+
+// https://github.com/gogf/gf/issues/4387
+// Test that the output path is relative to the original working directory,
+// not the source directory after Chdir.
+func Test_Gen_Enums_Issue4387_RelativePath(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			// Create temp directory to simulate user's project
+			tempPath = gfile.Temp(guid.S())
+			// Copy testdata to temp directory
+			srcTestData = gtest.DataPath("issue", "4387")
+		)
+
+		// Setup: create temp project structure
+		err := gfile.CopyDir(srcTestData, tempPath)
+		t.AssertNil(err)
+		defer gfile.Remove(tempPath)
+
+		// Save original working directory
+		originalWd := gfile.Pwd()
+
+		// Change to temp directory (simulate user being in project root)
+		err = gfile.Chdir(tempPath)
+		t.AssertNil(err)
+		defer gfile.Chdir(originalWd) // Restore original working directory
+
+		// Run gen enums with relative paths
+		var (
+			srcFolder  = "api"
+			outputPath = filepath.FromSlash("internal/packed/packed_enums.go")
+			in         = genenums.CGenEnumsInput{
+				Src:  srcFolder,
+				Path: outputPath,
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		_, err = genenums.CGenEnums{}.Enums(ctx, in)
+		t.AssertNil(err)
+
+		// Expected: file should be created at tempPath/internal/packed/packed_enums.go
+		expectedPath := filepath.Join(tempPath, "internal", "packed", "packed_enums.go")
+		// Bug: file is created at tempPath/api/internal/packed/packed_enums.go
+		wrongPath := filepath.Join(tempPath, "api", "internal", "packed", "packed_enums.go")
+
+		// Assert the file is at the expected location
+		t.Assert(gfile.Exists(expectedPath), true)
+		// Assert the file is NOT at the wrong location
+		t.Assert(gfile.Exists(wrongPath), false)
+	})
+}
+
+// Test gen enums with absolute output path (should work correctly)
+func Test_Gen_Enums_AbsolutePath(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			tempPath    = gfile.Temp(guid.S())
+			srcTestData = gtest.DataPath("issue", "4387")
+		)
+
+		err := gfile.CopyDir(srcTestData, tempPath)
+		t.AssertNil(err)
+		defer gfile.Remove(tempPath)
+
+		originalWd := gfile.Pwd()
+		err = gfile.Chdir(tempPath)
+		t.AssertNil(err)
+		defer gfile.Chdir(originalWd)
+
+		// Use absolute path for output
+		var (
+			srcFolder  = "api"
+			outputPath = filepath.Join(tempPath, "internal", "packed", "packed_enums.go")
+			in         = genenums.CGenEnumsInput{
+				Src:  srcFolder,
+				Path: outputPath,
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		_, err = genenums.CGenEnums{}.Enums(ctx, in)
+		t.AssertNil(err)
+
+		// Assert the file exists at absolute path
+		t.Assert(gfile.Exists(outputPath), true)
+	})
+}
+
+// Test gen enums in monorepo mode (cd app/xxx/ then run command)
+func Test_Gen_Enums_Issue4387_Monorepo(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			// Simulate monorepo structure
+			tempPath    = gfile.Temp(guid.S())
+			srcTestData = gtest.DataPath("issue", "4387")
+			// app/myapp is the subdirectory in monorepo
+			appPath = filepath.Join(tempPath, "app", "myapp")
+		)
+
+		// Create monorepo structure: tempPath/app/myapp/api/...
+		err := gfile.Mkdir(appPath)
+		t.AssertNil(err)
+		// Copy testdata into app/myapp
+		err = gfile.CopyDir(srcTestData, appPath)
+		t.AssertNil(err)
+		defer gfile.Remove(tempPath)
+
+		originalWd := gfile.Pwd()
+
+		// cd app/myapp (simulate user in monorepo subdirectory)
+		err = gfile.Chdir(appPath)
+		t.AssertNil(err)
+		defer gfile.Chdir(originalWd)
+
+		var (
+			srcFolder  = "api"
+			outputPath = filepath.FromSlash("internal/packed/packed_enums.go")
+			in         = genenums.CGenEnumsInput{
+				Src:  srcFolder,
+				Path: outputPath,
+			}
+		)
+		err = gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		_, err = genenums.CGenEnums{}.Enums(ctx, in)
+		t.AssertNil(err)
+
+		// Expected: file at app/myapp/internal/packed/packed_enums.go
+		expectedPath := filepath.Join(appPath, "internal", "packed", "packed_enums.go")
+		// Bug: file at app/myapp/api/internal/packed/packed_enums.go
+		wrongPath := filepath.Join(appPath, "api", "internal", "packed", "packed_enums.go")
+
+		t.Assert(gfile.Exists(expectedPath), true)
+		t.Assert(gfile.Exists(wrongPath), false)
+	})
+}
diff --git a/cmd/gf/internal/cmd/cmd_z_unit_gen_pb_test.go b/cmd/gf/internal/cmd/cmd_z_unit_gen_pb_test.go
index 80cf1e814..6c3cff236 100644
--- a/cmd/gf/internal/cmd/cmd_z_unit_gen_pb_test.go
+++ b/cmd/gf/internal/cmd/cmd_z_unit_gen_pb_test.go
@@ -88,3 +88,76 @@ func TestGenPbIssue3953(t *testing.T) {
 		t.Assert(gstr.Contains(genContent, notExceptText), false)
 	})
 }
+
+func TestGenPb_MultipleTags(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			outputPath     = gfile.Temp(guid.S())
+			outputApiPath  = filepath.Join(outputPath, "api")
+			outputCtrlPath = filepath.Join(outputPath, "controller")
+
+			protobufFolder = gtest.DataPath("genpb")
+			in             = genpb.CGenPbInput{
+				Path:       protobufFolder,
+				OutputApi:  outputApiPath,
+				OutputCtrl: outputCtrlPath,
+			}
+			err error
+		)
+		err = gfile.Mkdir(outputApiPath)
+		t.AssertNil(err)
+		err = gfile.Mkdir(outputCtrlPath)
+		t.AssertNil(err)
+		defer gfile.Remove(outputPath)
+
+		_, err = genpb.CGenPb{}.Pb(ctx, in)
+		t.AssertNil(err)
+
+		// Test multiple_tags.proto output
+		genContent := gfile.GetContents(filepath.Join(outputApiPath, "multiple_tags.pb.go"))
+		// Id field should have combined validation tags: v:"required#Id > 0"
+		t.Assert(gstr.Contains(genContent, `v:"required#Id > 0"`), true)
+		// Name field should have dc tag from plain comment
+		t.Assert(gstr.Contains(genContent, `dc:"User name for login"`), true)
+		// Email field should have combined validation and dc tag
+		t.Assert(gstr.Contains(genContent, `v:"requiredemail"`), true)
+		t.Assert(gstr.Contains(genContent, `dc:"User email address"`), true)
+	})
+}
+
+func TestGenPb_NestedMessage(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			outputPath     = gfile.Temp(guid.S())
+			outputApiPath  = filepath.Join(outputPath, "api")
+			outputCtrlPath = filepath.Join(outputPath, "controller")
+
+			protobufFolder = gtest.DataPath("genpb")
+			in             = genpb.CGenPbInput{
+				Path:       protobufFolder,
+				OutputApi:  outputApiPath,
+				OutputCtrl: outputCtrlPath,
+			}
+			err error
+		)
+		err = gfile.Mkdir(outputApiPath)
+		t.AssertNil(err)
+		err = gfile.Mkdir(outputCtrlPath)
+		t.AssertNil(err)
+		defer gfile.Remove(outputPath)
+
+		_, err = genpb.CGenPb{}.Pb(ctx, in)
+		t.AssertNil(err)
+
+		// Test nested_message.proto output
+		genContent := gfile.GetContents(filepath.Join(outputApiPath, "nested_message.pb.go"))
+		// Order.OrderId should have v:"required"
+		t.Assert(gstr.Contains(genContent, `v:"required"`), true)
+		// Order.Detail should have dc:"Order details"
+		t.Assert(gstr.Contains(genContent, `dc:"Order details"`), true)
+		// OrderDetail.Quantity should have v:"min:1"
+		t.Assert(gstr.Contains(genContent, `v:"min:1"`), true)
+		// OrderDetail.Price should have v:"min:0.01"
+		t.Assert(gstr.Contains(genContent, `v:"min:0.01"`), true)
+	})
+}
diff --git a/cmd/gf/internal/cmd/cmd_z_unit_gen_service_test.go b/cmd/gf/internal/cmd/cmd_z_unit_gen_service_test.go
index 40ee7158e..99769f820 100644
--- a/cmd/gf/internal/cmd/cmd_z_unit_gen_service_test.go
+++ b/cmd/gf/internal/cmd/cmd_z_unit_gen_service_test.go
@@ -156,3 +156,130 @@ func Test_Issue3835(t *testing.T) {
 		t.Assert(gfile.GetContents(genFile), gfile.GetContents(expectFile))
 	})
 }
+
+func Test_Gen_Service_CamelCase(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			path      = gfile.Temp(guid.S())
+			dstFolder = path + filepath.FromSlash("/service")
+			srvFolder = gtest.DataPath("genservice", "logic")
+			in        = genservice.CGenServiceInput{
+				SrcFolder:       srvFolder,
+				DstFolder:       dstFolder,
+				DstFileNameCase: "Camel",
+				WatchFile:       "",
+				StPattern:       "",
+				Packages:        nil,
+				ImportPrefix:    "",
+				Clear:           false,
+			}
+		)
+		err := gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+		defer gfile.Remove(path)
+
+		// Clean up generated logic.go
+		genSrv := srvFolder + filepath.FromSlash("/logic.go")
+		defer gfile.Remove(genSrv)
+
+		_, err = genservice.CGenService{}.Service(ctx, in)
+		t.AssertNil(err)
+
+		// Files should be in CamelCase
+		files, err := gfile.ScanDir(dstFolder, "*.go", true)
+		t.AssertNil(err)
+		t.Assert(files, []string{
+			dstFolder + filepath.FromSlash("/Article.go"),
+			dstFolder + filepath.FromSlash("/Base.go"),
+			dstFolder + filepath.FromSlash("/Delivery.go"),
+			dstFolder + filepath.FromSlash("/User.go"),
+		})
+	})
+}
+
+func Test_Gen_Service_PackagesFilter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			path      = gfile.Temp(guid.S())
+			dstFolder = path + filepath.FromSlash("/service")
+			srvFolder = gtest.DataPath("genservice", "logic")
+			in        = genservice.CGenServiceInput{
+				SrcFolder:       srvFolder,
+				DstFolder:       dstFolder,
+				DstFileNameCase: "Snake",
+				WatchFile:       "",
+				StPattern:       "",
+				Packages:        []string{"user"},
+				ImportPrefix:    "",
+				Clear:           false,
+			}
+		)
+		err := gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+		defer gfile.Remove(path)
+
+		// Clean up generated logic.go
+		genSrv := srvFolder + filepath.FromSlash("/logic.go")
+		defer gfile.Remove(genSrv)
+
+		_, err = genservice.CGenService{}.Service(ctx, in)
+		t.AssertNil(err)
+
+		// Only user.go should be generated
+		files, err := gfile.ScanDir(dstFolder, "*.go", true)
+		t.AssertNil(err)
+		t.Assert(len(files), 1)
+		t.Assert(files[0], dstFolder+filepath.FromSlash("/user.go"))
+	})
+}
+
+// https://github.com/gogf/gf/issues/4242
+// Test that versioned imports and aliased imports are correctly preserved.
+// The issue is that imports like "github.com/minio/minio-go/v7" were being
+// incorrectly handled because the package name (minio) differs from
+// the directory name (minio-go).
+func Test_Issue4242(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			path      = gfile.Temp(guid.S())
+			dstFolder = path + filepath.FromSlash("/service")
+			srvFolder = gtest.DataPath("issue", "4242", "logic")
+			in        = genservice.CGenServiceInput{
+				SrcFolder:       srvFolder,
+				DstFolder:       dstFolder,
+				DstFileNameCase: "Snake",
+				WatchFile:       "",
+				StPattern:       "",
+				Packages:        nil,
+				ImportPrefix:    "",
+				Clear:           false,
+			}
+		)
+		err := gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+		defer gfile.Remove(path)
+
+		_, err = genservice.CGenService{}.Service(ctx, in)
+		t.AssertNil(err)
+
+		// Test versioned imports
+		t.Assert(
+			gfile.GetContents(dstFolder+filepath.FromSlash("/issue_4242.go")),
+			gfile.GetContents(gtest.DataPath("issue", "4242", "service", "issue_4242.go")),
+		)
+		// Test aliased imports
+		t.Assert(
+			gfile.GetContents(dstFolder+filepath.FromSlash("/issue_4242_alias.go")),
+			gfile.GetContents(gtest.DataPath("issue", "4242", "service", "issue_4242_alias.go")),
+		)
+	})
+}
diff --git a/cmd/gf/internal/cmd/cmd_z_unit_pack_test.go b/cmd/gf/internal/cmd/cmd_z_unit_pack_test.go
new file mode 100644
index 000000000..ac39e8da0
--- /dev/null
+++ b/cmd/gf/internal/cmd/cmd_z_unit_pack_test.go
@@ -0,0 +1,346 @@
+// Copyright GoFrame gf 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 cmd
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/guid"
+)
+
+func Test_Pack_ToGoFile(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "packed", "data.go")
+		)
+		// Create source directory with test files
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create test files
+		err = gfile.PutContents(filepath.Join(srcPath, "test.txt"), "hello world")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(srcPath, "test.json"), `{"key":"value"}`)
+		t.AssertNil(err)
+
+		// Create packed directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "packed"))
+		t.AssertNil(err)
+
+		// Pack to go file
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src:  srcPath,
+			Dst:  dstFile,
+			Name: "packed",
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists
+		t.Assert(gfile.Exists(dstFile), true)
+
+		// Verify it's a valid Go file
+		content := gfile.GetContents(dstFile)
+		t.Assert(gstr.Contains(content, "package packed"), true)
+		t.Assert(gstr.Contains(content, "func init()"), true)
+	})
+}
+
+func Test_Pack_ToBinaryFile(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "data.bin")
+		)
+		// Create source directory with test files
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create test file
+		err = gfile.PutContents(filepath.Join(srcPath, "test.txt"), "binary content")
+		t.AssertNil(err)
+
+		// Pack to binary file (no Name specified)
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src: srcPath,
+			Dst: dstFile,
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists
+		t.Assert(gfile.Exists(dstFile), true)
+
+		// Verify it's a binary file (not a Go file)
+		content := gfile.GetContents(dstFile)
+		t.Assert(gstr.Contains(content, "package"), false)
+	})
+}
+
+func Test_Pack_MultipleSources(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath1 = gfile.Temp(guid.S())
+			srcPath2 = gfile.Temp(guid.S())
+			dstPath  = gfile.Temp(guid.S())
+			dstFile  = filepath.Join(dstPath, "packed", "multi.go")
+		)
+		// Create source directories
+		err := gfile.Mkdir(srcPath1)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath1)
+
+		err = gfile.Mkdir(srcPath2)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath2)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create test files in each source
+		err = gfile.PutContents(filepath.Join(srcPath1, "file1.txt"), "content1")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(srcPath2, "file2.txt"), "content2")
+		t.AssertNil(err)
+
+		// Create packed directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "packed"))
+		t.AssertNil(err)
+
+		// Pack multiple sources (comma-separated)
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src:  srcPath1 + "," + srcPath2,
+			Dst:  dstFile,
+			Name: "packed",
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists
+		t.Assert(gfile.Exists(dstFile), true)
+	})
+}
+
+func Test_Pack_WithPrefix(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "packed", "prefix.go")
+		)
+		// Create source directory
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create test file
+		err = gfile.PutContents(filepath.Join(srcPath, "test.txt"), "with prefix")
+		t.AssertNil(err)
+
+		// Create packed directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "packed"))
+		t.AssertNil(err)
+
+		// Pack with prefix
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src:    srcPath,
+			Dst:    dstFile,
+			Name:   "packed",
+			Prefix: "/static",
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists
+		t.Assert(gfile.Exists(dstFile), true)
+	})
+}
+
+func Test_Pack_WithKeepPath(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "packed", "keeppath.go")
+		)
+		// Create source directory with subdirectory
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create subdirectory and file
+		subDir := filepath.Join(srcPath, "subdir")
+		err = gfile.Mkdir(subDir)
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(subDir, "test.txt"), "keeppath content")
+		t.AssertNil(err)
+
+		// Create packed directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "packed"))
+		t.AssertNil(err)
+
+		// Pack with keepPath
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src:      srcPath,
+			Dst:      dstFile,
+			Name:     "packed",
+			KeepPath: true,
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists
+		t.Assert(gfile.Exists(dstFile), true)
+	})
+}
+
+func Test_Pack_AutoPackageName(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "mypackage", "data.go")
+		)
+		// Create source directory
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create test file
+		err = gfile.PutContents(filepath.Join(srcPath, "test.txt"), "auto package name")
+		t.AssertNil(err)
+
+		// Create mypackage directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "mypackage"))
+		t.AssertNil(err)
+
+		// Pack without Name - should use directory name "mypackage"
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src: srcPath,
+			Dst: dstFile,
+			// Name not specified, should be auto-detected as "mypackage"
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists and has correct package name
+		t.Assert(gfile.Exists(dstFile), true)
+		content := gfile.GetContents(dstFile)
+		t.Assert(gstr.Contains(content, "package mypackage"), true)
+	})
+}
+
+func Test_Pack_EmptySource(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "packed", "empty.go")
+		)
+		// Create empty source directory
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create packed directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "packed"))
+		t.AssertNil(err)
+
+		// Pack empty directory
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src:  srcPath,
+			Dst:  dstFile,
+			Name: "packed",
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists (even if source is empty)
+		t.Assert(gfile.Exists(dstFile), true)
+	})
+}
+
+func Test_Pack_NestedDirectories(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			srcPath = gfile.Temp(guid.S())
+			dstPath = gfile.Temp(guid.S())
+			dstFile = filepath.Join(dstPath, "packed", "nested.go")
+		)
+		// Create source directory with nested structure
+		err := gfile.Mkdir(srcPath)
+		t.AssertNil(err)
+		defer gfile.Remove(srcPath)
+
+		err = gfile.Mkdir(dstPath)
+		t.AssertNil(err)
+		defer gfile.Remove(dstPath)
+
+		// Create nested directories and files
+		level1 := filepath.Join(srcPath, "level1")
+		level2 := filepath.Join(level1, "level2")
+		level3 := filepath.Join(level2, "level3")
+		err = gfile.Mkdir(level3)
+		t.AssertNil(err)
+
+		err = gfile.PutContents(filepath.Join(srcPath, "root.txt"), "root")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(level1, "l1.txt"), "level1")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(level2, "l2.txt"), "level2")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(level3, "l3.txt"), "level3")
+		t.AssertNil(err)
+
+		// Create packed directory
+		err = gfile.Mkdir(filepath.Join(dstPath, "packed"))
+		t.AssertNil(err)
+
+		// Pack nested directories
+		_, err = Pack.Index(context.Background(), cPackInput{
+			Src:  srcPath,
+			Dst:  dstFile,
+			Name: "packed",
+		})
+		t.AssertNil(err)
+
+		// Verify output file exists
+		t.Assert(gfile.Exists(dstFile), true)
+
+		// Verify content includes all files
+		content := gfile.GetContents(dstFile)
+		t.Assert(gstr.Contains(content, "package packed"), true)
+	})
+}
diff --git a/cmd/gf/internal/cmd/cmd_z_unit_run_test.go b/cmd/gf/internal/cmd/cmd_z_unit_run_test.go
new file mode 100644
index 000000000..b5fc4b13e
--- /dev/null
+++ b/cmd/gf/internal/cmd/cmd_z_unit_run_test.go
@@ -0,0 +1,336 @@
+// Copyright GoFrame gf 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 cmd
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_cRunApp_getWatchPaths_Basic(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		app := &cRunApp{
+			WatchPaths: []string{"."},
+		}
+		watchPaths := app.getWatchPaths()
+
+		t.AssertGT(len(watchPaths), 0)
+		for _, v := range watchPaths {
+			t.Log(v)
+		}
+	})
+}
+
+func Test_cRunApp_getWatchPaths_EmptyWatchPaths(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		app := &cRunApp{
+			WatchPaths: []string{},
+		}
+		watchPaths := app.getWatchPaths()
+
+		// Should default to current directory "."
+		t.AssertGT(len(watchPaths), 0)
+	})
+}
+
+func Test_cRunApp_getWatchPaths_CustomIgnorePattern(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		app := &cRunApp{
+			WatchPaths:     []string{"testdata"},
+			IgnorePatterns: []string{"2572"},
+		}
+		watchPaths := app.getWatchPaths()
+
+		// Ensure the "2572" directory is not watched directly.
+		for _, wp := range watchPaths {
+			t.Log("watch path:", wp)
+			t.Assert(strings.HasSuffix(wp.Path, "2572"), false)
+		}
+		t.AssertGT(len(watchPaths), 0)
+	})
+}
+
+func Test_cRunApp_getWatchPaths_WithIgnoredDirectories(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a temporary directory structure for testing
+		tempDir := gfile.Temp("gf_run_test")
+		defer gfile.Remove(tempDir)
+
+		// Create directory structure:
+		// tempDir/
+		//   ├── src/
+		//   │   ├── api/
+		//   │   └── internal/
+		//   ├── vendor/  <-- ignored
+		//   └── node_modules/  <-- ignored
+		gfile.Mkdir(filepath.Join(tempDir, "src", "api"))
+		gfile.Mkdir(filepath.Join(tempDir, "src", "internal"))
+		gfile.Mkdir(filepath.Join(tempDir, "vendor"))
+		gfile.Mkdir(filepath.Join(tempDir, "node_modules"))
+
+		app := &cRunApp{
+			WatchPaths: []string{tempDir},
+		}
+		watchPaths := app.getWatchPaths()
+
+		// Should watch tempDir non-recursively (to catch top-level files) and src recursively
+		t.Assert(len(watchPaths), 2)
+		// First path is tempDir (non-recursive)
+		t.Assert(watchPaths[0].Path, tempDir)
+		t.Assert(watchPaths[0].Recursive, false)
+		// Second path is src (recursive, since it has no ignored descendants)
+		t.Assert(watchPaths[1].Path, filepath.Join(tempDir, "src"))
+		t.Assert(watchPaths[1].Recursive, true)
+	})
+}
+
+func Test_cRunApp_getWatchPaths_NoIgnoredDirectories(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a temporary directory structure without ignored directories
+		tempDir := gfile.Temp("gf_run_test_no_ignore")
+		defer gfile.Remove(tempDir)
+
+		// Create directory structure without ignored patterns:
+		// tempDir/
+		//   ├── src/
+		//   │   ├── api/
+		//   │   └── internal/
+		gfile.Mkdir(filepath.Join(tempDir, "src", "api"))
+		gfile.Mkdir(filepath.Join(tempDir, "src", "internal"))
+
+		app := &cRunApp{
+			WatchPaths: []string{tempDir},
+		}
+		watchPaths := app.getWatchPaths()
+
+		// Should watch the root directory recursively since no ignored directories exist
+		t.Assert(len(watchPaths), 1)
+		t.Assert(watchPaths[0].Path, tempDir)
+		t.Assert(watchPaths[0].Recursive, true)
+	})
+}
+
+func Test_cRunApp_getWatchPaths_CustomIgnorePatterns(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a temporary directory structure
+		tempDir := gfile.Temp("gf_run_test_custom_ignore")
+		defer gfile.Remove(tempDir)
+
+		// Create directory structure:
+		// tempDir/
+		//   ├── src/
+		//   │   ├── api/
+		//   │   └── internal/
+		//   ├── build/  <-- ignored
+		//   └── dist/  <-- ignored
+		gfile.Mkdir(filepath.Join(tempDir, "src", "api"))
+		gfile.Mkdir(filepath.Join(tempDir, "src", "internal"))
+		gfile.Mkdir(filepath.Join(tempDir, "build"))
+		gfile.Mkdir(filepath.Join(tempDir, "dist"))
+
+		app := &cRunApp{
+			WatchPaths:     []string{tempDir},
+			IgnorePatterns: []string{"build", "dist"},
+		}
+		watchPaths := app.getWatchPaths()
+
+		// Should watch tempDir non-recursively and src recursively
+		t.Assert(len(watchPaths), 2)
+		t.Assert(watchPaths[0].Path, tempDir)
+		t.Assert(watchPaths[0].Recursive, false)
+		t.Assert(watchPaths[1].Path, filepath.Join(tempDir, "src"))
+		t.Assert(watchPaths[1].Recursive, true)
+	})
+}
+
+func Test_cRunApp_getWatchPaths_DeepNestedStructure(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a deep nested directory structure
+		tempDir := gfile.Temp("gf_run_test_deep")
+		defer gfile.Remove(tempDir)
+
+		// Create deep directory structure:
+		// tempDir/
+		//   ├── a/
+		//   │   ├── b/
+		//   │   │   └── c/
+		//   │   └── vendor/  <-- ignored
+		//   └── d/
+		gfile.Mkdir(filepath.Join(tempDir, "a", "b", "c"))
+		gfile.Mkdir(filepath.Join(tempDir, "a", "vendor"))
+		gfile.Mkdir(filepath.Join(tempDir, "d"))
+
+		app := &cRunApp{
+			WatchPaths: []string{tempDir},
+		}
+		watchPaths := app.getWatchPaths()
+
+		// Should watch individual valid directories due to ignored vendor directory
+		t.AssertGT(len(watchPaths), 0)
+
+		// Verify that vendor directory is not in watch list
+		for _, wp := range watchPaths {
+			t.Assert(strings.Contains(wp.Path, "vendor"), false)
+		}
+	})
+}
+
+func Test_cRunApp_getWatchPaths_MultipleRoots(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create multiple temporary directories
+		tempDir1 := gfile.Temp("gf_run_test_multi1")
+		tempDir2 := gfile.Temp("gf_run_test_multi2")
+		defer gfile.Remove(tempDir1)
+		defer gfile.Remove(tempDir2)
+
+		gfile.Mkdir(filepath.Join(tempDir1, "src"))
+		gfile.Mkdir(filepath.Join(tempDir2, "api"))
+
+		app := &cRunApp{
+			WatchPaths: []string{tempDir1, tempDir2},
+		}
+		watchPaths := app.getWatchPaths()
+
+		// Should watch both root directories recursively
+		t.Assert(len(watchPaths), 2)
+
+		// Both directories should be in the watch list
+		foundDir1, foundDir2 := false, false
+		for _, wp := range watchPaths {
+			if wp.Path == tempDir1 {
+				foundDir1 = true
+				t.Assert(wp.Recursive, true)
+			}
+			if wp.Path == tempDir2 {
+				foundDir2 = true
+				t.Assert(wp.Recursive, true)
+			}
+		}
+		t.Assert(foundDir1, true)
+		t.Assert(foundDir2, true)
+	})
+}
+
+func Test_cRunApp_getWatchPaths_NonExistentDirectory(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		app := &cRunApp{
+			WatchPaths: []string{"/non/existent/path"},
+		}
+		watchPaths := app.getWatchPaths()
+
+		// Should fall back to current directory when no valid paths found
+		t.AssertGT(len(watchPaths), 0)
+
+		// Should contain current directory
+		currentDir, _ := os.Getwd()
+		foundCurrentDir := false
+		for _, wp := range watchPaths {
+			if wp.Path == currentDir {
+				foundCurrentDir = true
+				break
+			}
+		}
+		t.Assert(foundCurrentDir, true)
+	})
+}
+
+func Test_isIgnoredDirName(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test default ignore patterns
+		t.Assert(isIgnoredDirName("node_modules", defaultIgnorePatterns), true)
+		t.Assert(isIgnoredDirName("vendor", defaultIgnorePatterns), true)
+		t.Assert(isIgnoredDirName(".git", defaultIgnorePatterns), true)
+		t.Assert(isIgnoredDirName("_private", defaultIgnorePatterns), true)
+		t.Assert(isIgnoredDirName("src", defaultIgnorePatterns), false)
+		t.Assert(isIgnoredDirName("api", defaultIgnorePatterns), false)
+
+		// Test custom ignore patterns
+		customPatterns := []string{"build", "dist", "*.tmp"}
+		t.Assert(isIgnoredDirName("build", customPatterns), true)
+		t.Assert(isIgnoredDirName("dist", customPatterns), true)
+		t.Assert(isIgnoredDirName("test.tmp", customPatterns), true)
+		t.Assert(isIgnoredDirName("src", customPatterns), false)
+	})
+}
+
+func Test_cRunApp_getWatchPaths_DeeplyNestedIgnore(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a temporary directory structure with deeply nested ignored directory
+		tempDir := gfile.Temp("gf_run_test_deeply_nested")
+		defer gfile.Remove(tempDir)
+
+		// Create directory structure:
+		// tempDir/
+		//   ├── a/
+		//   │   ├── b/
+		//   │   │   ├── c/
+		//   │   │   │   └── vendor/  <-- deeply nested ignored (4 levels)
+		//   │   │   └── d/
+		//   │   └── e/
+		//   └── f/
+		gfile.Mkdir(filepath.Join(tempDir, "a", "b", "c", "vendor"))
+		gfile.Mkdir(filepath.Join(tempDir, "a", "b", "d"))
+		gfile.Mkdir(filepath.Join(tempDir, "a", "e"))
+		gfile.Mkdir(filepath.Join(tempDir, "f"))
+
+		app := &cRunApp{
+			WatchPaths: []string{tempDir},
+		}
+		watchPaths := app.getWatchPaths()
+
+		// Expected watch paths:
+		// 1. tempDir (non-recursive) - has ignored descendant
+		// 2. a (non-recursive) - has ignored descendant in b/c/vendor
+		// 3. b (non-recursive) - has ignored descendant in c/vendor
+		// 4. c (non-recursive) - has ignored child vendor
+		// 5. d (recursive) - no ignored descendants
+		// 6. e (recursive) - no ignored descendants
+		// 7. f (recursive) - no ignored descendants
+
+		t.AssertGT(len(watchPaths), 0)
+
+		// Verify vendor is not in watch paths
+		for _, wp := range watchPaths {
+			t.Assert(strings.Contains(wp.Path, "vendor"), false)
+		}
+
+		// Find specific paths and verify their recursive flags
+		foundF := false
+		for _, wp := range watchPaths {
+			if wp.Path == filepath.Join(tempDir, "f") {
+				foundF = true
+				t.Assert(wp.Recursive, true) // f should be recursive (no ignored descendants)
+			}
+		}
+		t.Assert(foundF, true)
+	})
+}
+
+func Test_cRunApp_getWatchPaths_EmptyDirectory(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create an empty temporary directory
+		tempDir := gfile.Temp("gf_run_test_empty")
+		defer gfile.Remove(tempDir)
+
+		gfile.Mkdir(tempDir)
+
+		app := &cRunApp{
+			WatchPaths: []string{tempDir},
+		}
+		watchPaths := app.getWatchPaths()
+
+		// Empty directory should be watched recursively (no ignored descendants)
+		t.Assert(len(watchPaths), 1)
+		t.Assert(watchPaths[0].Path, tempDir)
+		t.Assert(watchPaths[0].Recursive, true)
+	})
+}
diff --git a/cmd/gf/internal/cmd/genctrl/genctrl.go b/cmd/gf/internal/cmd/genctrl/genctrl.go
index 71771f593..35352fcd4 100644
--- a/cmd/gf/internal/cmd/genctrl/genctrl.go
+++ b/cmd/gf/internal/cmd/genctrl/genctrl.go
@@ -89,28 +89,11 @@ func (c CGenCtrl) Ctrl(ctx context.Context, in CGenCtrlInput) (out *CGenCtrlOutp
 	if !gfile.Exists(in.SrcFolder) {
 		mlog.Fatalf(`source folder path "%s" does not exist`, in.SrcFolder)
 	}
-	// retrieve all api modules.
-	apiModuleFolderPaths, err := gfile.ScanDir(in.SrcFolder, "*", false)
+
+	err = c.generateByModules(in)
 	if err != nil {
 		return nil, err
 	}
-	for _, apiModuleFolderPath := range apiModuleFolderPaths {
-		if !gfile.IsDir(apiModuleFolderPath) {
-			continue
-		}
-		// generate go files by api module.
-		var (
-			module              = gfile.Basename(apiModuleFolderPath)
-			dstModuleFolderPath = gfile.Join(in.DstFolder, module)
-		)
-		err = c.generateByModule(
-			apiModuleFolderPath, dstModuleFolderPath, in.SdkPath,
-			in.SdkStdVersion, in.SdkNoV1, in.Clear, in.Merge,
-		)
-		if err != nil {
-			return nil, err
-		}
-	}
 
 	mlog.Print(`done!`)
 	return
@@ -163,6 +146,56 @@ func (c CGenCtrl) generateByWatchFile(watchFile, sdkPath string, sdkStdVersion,
 	)
 }
 
+// generateByModules recursively calls generateByModule for multi-level modules generation.
+func (c CGenCtrl) generateByModules(in CGenCtrlInput) (err error) {
+	// read root folder, example: api/user or api/app
+	moduleFolderPaths, err := gfile.ScanDir(in.SrcFolder, "*", false)
+	if err != nil {
+		return err
+	}
+	for _, moduleFolder := range moduleFolderPaths {
+		if !gfile.IsDir(moduleFolder) {
+			continue
+		}
+
+		// read children folder, example: api/user/v1 or api/app/user
+		childrenFolderPaths, err := gfile.ScanDir(moduleFolder, "*", false)
+		if err != nil {
+			return err
+		}
+		for _, childrenFolderPath := range childrenFolderPaths {
+			if !gfile.IsDir(childrenFolderPath) {
+				continue
+			}
+
+			var (
+				inCopy = in
+				module = gfile.Basename(moduleFolder)
+			)
+			inCopy.SrcFolder = gfile.Join(in.SrcFolder, module)
+			inCopy.DstFolder = gfile.Join(in.DstFolder, module)
+			err = c.generateByModules(inCopy)
+			if err != nil {
+				return err
+			}
+		}
+
+		// generate go files by api module.
+		var (
+			module              = gfile.Basename(moduleFolder)
+			dstModuleFolderPath = gfile.Join(in.DstFolder, module)
+		)
+		err = c.generateByModule(
+			moduleFolder, dstModuleFolderPath, in.SdkPath,
+			in.SdkStdVersion, in.SdkNoV1, in.Clear, in.Merge,
+		)
+		if err != nil {
+			return err
+		}
+	}
+	return
+}
+
 // parseApiModule parses certain api and generate associated go files by certain module, not all api modules.
 func (c CGenCtrl) generateByModule(
 	apiModuleFolderPath, dstModuleFolderPath, sdkPath string,
diff --git a/cmd/gf/internal/cmd/genctrl/genctrl_generate_ctrl.go b/cmd/gf/internal/cmd/genctrl/genctrl_generate_ctrl.go
index 047dbb740..8c993e0da 100644
--- a/cmd/gf/internal/cmd/genctrl/genctrl_generate_ctrl.go
+++ b/cmd/gf/internal/cmd/genctrl/genctrl_generate_ctrl.go
@@ -8,6 +8,9 @@ package genctrl
 
 import (
 	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
 	"path/filepath"
 	"strings"
 
@@ -144,8 +147,8 @@ func (c *controllerGenerator) doGenerateCtrlItem(dstModuleFolderPath string, ite
 			"{MethodName}":    item.MethodName,
 			"{MethodComment}": item.GetComment(),
 		})
-
-		if gstr.Contains(gfile.GetContents(methodFilePath), fmt.Sprintf(`func (c *%v) %v(`, ctrlName, item.MethodName)) {
+		// Use AST-based checking for more accurate method detection
+		if methodExists(methodFilePath, ctrlName, item.MethodName) {
 			return
 		}
 		if err = gfile.PutContentsAppend(methodFilePath, gstr.TrimLeft(content)); err != nil {
@@ -170,7 +173,6 @@ func (c *controllerGenerator) doGenerateCtrlItem(dstModuleFolderPath string, ite
 
 // use -merge
 func (c *controllerGenerator) doGenerateCtrlMergeItem(dstModuleFolderPath string, apiItems []apiItem, doneApiSet *gset.StrSet) (err error) {
-
 	type controllerFileItem struct {
 		module     string
 		version    string
@@ -193,13 +195,23 @@ func (c *controllerGenerator) doGenerateCtrlMergeItem(dstModuleFolderPath string
 			ctrlFileItemMap[api.FileName] = ctrlFileItem
 		}
 
+		ctrlName := fmt.Sprintf(`Controller%s`, gstr.UcFirst(api.Version))
 		ctrl := gstr.TrimLeft(gstr.ReplaceByMap(consts.TemplateGenCtrlControllerMethodFuncMerge, g.MapStrStr{
 			"{Module}":        api.Module,
-			"{CtrlName}":      fmt.Sprintf(`Controller%s`, gstr.UcFirst(api.Version)),
+			"{CtrlName}":      ctrlName,
 			"{Version}":       api.Version,
 			"{MethodName}":    api.MethodName,
 			"{MethodComment}": api.GetComment(),
 		}))
+
+		ctrlFilePath := gfile.Join(dstModuleFolderPath, fmt.Sprintf(
+			`%s_%s_%s.go`, ctrlFileItem.module, ctrlFileItem.version, api.FileName,
+		))
+		// Use AST-based checking for more accurate method detection
+		if methodExists(ctrlFilePath, ctrlName, api.MethodName) {
+			return
+		}
+
 		ctrlFileItem.controllers.WriteString(ctrl)
 		doneApiSet.Add(api.String())
 	}
@@ -229,3 +241,41 @@ func (c *controllerGenerator) doGenerateCtrlMergeItem(dstModuleFolderPath string
 	}
 	return
 }
+
+// methodExists checks if a method with the given receiver type and name exists in the file.
+// It uses AST parsing to accurately detect method definitions regardless of formatting.
+// This handles various code formatting styles including multi-line method signatures.
+func methodExists(filePath, ctrlName, methodName string) bool {
+	fset := token.NewFileSet()
+	node, err := parser.ParseFile(fset, filePath, nil, parser.ParseComments)
+	if err != nil {
+		// If parsing fails (e.g., file doesn't exist or invalid syntax), return false
+		return false
+	}
+	for _, decl := range node.Decls {
+		funcDecl, ok := decl.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		// Check if it's a method (has receiver)
+		if funcDecl.Recv != nil && len(funcDecl.Recv.List) > 0 {
+			// Extract receiver type name
+			// Handle both *T and T patterns
+			recvType := ""
+			switch t := funcDecl.Recv.List[0].Type.(type) {
+			case *ast.StarExpr:
+				if ident, ok := t.X.(*ast.Ident); ok {
+					recvType = ident.Name
+				}
+			case *ast.Ident:
+				recvType = t.Name
+			}
+
+			// Check if both receiver type and method name match
+			if recvType == ctrlName && funcDecl.Name.Name == methodName {
+				return true
+			}
+		}
+	}
+	return false
+}
diff --git a/cmd/gf/internal/cmd/gendao.zip b/cmd/gf/internal/cmd/gendao.zip
new file mode 100644
index 000000000..46dace4f0
Binary files /dev/null and b/cmd/gf/internal/cmd/gendao.zip differ
diff --git a/cmd/gf/internal/cmd/gendao/gendao.go b/cmd/gf/internal/cmd/gendao/gendao.go
index 053f65e3c..056d91dcc 100644
--- a/cmd/gf/internal/cmd/gendao/gendao.go
+++ b/cmd/gf/internal/cmd/gendao/gendao.go
@@ -9,6 +9,7 @@ package gendao
 import (
 	"context"
 	"fmt"
+	"sort"
 	"strings"
 
 	"github.com/olekukonko/tablewriter"
@@ -47,8 +48,10 @@ type (
 		JsonCase           string   `name:"jsonCase"            short:"j"  brief:"{CGenDaoBriefJsonCase}" d:"CamelLower"`
 		ImportPrefix       string   `name:"importPrefix"        short:"i"  brief:"{CGenDaoBriefImportPrefix}"`
 		DaoPath            string   `name:"daoPath"             short:"d"  brief:"{CGenDaoBriefDaoPath}" d:"dao"`
+		TablePath          string   `name:"tablePath"           short:"tp" brief:"{CGenDaoBriefTablePath}" d:"table"`
 		DoPath             string   `name:"doPath"              short:"o"  brief:"{CGenDaoBriefDoPath}" d:"model/do"`
 		EntityPath         string   `name:"entityPath"          short:"e"  brief:"{CGenDaoBriefEntityPath}" d:"model/entity"`
+		TplDaoTablePath    string   `name:"tplDaoTablePath"     short:"t0" brief:"{CGenDaoBriefTplDaoTablePath}"`
 		TplDaoIndexPath    string   `name:"tplDaoIndexPath"     short:"t1" brief:"{CGenDaoBriefTplDaoIndexPath}"`
 		TplDaoInternalPath string   `name:"tplDaoInternalPath"  short:"t2" brief:"{CGenDaoBriefTplDaoInternalPath}"`
 		TplDaoDoPath       string   `name:"tplDaoDoPath"        short:"t3" brief:"{CGenDaoBriefTplDaoDoPathPath}"`
@@ -61,6 +64,7 @@ type (
 		NoJsonTag          bool     `name:"noJsonTag"           short:"k"  brief:"{CGenDaoBriefNoJsonTag}" orphan:"true"`
 		NoModelComment     bool     `name:"noModelComment"      short:"m"  brief:"{CGenDaoBriefNoModelComment}" orphan:"true"`
 		Clear              bool     `name:"clear"               short:"a"  brief:"{CGenDaoBriefClear}" orphan:"true"`
+		GenTable           bool     `name:"genTable"            short:"gt" brief:"{CGenDaoBriefGenTable}" orphan:"true"`
 
 		TypeMapping  map[DBFieldTypeName]CustomAttributeType  `name:"typeMapping"  short:"y"  brief:"{CGenDaoBriefTypeMapping}"  orphan:"true"`
 		FieldMapping map[DBTableFieldName]CustomAttributeType `name:"fieldMapping" short:"fm" brief:"{CGenDaoBriefFieldMapping}" orphan:"true"`
@@ -101,6 +105,10 @@ var (
 		"smallmoney": {
 			Type: "float64",
 		},
+		"uuid": {
+			Type:   "uuid.UUID",
+			Import: "github.com/google/uuid",
+		},
 	}
 
 	// tablewriter Options
@@ -180,7 +188,27 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 
 	var tableNames []string
 	if in.Tables != "" {
-		tableNames = gstr.SplitAndTrim(in.Tables, ",")
+		inputTables := gstr.SplitAndTrim(in.Tables, ",")
+		// Check if any table pattern contains wildcard characters.
+		// https://github.com/gogf/gf/issues/4629
+		var hasPattern bool
+		for _, t := range inputTables {
+			if containsWildcard(t) {
+				hasPattern = true
+				break
+			}
+		}
+		if hasPattern {
+			// Fetch all tables first, then filter by patterns.
+			allTables, err := db.Tables(context.TODO())
+			if err != nil {
+				mlog.Fatalf("fetching tables failed: %+v", err)
+			}
+			tableNames = filterTablesByPatterns(allTables, inputTables)
+		} else {
+			// Use exact table names as before.
+			tableNames = inputTables
+		}
 	} else {
 		tableNames, err = db.Tables(context.TODO())
 		if err != nil {
@@ -190,8 +218,18 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 	// Table excluding.
 	if in.TablesEx != "" {
 		array := garray.NewStrArrayFrom(tableNames)
-		for _, v := range gstr.SplitAndTrim(in.TablesEx, ",") {
-			array.RemoveValue(v)
+		for _, p := range gstr.SplitAndTrim(in.TablesEx, ",") {
+			if containsWildcard(p) {
+				// Use exact match with ^ and $ anchors for consistency with tables pattern.
+				regPattern := "^" + patternToRegex(p) + "$"
+				for _, v := range array.Clone().Slice() {
+					if gregex.IsMatchString(regPattern, v) {
+						array.RemoveValue(v)
+					}
+				}
+			} else {
+				array.RemoveValue(p)
+			}
 		}
 		tableNames = array.Slice()
 	}
@@ -212,13 +250,22 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 		newTableNames       = make([]string, len(tableNames))
 		shardingNewTableSet = gset.NewStrSet()
 	)
+	// Sort sharding patterns by length descending, so that longer (more specific) patterns
+	// are matched first. This prevents shorter patterns like "a_?" from incorrectly matching
+	// tables that should match longer patterns like "a_b_?" or "a_c_?".
+	// https://github.com/gogf/gf/issues/4603
+	sortedShardingPatterns := make([]string, len(in.ShardingPattern))
+	copy(sortedShardingPatterns, in.ShardingPattern)
+	sort.Slice(sortedShardingPatterns, func(i, j int) bool {
+		return len(sortedShardingPatterns[i]) > len(sortedShardingPatterns[j])
+	})
 	for i, tableName := range tableNames {
 		newTableName := tableName
 		for _, v := range removePrefixArray {
 			newTableName = gstr.TrimLeftStr(newTableName, v, 1)
 		}
-		if len(in.ShardingPattern) > 0 {
-			for _, pattern := range in.ShardingPattern {
+		if len(sortedShardingPatterns) > 0 {
+			for _, pattern := range sortedShardingPatterns {
 				var (
 					match      []string
 					regPattern = gstr.Replace(pattern, "?", `(.+)`)
@@ -234,10 +281,11 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 				newTableName = gstr.Trim(newTableName, `_.-`)
 				if shardingNewTableSet.Contains(newTableName) {
 					tableNames[i] = ""
-					continue
+					break
 				}
 				// Add prefix to sharding table name, if not, the isSharding check would not match.
 				shardingNewTableSet.Add(in.Prefix + newTableName)
+				break
 			}
 		}
 		newTableName = in.Prefix + newTableName
@@ -258,6 +306,14 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 		NewTableNames:    newTableNames,
 		ShardingTableSet: shardingNewTableSet,
 	})
+	// Table: table fields.
+	generateTable(ctx, CGenDaoInternalInput{
+		CGenDaoInput:     in,
+		DB:               db,
+		TableNames:       tableNames,
+		NewTableNames:    newTableNames,
+		ShardingTableSet: shardingNewTableSet,
+	})
 	// Do.
 	generateDo(ctx, CGenDaoInternalInput{
 		CGenDaoInput:  in,
@@ -375,3 +431,61 @@ func getTemplateFromPathOrDefault(filePath string, def string) string {
 	}
 	return def
 }
+
+// containsWildcard checks if the pattern contains wildcard characters (* or ?).
+func containsWildcard(pattern string) bool {
+	return gstr.Contains(pattern, "*") || gstr.Contains(pattern, "?")
+}
+
+// patternToRegex converts a wildcard pattern to a regex pattern.
+// Wildcard characters: * matches any characters, ? matches single character.
+func patternToRegex(pattern string) string {
+	pattern = gstr.ReplaceByMap(pattern, map[string]string{
+		"\r": "",
+		"\n": "",
+	})
+	pattern = gstr.ReplaceByMap(pattern, map[string]string{
+		"*": "\r",
+		"?": "\n",
+	})
+	pattern = gregex.Quote(pattern)
+	pattern = gstr.ReplaceByMap(pattern, map[string]string{
+		"\r": ".*",
+		"\n": ".",
+	})
+	return pattern
+}
+
+// filterTablesByPatterns filters tables by given patterns.
+// Patterns support wildcard characters: * matches any characters, ? matches single character.
+// https://github.com/gogf/gf/issues/4629
+func filterTablesByPatterns(allTables []string, patterns []string) []string {
+	var result []string
+	matched := make(map[string]bool)
+	allTablesSet := make(map[string]bool)
+	for _, t := range allTables {
+		allTablesSet[t] = true
+	}
+	for _, p := range patterns {
+		if containsWildcard(p) {
+			regPattern := "^" + patternToRegex(p) + "$"
+			for _, table := range allTables {
+				if !matched[table] && gregex.IsMatchString(regPattern, table) {
+					result = append(result, table)
+					matched[table] = true
+				}
+			}
+		} else {
+			// Exact table name, use direct string comparison.
+			if !allTablesSet[p] {
+				mlog.Printf(`table "%s" does not exist, skipped`, p)
+				continue
+			}
+			if !matched[p] {
+				result = append(result, p)
+				matched[p] = true
+			}
+		}
+	}
+	return result
+}
diff --git a/cmd/gf/internal/cmd/gendao/gendao_structure.go b/cmd/gf/internal/cmd/gendao/gendao_structure.go
index 95084892f..7601bc616 100644
--- a/cmd/gf/internal/cmd/gendao/gendao_structure.go
+++ b/cmd/gf/internal/cmd/gendao/gendao_structure.go
@@ -98,7 +98,6 @@ func generateStructFieldDefinition(
 		err              error
 		localTypeName    gdb.LocalType
 		localTypeNameStr string
-		jsonTag          = gstr.CaseConvert(field.Name, gstr.CaseTypeMatch(in.JsonCase))
 	)
 
 	if in.TypeMapping != nil && len(in.TypeMapping) > 0 {
@@ -156,6 +155,8 @@ func generateStructFieldDefinition(
 		"    #" + formatFieldName(newFiledName, FieldNameCaseCamel),
 		" #" + localTypeNameStr,
 	}
+
+	jsonTag := gstr.CaseConvert(newFiledName, gstr.CaseTypeMatch(in.JsonCase))
 	attrLines = append(attrLines, fmt.Sprintf(` #%sjson:"%s"`, tagKey, jsonTag))
 	// orm tag
 	if !in.IsDo {
diff --git a/cmd/gf/internal/cmd/gendao/gendao_table.go b/cmd/gf/internal/cmd/gendao/gendao_table.go
new file mode 100644
index 000000000..4af71fc1c
--- /dev/null
+++ b/cmd/gf/internal/cmd/gendao/gendao_table.go
@@ -0,0 +1,147 @@
+// Copyright GoFrame gf 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 gendao
+
+import (
+	"bytes"
+	"context"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gview"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
+)
+
+// generateTable generates dao files for given tables.
+func generateTable(ctx context.Context, in CGenDaoInternalInput) {
+	dirPathTable := gfile.Join(in.Path, in.TablePath)
+	if !in.GenTable {
+		if gfile.Exists(dirPathTable) {
+			in.genItems.AppendDirPath(dirPathTable)
+		}
+		return
+	}
+	in.genItems.AppendDirPath(dirPathTable)
+	for i := 0; i < len(in.TableNames); i++ {
+		var (
+			realTableName = in.TableNames[i]
+			newTableName  = in.NewTableNames[i]
+		)
+		generateTableSingle(ctx, generateTableSingleInput{
+			CGenDaoInternalInput: in,
+			TableName:            realTableName,
+			NewTableName:         newTableName,
+			DirPathTable:         dirPathTable,
+		})
+	}
+}
+
+// generateTableSingleInput is the input parameter for generateTableSingle.
+type generateTableSingleInput struct {
+	CGenDaoInternalInput
+	// TableName specifies the table name of the table.
+	TableName string
+	// NewTableName specifies the prefix-stripped or custom edited name of the table.
+	NewTableName string
+	DirPathTable string
+}
+
+// generateTableSingle generates dao files for a single table.
+func generateTableSingle(ctx context.Context, in generateTableSingleInput) {
+	// Generating table data preparing.
+	fieldMap, err := in.DB.TableFields(ctx, in.TableName)
+	if err != nil {
+		mlog.Fatalf(`fetching tables fields failed for table "%s": %+v`, in.TableName, err)
+	}
+
+	tableNameSnakeCase := gstr.CaseSnake(in.NewTableName)
+	fileName := gstr.Trim(tableNameSnakeCase, "-_.")
+	if len(fileName) > 5 && fileName[len(fileName)-5:] == "_test" {
+		// Add suffix to avoid the table name which contains "_test",
+		// which would make the go file a testing file.
+		fileName += "_table"
+	}
+	path := filepath.FromSlash(gfile.Join(in.DirPathTable, fileName+".go"))
+	in.genItems.AppendGeneratedFilePath(path)
+	if in.OverwriteDao || !gfile.Exists(path) {
+		var (
+			ctx        = context.Background()
+			tplContent = getTemplateFromPathOrDefault(
+				in.TplDaoTablePath, consts.TemplateGenTableContent,
+			)
+		)
+		tplView.ClearAssigns()
+		tplView.Assigns(gview.Params{
+			tplVarGroupName:          in.Group,
+			tplVarTableName:          in.TableName,
+			tplVarTableNameCamelCase: formatFieldName(in.NewTableName, FieldNameCaseCamel),
+			tplVarPackageName:        filepath.Base(in.TablePath),
+			tplVarTableFields:        generateTableFields(fieldMap),
+		})
+		indexContent, err := tplView.ParseContent(ctx, tplContent)
+		if err != nil {
+			mlog.Fatalf("parsing template content failed: %v", err)
+		}
+		if err = gfile.PutContents(path, strings.TrimSpace(indexContent)); err != nil {
+			mlog.Fatalf("writing content to '%s' failed: %v", path, err)
+		} else {
+			utils.GoFmt(path)
+			mlog.Print("generated:", gfile.RealPath(path))
+		}
+	}
+}
+
+// generateTableFields generates and returns the field definition content for specified table.
+func generateTableFields(fields map[string]*gdb.TableField) string {
+	var buf bytes.Buffer
+	fieldNames := make([]string, 0, len(fields))
+	for fieldName := range fields {
+		fieldNames = append(fieldNames, fieldName)
+	}
+	sort.Slice(fieldNames, func(i, j int) bool {
+		return fields[fieldNames[i]].Index < fields[fieldNames[j]].Index // asc
+	})
+	for index, fieldName := range fieldNames {
+		field := fields[fieldName]
+		buf.WriteString("    " + strconv.Quote(field.Name) + ": {\n")
+		buf.WriteString("        Index:   " + gconv.String(field.Index) + ",\n")
+		buf.WriteString("        Name:    " + strconv.Quote(field.Name) + ",\n")
+		buf.WriteString("        Type:    " + strconv.Quote(field.Type) + ",\n")
+		buf.WriteString("        Null:    " + gconv.String(field.Null) + ",\n")
+		buf.WriteString("        Key:     " + strconv.Quote(field.Key) + ",\n")
+		buf.WriteString("        Default: " + generateDefaultValue(field.Default) + ",\n")
+		buf.WriteString("        Extra:   " + strconv.Quote(field.Extra) + ",\n")
+		buf.WriteString("        Comment: " + strconv.Quote(field.Comment) + ",\n")
+		buf.WriteString("    },")
+		if index != len(fieldNames)-1 {
+			buf.WriteString("\n")
+		}
+	}
+	return buf.String()
+}
+
+// generateDefaultValue generates and returns the default value definition for specified field.
+func generateDefaultValue(value interface{}) string {
+	if value == nil {
+		return "nil"
+	}
+	switch v := value.(type) {
+	case string:
+		return strconv.Quote(v)
+	default:
+		return gconv.String(v)
+	}
+}
diff --git a/cmd/gf/internal/cmd/gendao/gendao_tag.go b/cmd/gf/internal/cmd/gendao/gendao_tag.go
index 6feeb8081..25bc84258 100644
--- a/cmd/gf/internal/cmd/gendao/gendao_tag.go
+++ b/cmd/gf/internal/cmd/gendao/gendao_tag.go
@@ -60,6 +60,7 @@ CONFIGURATION SUPPORT
 	CGenDaoBriefGJsonSupport      = `use gJsonSupport to use *gjson.Json instead of string for generated json fields of tables`
 	CGenDaoBriefImportPrefix      = `custom import prefix for generated go files`
 	CGenDaoBriefDaoPath           = `directory path for storing generated dao files under path`
+	CGenDaoBriefTablePath         = `directory path for storing generated table files under path`
 	CGenDaoBriefDoPath            = `directory path for storing generated do files under path`
 	CGenDaoBriefEntityPath        = `directory path for storing generated entity files under path`
 	CGenDaoBriefOverwriteDao      = `overwrite all dao files both inside/outside internal folder`
@@ -69,6 +70,7 @@ CONFIGURATION SUPPORT
 	CGenDaoBriefNoJsonTag         = `no json tag will be added for each field`
 	CGenDaoBriefNoModelComment    = `no model comment will be added for each field`
 	CGenDaoBriefClear             = `delete all generated go files that do not exist in database`
+	CGenDaoBriefGenTable          = `generate table files`
 	CGenDaoBriefTypeMapping       = `custom local type mapping for generated struct attributes relevant to fields of table`
 	CGenDaoBriefFieldMapping      = `custom local type mapping for generated struct attributes relevant to specific fields of table`
 	CGenDaoBriefShardingPattern   = `sharding pattern for table name, e.g. "users_?" will be replace tables "users_001,users_002,..." to "users" dao`
@@ -98,6 +100,7 @@ generated json tag case for model struct, cases are as follows:
 	tplVarTableNameCamelLowerCase = `TplTableNameCamelLowerCase`
 	tplVarTableSharding           = `TplTableSharding`
 	tplVarTableShardingPrefix     = `TplTableShardingPrefix`
+	tplVarTableFields             = `TplTableFields`
 	tplVarPackageImports          = `TplPackageImports`
 	tplVarImportPrefix            = `TplImportPrefix`
 	tplVarStructDefine            = `TplStructDefine`
@@ -126,6 +129,7 @@ func init() {
 		`CGenDaoBriefStdTime`:            CGenDaoBriefStdTime,
 		`CGenDaoBriefWithTime`:           CGenDaoBriefWithTime,
 		`CGenDaoBriefDaoPath`:            CGenDaoBriefDaoPath,
+		`CGenDaoBriefTablePath`:          CGenDaoBriefTablePath,
 		`CGenDaoBriefDoPath`:             CGenDaoBriefDoPath,
 		`CGenDaoBriefEntityPath`:         CGenDaoBriefEntityPath,
 		`CGenDaoBriefGJsonSupport`:       CGenDaoBriefGJsonSupport,
@@ -137,6 +141,7 @@ func init() {
 		`CGenDaoBriefNoJsonTag`:          CGenDaoBriefNoJsonTag,
 		`CGenDaoBriefNoModelComment`:     CGenDaoBriefNoModelComment,
 		`CGenDaoBriefClear`:              CGenDaoBriefClear,
+		`CGenDaoBriefGenTable`:           CGenDaoBriefGenTable,
 		`CGenDaoBriefTypeMapping`:        CGenDaoBriefTypeMapping,
 		`CGenDaoBriefFieldMapping`:       CGenDaoBriefFieldMapping,
 		`CGenDaoBriefShardingPattern`:    CGenDaoBriefShardingPattern,
diff --git a/cmd/gf/internal/cmd/gendao/gendao_test.go b/cmd/gf/internal/cmd/gendao/gendao_test.go
new file mode 100644
index 000000000..80b67d907
--- /dev/null
+++ b/cmd/gf/internal/cmd/gendao/gendao_test.go
@@ -0,0 +1,182 @@
+// Copyright GoFrame gf 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 gendao
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+// Test containsWildcard function.
+func Test_containsWildcard(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(containsWildcard("trade_*"), true)
+		t.Assert(containsWildcard("user_?"), true)
+		t.Assert(containsWildcard("*"), true)
+		t.Assert(containsWildcard("?"), true)
+		t.Assert(containsWildcard("trade_order"), false)
+		t.Assert(containsWildcard(""), false)
+	})
+}
+
+// Test patternToRegex function.
+func Test_patternToRegex(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// * should become .*
+		t.Assert(patternToRegex("trade_*"), "trade_.*")
+		// ? should become .
+		t.Assert(patternToRegex("user_???"), "user_...")
+		// Mixed
+		t.Assert(patternToRegex("*_order_?"), ".*_order_.")
+		// No wildcards - should escape special regex chars
+		t.Assert(patternToRegex("trade_order"), "trade_order")
+		// Just *
+		t.Assert(patternToRegex("*"), ".*")
+	})
+}
+
+// Test filterTablesByPatterns with * wildcard.
+func Test_filterTablesByPatterns_Star(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info", "user_log", "config"}
+
+		// Single pattern with *
+		result := filterTablesByPatterns(allTables, []string{"trade_*"})
+		t.Assert(len(result), 2)
+		t.AssertIN("trade_order", result)
+		t.AssertIN("trade_item", result)
+
+		// Multiple patterns with *
+		result = filterTablesByPatterns(allTables, []string{"trade_*", "user_*"})
+		t.Assert(len(result), 4)
+		t.AssertIN("trade_order", result)
+		t.AssertIN("trade_item", result)
+		t.AssertIN("user_info", result)
+		t.AssertIN("user_log", result)
+	})
+}
+
+// Test filterTablesByPatterns with ? wildcard.
+func Test_filterTablesByPatterns_Question(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info", "user_log", "config"}
+
+		// ? matches single character: user_log (3 chars) but not user_info (4 chars)
+		result := filterTablesByPatterns(allTables, []string{"user_???"})
+		t.Assert(len(result), 1)
+		t.AssertIN("user_log", result)
+		t.AssertNI("user_info", result)
+
+		// user_???? should match user_info (4 chars)
+		result = filterTablesByPatterns(allTables, []string{"user_????"})
+		t.Assert(len(result), 1)
+		t.AssertIN("user_info", result)
+		t.AssertNI("user_log", result)
+	})
+}
+
+// Test filterTablesByPatterns with mixed patterns and exact names.
+func Test_filterTablesByPatterns_Mixed(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info", "user_log", "config"}
+
+		// Pattern + exact name
+		result := filterTablesByPatterns(allTables, []string{"trade_*", "config"})
+		t.Assert(len(result), 3)
+		t.AssertIN("trade_order", result)
+		t.AssertIN("trade_item", result)
+		t.AssertIN("config", result)
+		t.AssertNI("user_info", result)
+		t.AssertNI("user_log", result)
+	})
+}
+
+// Test filterTablesByPatterns with exact names only (backward compatibility).
+func Test_filterTablesByPatterns_ExactNames(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info", "user_log", "config"}
+
+		// Exact names only
+		result := filterTablesByPatterns(allTables, []string{"trade_order", "config"})
+		t.Assert(len(result), 2)
+		t.AssertIN("trade_order", result)
+		t.AssertIN("config", result)
+		t.AssertNI("trade_item", result)
+	})
+}
+
+// Test filterTablesByPatterns - no duplicates when table matches multiple patterns.
+func Test_filterTablesByPatterns_NoDuplicates(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info"}
+
+		// trade_order matches both patterns, should only appear once
+		result := filterTablesByPatterns(allTables, []string{"trade_*", "trade_order"})
+		t.Assert(len(result), 2) // trade_order, trade_item
+
+		// Count occurrences of trade_order
+		count := 0
+		for _, v := range result {
+			if v == "trade_order" {
+				count++
+			}
+		}
+		t.Assert(count, 1) // No duplicates
+	})
+}
+
+// Test filterTablesByPatterns - pattern matches nothing.
+func Test_filterTablesByPatterns_NoMatch(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info"}
+
+		// Pattern that matches nothing
+		result := filterTablesByPatterns(allTables, []string{"nonexistent_*"})
+		t.Assert(len(result), 0)
+	})
+}
+
+// Test filterTablesByPatterns - empty input.
+func Test_filterTablesByPatterns_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item"}
+
+		// Empty patterns
+		result := filterTablesByPatterns(allTables, []string{})
+		t.Assert(len(result), 0)
+
+		// Empty tables
+		result = filterTablesByPatterns([]string{}, []string{"trade_*"})
+		t.Assert(len(result), 0)
+	})
+}
+
+// Test filterTablesByPatterns - "*" matches all tables.
+func Test_filterTablesByPatterns_MatchAll(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info", "user_log", "config"}
+
+		// "*" should match all tables
+		result := filterTablesByPatterns(allTables, []string{"*"})
+		t.Assert(len(result), 5)
+	})
+}
+
+// Test filterTablesByPatterns - non-existent exact table name should be skipped.
+func Test_filterTablesByPatterns_NonExistent(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		allTables := []string{"trade_order", "trade_item", "user_info"}
+
+		// Mix of existing and non-existing tables
+		result := filterTablesByPatterns(allTables, []string{"trade_order", "nonexistent", "user_info"})
+		t.Assert(len(result), 2)
+		t.AssertIN("trade_order", result)
+		t.AssertIN("user_info", result)
+		t.AssertNI("nonexistent", result)
+	})
+}
diff --git a/cmd/gf/internal/cmd/genenums/genenums.go b/cmd/gf/internal/cmd/genenums/genenums.go
index a214072c2..27ff362e8 100644
--- a/cmd/gf/internal/cmd/genenums/genenums.go
+++ b/cmd/gf/internal/cmd/genenums/genenums.go
@@ -55,6 +55,13 @@ func (c CGenEnums) Enums(ctx context.Context, in CGenEnumsInput) (out *CGenEnums
 	if realPath == "" {
 		mlog.Fatalf(`source folder path "%s" does not exist`, in.Src)
 	}
+	// Convert output path to absolute before Chdir, so it remains correct after directory change.
+	// See: https://github.com/gogf/gf/issues/4387
+	outputPath := gfile.Abs(in.Path)
+
+	originPwd := gfile.Pwd()
+	defer gfile.Chdir(originPwd)
+
 	err = gfile.Chdir(realPath)
 	if err != nil {
 		mlog.Fatal(err)
@@ -72,14 +79,14 @@ func (c CGenEnums) Enums(ctx context.Context, in CGenEnumsInput) (out *CGenEnums
 	p := NewEnumsParser(in.Prefixes)
 	p.ParsePackages(pkgs)
 	var enumsContent = gstr.ReplaceByMap(consts.TemplateGenEnums, g.MapStrStr{
-		"{PackageName}": gfile.Basename(gfile.Dir(in.Path)),
+		"{PackageName}": gfile.Basename(gfile.Dir(outputPath)),
 		"{EnumsJson}":   "`" + p.Export() + "`",
 	})
 	enumsContent = gstr.Trim(enumsContent)
-	if err = gfile.PutContents(in.Path, enumsContent); err != nil {
+	if err = gfile.PutContents(outputPath, enumsContent); err != nil {
 		return
 	}
-	mlog.Printf(`generated enums go file: %s`, in.Path)
+	mlog.Printf(`generated enums go file: %s`, outputPath)
 	mlog.Print("done!")
 	return
 }
diff --git a/cmd/gf/internal/cmd/genenums/genenums_z_unit_test.go b/cmd/gf/internal/cmd/genenums/genenums_z_unit_test.go
new file mode 100644
index 000000000..d3a3a58fc
--- /dev/null
+++ b/cmd/gf/internal/cmd/genenums/genenums_z_unit_test.go
@@ -0,0 +1,368 @@
+// Copyright GoFrame gf 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 genenums
+
+import (
+	"go/constant"
+	"path/filepath"
+	"testing"
+
+	"golang.org/x/tools/go/packages"
+
+	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/guid"
+)
+
+func Test_NewEnumsParser(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test creating parser without prefixes
+		p := NewEnumsParser(nil)
+		t.AssertNE(p, nil)
+		t.Assert(len(p.enums), 0)
+		t.Assert(len(p.prefixes), 0)
+		t.AssertNE(p.parsedPkg, nil)
+		t.AssertNE(p.standardPackages, nil)
+	})
+}
+
+func Test_NewEnumsParser_WithPrefixes(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test creating parser with prefixes
+		prefixes := []string{"github.com/gogf", "github.com/test"}
+		p := NewEnumsParser(prefixes)
+		t.AssertNE(p, nil)
+		t.Assert(len(p.prefixes), 2)
+		t.Assert(p.prefixes[0], "github.com/gogf")
+		t.Assert(p.prefixes[1], "github.com/test")
+	})
+}
+
+func Test_EnumsParser_Export_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test exporting empty enums
+		p := NewEnumsParser(nil)
+		result := p.Export()
+		t.Assert(result, "{}")
+	})
+}
+
+func Test_EnumsParser_Export_WithEnums(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test exporting with manually added enums
+		p := NewEnumsParser(nil)
+
+		// Add some test enums
+		p.enums = []EnumItem{
+			{
+				Name:  "StatusActive",
+				Value: "1",
+				Type:  "pkg.Status",
+				Kind:  constant.Int,
+			},
+			{
+				Name:  "StatusInactive",
+				Value: "0",
+				Type:  "pkg.Status",
+				Kind:  constant.Int,
+			},
+			{
+				Name:  "TypeA",
+				Value: "type_a",
+				Type:  "pkg.Type",
+				Kind:  constant.String,
+			},
+		}
+
+		result := p.Export()
+		t.AssertNE(result, "")
+
+		// Parse the result to verify - use raw map to avoid gjson path issues with "."
+		var resultMap map[string][]interface{}
+		err := gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		// Verify Status type has 2 values
+		statusValues := resultMap["pkg.Status"]
+		t.Assert(len(statusValues), 2)
+
+		// Verify Type type has 1 value
+		typeValues := resultMap["pkg.Type"]
+		t.Assert(len(typeValues), 1)
+		t.Assert(typeValues[0], "type_a")
+	})
+}
+
+func Test_EnumsParser_Export_IntValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		p := NewEnumsParser(nil)
+		p.enums = []EnumItem{
+			{Name: "One", Value: "1", Type: "pkg.Int", Kind: constant.Int},
+			{Name: "Two", Value: "2", Type: "pkg.Int", Kind: constant.Int},
+			{Name: "Negative", Value: "-5", Type: "pkg.Int", Kind: constant.Int},
+		}
+
+		result := p.Export()
+		var resultMap map[string][]interface{}
+		err := gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		values := resultMap["pkg.Int"]
+		t.Assert(len(values), 3)
+		// Int values should be exported as integers (stored as float64 in JSON)
+		t.Assert(values[0], float64(1))
+		t.Assert(values[1], float64(2))
+		t.Assert(values[2], float64(-5))
+	})
+}
+
+func Test_EnumsParser_Export_FloatValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		p := NewEnumsParser(nil)
+		p.enums = []EnumItem{
+			{Name: "Pi", Value: "3.14159", Type: "pkg.Float", Kind: constant.Float},
+			{Name: "E", Value: "2.71828", Type: "pkg.Float", Kind: constant.Float},
+		}
+
+		result := p.Export()
+		var resultMap map[string][]interface{}
+		err := gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		values := resultMap["pkg.Float"]
+		t.Assert(len(values), 2)
+	})
+}
+
+func Test_EnumsParser_Export_BoolValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		p := NewEnumsParser(nil)
+		p.enums = []EnumItem{
+			{Name: "True", Value: "true", Type: "pkg.Bool", Kind: constant.Bool},
+			{Name: "False", Value: "false", Type: "pkg.Bool", Kind: constant.Bool},
+		}
+
+		result := p.Export()
+		var resultMap map[string][]interface{}
+		err := gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		values := resultMap["pkg.Bool"]
+		t.Assert(len(values), 2)
+		t.Assert(values[0], true)
+		t.Assert(values[1], false)
+	})
+}
+
+func Test_EnumsParser_Export_StringValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		p := NewEnumsParser(nil)
+		p.enums = []EnumItem{
+			{Name: "Hello", Value: "hello", Type: "pkg.Str", Kind: constant.String},
+			{Name: "World", Value: "world", Type: "pkg.Str", Kind: constant.String},
+		}
+
+		result := p.Export()
+		var resultMap map[string][]interface{}
+		err := gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		values := resultMap["pkg.Str"]
+		t.Assert(len(values), 2)
+		t.Assert(values[0], "hello")
+		t.Assert(values[1], "world")
+	})
+}
+
+func Test_EnumsParser_Export_MixedTypes(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		p := NewEnumsParser(nil)
+		p.enums = []EnumItem{
+			{Name: "IntVal", Value: "42", Type: "pkg.IntType", Kind: constant.Int},
+			{Name: "StrVal", Value: "test", Type: "pkg.StrType", Kind: constant.String},
+			{Name: "BoolVal", Value: "true", Type: "pkg.BoolType", Kind: constant.Bool},
+		}
+
+		result := p.Export()
+		var resultMap map[string][]interface{}
+		err := gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		// Each type should have its own array
+		t.Assert(len(resultMap["pkg.IntType"]), 1)
+		t.Assert(len(resultMap["pkg.StrType"]), 1)
+		t.Assert(len(resultMap["pkg.BoolType"]), 1)
+	})
+}
+
+func Test_EnumItem_Structure(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test EnumItem structure
+		item := EnumItem{
+			Name:  "TestEnum",
+			Value: "test_value",
+			Type:  "github.com/test/pkg.EnumType",
+			Kind:  constant.String,
+		}
+
+		t.Assert(item.Name, "TestEnum")
+		t.Assert(item.Value, "test_value")
+		t.Assert(item.Type, "github.com/test/pkg.EnumType")
+		t.Assert(item.Kind, constant.String)
+	})
+}
+
+func Test_EnumsParser_ParsePackages_Integration(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a temporary directory with a Go package containing enums
+		// Note: The module path must contain "/" for enums to be parsed
+		// (the parser skips std types without "/" in the type name)
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Create go.mod with a path containing "/"
+		goModContent := `module github.com/test/enumtest
+
+go 1.21
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "go.mod"), goModContent)
+		t.AssertNil(err)
+
+		// Create a Go file with enum definitions
+		enumsContent := `package enumtest
+
+type Status int
+
+const (
+	StatusActive   Status = 1
+	StatusInactive Status = 0
+)
+
+type Color string
+
+const (
+	ColorRed   Color = "red"
+	ColorGreen Color = "green"
+	ColorBlue  Color = "blue"
+)
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "enums.go"), enumsContent)
+		t.AssertNil(err)
+
+		// Load the package
+		cfg := &packages.Config{
+			Dir:   tempDir,
+			Mode:  pkgLoadMode,
+			Tests: false,
+		}
+		pkgs, err := packages.Load(cfg)
+		t.AssertNil(err)
+		t.Assert(len(pkgs) > 0, true)
+
+		// Parse the packages
+		p := NewEnumsParser(nil)
+		p.ParsePackages(pkgs)
+
+		// Export and verify - result should contain parsed enums
+		result := p.Export()
+		// Verify the export contains some data
+		t.Assert(len(result) > 2, true) // More than just "{}"
+
+		// Parse result as raw map to handle keys with "/"
+		var resultMap map[string][]interface{}
+		err = gjson.DecodeTo(result, &resultMap)
+		t.AssertNil(err)
+
+		// Verify Status enum was parsed (type will be "github.com/test/enumtest.Status")
+		statusKey := "github.com/test/enumtest.Status"
+		statusValues, hasStatus := resultMap[statusKey]
+		t.Assert(hasStatus, true)
+		t.Assert(len(statusValues), 2)
+
+		// Verify Color enum was parsed
+		colorKey := "github.com/test/enumtest.Color"
+		colorValues, hasColor := resultMap[colorKey]
+		t.Assert(hasColor, true)
+		t.Assert(len(colorValues), 3)
+	})
+}
+
+func Test_EnumsParser_ParsePackages_WithPrefixes(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a temporary directory with a Go package
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Create go.mod with a specific module name
+		goModContent := `module github.com/allowed/pkg
+
+go 1.21
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "go.mod"), goModContent)
+		t.AssertNil(err)
+
+		// Create a Go file with enum definitions
+		enumsContent := `package pkg
+
+type Status int
+
+const (
+	StatusOK Status = 1
+)
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "enums.go"), enumsContent)
+		t.AssertNil(err)
+
+		// Load the package
+		cfg := &packages.Config{
+			Dir:   tempDir,
+			Mode:  pkgLoadMode,
+			Tests: false,
+		}
+		pkgs, err := packages.Load(cfg)
+		t.AssertNil(err)
+
+		// Parse with prefix filter that matches
+		p := NewEnumsParser([]string{"github.com/allowed"})
+		p.ParsePackages(pkgs)
+
+		result := p.Export()
+		// Should have enums because prefix matches
+		t.AssertNE(result, "{}")
+
+		// Parse with prefix filter that doesn't match
+		p2 := NewEnumsParser([]string{"github.com/other"})
+		p2.ParsePackages(pkgs)
+
+		result2 := p2.Export()
+		// Should be empty because prefix doesn't match
+		t.Assert(result2, "{}")
+	})
+}
+
+func Test_getStandardPackages(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		stdPkgs := getStandardPackages()
+		t.AssertNE(stdPkgs, nil)
+		t.Assert(len(stdPkgs) > 0, true)
+
+		// Verify some common standard packages are included
+		_, hasFmt := stdPkgs["fmt"]
+		t.Assert(hasFmt, true)
+
+		_, hasOs := stdPkgs["os"]
+		t.Assert(hasOs, true)
+
+		_, hasContext := stdPkgs["context"]
+		t.Assert(hasContext, true)
+	})
+}
diff --git a/cmd/gf/internal/cmd/geninit/geninit.go b/cmd/gf/internal/cmd/geninit/geninit.go
new file mode 100644
index 000000000..3eeab7afd
--- /dev/null
+++ b/cmd/gf/internal/cmd/geninit/geninit.go
@@ -0,0 +1,269 @@
+// Copyright GoFrame gf 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 geninit
+
+import (
+	"context"
+	"path/filepath"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gstr"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+)
+
+// ProcessOptions contains options for the Process function
+type ProcessOptions struct {
+	SelectVersion bool   // Enable interactive version selection
+	ModulePath    string // Custom go.mod module path (e.g., github.com/xxx/xxx)
+	UpgradeDeps   bool   // Upgrade dependencies to latest (go get -u ./...)
+}
+
+// Process handles the template generation flow from remote repository
+func Process(ctx context.Context, repo, name string, opts *ProcessOptions) error {
+	if opts == nil {
+		opts = &ProcessOptions{}
+	}
+
+	// 0. Check Go environment first
+	mlog.Print("Checking Go environment...")
+	goEnv, err := CheckGoEnv(ctx)
+	if err != nil {
+		mlog.Printf("Go environment check failed: %v", err)
+		return err
+	}
+	mlog.Printf("Go environment OK (version: %s)", goEnv.GOVERSION)
+
+	// Check if this is a git subdirectory URL
+	if IsSubdirRepo(repo) {
+		return processGitSubdir(ctx, repo, name, opts)
+	}
+
+	// Try Go module download first, fallback to git subdirectory if it fails
+	// This handles edge cases where the heuristic may be incorrect
+	err = processGoModule(ctx, repo, name, opts)
+	if err != nil {
+		mlog.Printf("Go module download failed, trying git subdirectory mode: %v", err)
+		mlog.Print("Note: If this is a git subdirectory, you can force git mode by using a full git URL")
+
+		// If Go module download fails, try git subdirectory as fallback
+		// This handles cases where the heuristic incorrectly classified a git subdir as Go module
+		if IsSubdirRepo(repo) {
+			mlog.Print("Falling back to git subdirectory download...")
+			return processGitSubdir(ctx, repo, name, opts)
+		}
+	}
+
+	return err
+}
+
+// processGoModule handles standard Go module download via go get
+func processGoModule(ctx context.Context, repo, name string, opts *ProcessOptions) error {
+	// Extract module path (without version)
+	modulePath := repo
+	specifiedVersion := ""
+	if gstr.Contains(repo, "@") {
+		parts := gstr.Split(repo, "@")
+		modulePath = parts[0]
+		specifiedVersion = parts[1]
+	}
+
+	// Default name to repo basename if empty
+	if name == "" {
+		name = filepath.Base(modulePath)
+	}
+
+	// Determine the target module path for go.mod
+	targetModulePath := name
+	if opts.ModulePath != "" {
+		targetModulePath = opts.ModulePath
+	}
+
+	// 1. Determine version to use
+	var targetVersion string
+	if specifiedVersion != "" {
+		// User specified version, try to use it first
+		targetVersion = specifiedVersion
+		mlog.Printf("Using specified version: %s", targetVersion)
+	} else if opts.SelectVersion {
+		// Interactive version selection
+		mlog.Print("Fetching available versions...")
+		versionInfo, err := GetModuleVersions(ctx, modulePath)
+		if err != nil {
+			mlog.Printf("Failed to get versions: %v", err)
+			return err
+		}
+
+		targetVersion, err = SelectVersion(ctx, versionInfo.Versions, modulePath)
+		if err != nil {
+			mlog.Printf("Version selection failed: %v", err)
+			return err
+		}
+	} else {
+		// Default: use latest version
+		mlog.Print("Fetching latest version...")
+		latest, err := GetLatestVersion(ctx, modulePath)
+		if err != nil {
+			mlog.Printf("Failed to get latest version, will try @latest tag: %v", err)
+			targetVersion = "latest"
+		} else {
+			targetVersion = latest
+			mlog.Printf("Latest version: %s", targetVersion)
+		}
+	}
+
+	// 2. Download Template with determined version
+	repoWithVersion := modulePath + "@" + targetVersion
+	srcDir, err := downloadTemplate(ctx, repoWithVersion)
+	if err != nil {
+		// If specified version download failed, offer to select from available versions
+		if specifiedVersion != "" {
+			mlog.Printf("Failed to download specified version '%s': %v", specifiedVersion, err)
+			mlog.Print("Fetching available versions...")
+
+			versionInfo, verErr := GetModuleVersions(ctx, modulePath)
+			if verErr != nil {
+				mlog.Printf("Failed to get available versions: %v", verErr)
+				return err // Return original download error
+			}
+
+			if len(versionInfo.Versions) == 0 {
+				mlog.Print("No versions available for this module")
+				return err
+			}
+
+			// Let user select from available versions
+			selectedVersion, selErr := SelectVersion(ctx, versionInfo.Versions, modulePath)
+			if selErr != nil {
+				mlog.Printf("Version selection failed: %v", selErr)
+				return selErr
+			}
+
+			// Retry download with selected version
+			targetVersion = selectedVersion
+			repoWithVersion = modulePath + "@" + targetVersion
+			srcDir, err = downloadTemplate(ctx, repoWithVersion)
+			if err != nil {
+				mlog.Printf("Download failed: %v", err)
+				return err
+			}
+		} else {
+			mlog.Printf("Download failed: %v", err)
+			return err
+		}
+	}
+
+	mlog.Debugf("Template located at: %s", srcDir)
+
+	// 3. Generate Project
+	if err := generateProject(ctx, srcDir, name, modulePath, targetModulePath); err != nil {
+		mlog.Printf("Generation failed: %v", err)
+		return err
+	}
+
+	// 4. Handle dependencies
+	var projectDir string
+	if name == "." {
+		projectDir = gfile.Pwd()
+	} else {
+		projectDir = filepath.Join(gfile.Pwd(), name)
+	}
+	if opts.UpgradeDeps {
+		// Upgrade all dependencies to latest
+		if err := upgradeDependencies(ctx, projectDir); err != nil {
+			mlog.Printf("Failed to upgrade dependencies: %v", err)
+		}
+	} else {
+		// Default: just tidy dependencies
+		if err := tidyDependencies(ctx, projectDir); err != nil {
+			mlog.Printf("Failed to tidy dependencies: %v", err)
+		}
+	}
+
+	return nil
+}
+
+// processGitSubdir handles git subdirectory download via sparse checkout
+func processGitSubdir(ctx context.Context, repo, name string, opts *ProcessOptions) error {
+	mlog.Print("Detected subdirectory URL, using git sparse checkout...")
+
+	// Check if git is available
+	gitVersion, err := CheckGitEnv(ctx)
+	if err != nil {
+		mlog.Printf("Git is required for subdirectory templates: %v", err)
+		return err
+	}
+	mlog.Printf("Git available (%s)", gitVersion)
+
+	// Download via git sparse checkout
+	srcDir, gitInfo, err := downloadGitSubdir(ctx, repo)
+	if err != nil {
+		mlog.Printf("Git download failed: %v", err)
+		return err
+	}
+
+	// Clean up temp directory after generation
+	// The temp dir is parent of parent of srcDir (tempDir/repo/subpath)
+	tempDir := filepath.Dir(filepath.Dir(srcDir))
+	if tempDir != "" && gfile.Exists(tempDir) && gstr.Contains(tempDir, "gf-init-git") {
+		defer func() {
+			if err := gfile.Remove(tempDir); err != nil {
+				mlog.Debugf("Failed to remove temp directory %s: %v", tempDir, err)
+			} else {
+				mlog.Debugf("Cleaned up temp directory: %s", tempDir)
+			}
+		}()
+	}
+
+	// Default name to subpath basename if empty
+	if name == "" {
+		name = filepath.Base(gitInfo.SubPath)
+	}
+
+	// Get original module name from go.mod (might be "main" or something else)
+	oldModule := GetModuleNameFromGoMod(srcDir)
+	if oldModule == "" {
+		// Fallback: construct from git info
+		oldModule = gitInfo.Host + "/" + gitInfo.Owner + "/" + gitInfo.Repo + "/" + gitInfo.SubPath
+	}
+
+	// Determine the target module path for go.mod
+	targetModulePath := name
+	if opts.ModulePath != "" {
+		targetModulePath = opts.ModulePath
+	}
+
+	mlog.Debugf("Template located at: %s", srcDir)
+	mlog.Debugf("Original module: %s", oldModule)
+
+	// Generate Project
+	if err := generateProject(ctx, srcDir, name, oldModule, targetModulePath); err != nil {
+		mlog.Printf("Generation failed: %v", err)
+		return err
+	}
+
+	// Handle dependencies
+	var projectDir string
+	if name == "." {
+		projectDir = gfile.Pwd()
+	} else {
+		projectDir = filepath.Join(gfile.Pwd(), name)
+	}
+	if opts.UpgradeDeps {
+		// Upgrade all dependencies to latest
+		if err := upgradeDependencies(ctx, projectDir); err != nil {
+			mlog.Printf("Failed to upgrade dependencies: %v", err)
+		}
+	} else {
+		// Default: just tidy dependencies
+		if err := tidyDependencies(ctx, projectDir); err != nil {
+			mlog.Printf("Failed to tidy dependencies: %v", err)
+		}
+	}
+
+	return nil
+}
diff --git a/cmd/gf/internal/cmd/geninit/geninit_ast.go b/cmd/gf/internal/cmd/geninit/geninit_ast.go
new file mode 100644
index 000000000..fde378291
--- /dev/null
+++ b/cmd/gf/internal/cmd/geninit/geninit_ast.go
@@ -0,0 +1,125 @@
+// Copyright GoFrame gf 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 geninit
+
+import (
+	"bytes"
+	"context"
+	"go/ast"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/gogf/gf/v2/os/gfile"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+)
+
+// ASTReplacer handles import path replacement using Go AST
+type ASTReplacer struct {
+	oldModule string
+	newModule string
+	fset      *token.FileSet
+}
+
+// NewASTReplacer creates a new AST-based import replacer
+func NewASTReplacer(oldModule, newModule string) *ASTReplacer {
+	return &ASTReplacer{
+		oldModule: oldModule,
+		newModule: newModule,
+		fset:      token.NewFileSet(),
+	}
+}
+
+// ReplaceInFile replaces import paths in a single Go file
+func (r *ASTReplacer) ReplaceInFile(ctx context.Context, filePath string) error {
+	// Read file content
+	content := gfile.GetContents(filePath)
+	if content == "" {
+		return nil
+	}
+
+	// Parse the file
+	file, err := parser.ParseFile(r.fset, filePath, content, parser.ParseComments)
+	if err != nil {
+		mlog.Debugf("Failed to parse %s: %v", filePath, err)
+		return nil // Skip files that can't be parsed
+	}
+
+	// Track if any changes were made
+	changed := false
+
+	// Traverse and modify imports
+	ast.Inspect(file, func(n ast.Node) bool {
+		switch x := n.(type) {
+		case *ast.ImportSpec:
+			if x.Path != nil {
+				importPath := strings.Trim(x.Path.Value, `"`)
+				if strings.HasPrefix(importPath, r.oldModule) {
+					// Replace only the leading module prefix for clarity and correctness.
+					newPath := r.newModule + strings.TrimPrefix(importPath, r.oldModule)
+					x.Path.Value = `"` + newPath + `"`
+					changed = true
+					mlog.Debugf("Replaced import: %s -> %s in %s", importPath, newPath, filePath)
+				}
+			}
+		}
+		return true
+	})
+
+	if !changed {
+		return nil
+	}
+
+	// Write back to file without formatting.
+	// Formatting will be handled by formatGoFiles after all replacements are done.
+	var buf bytes.Buffer
+	if err := printer.Fprint(&buf, r.fset, file); err != nil {
+		return err
+	}
+
+	return gfile.PutContents(filePath, buf.String())
+}
+
+// ReplaceInDir replaces import paths in all Go files in a directory (recursively)
+func (r *ASTReplacer) ReplaceInDir(ctx context.Context, dir string) error {
+	mlog.Printf("Replacing imports: %s -> %s", r.oldModule, r.newModule)
+
+	// Find all .go files
+	files, err := findGoFiles(dir)
+	if err != nil {
+		return err
+	}
+
+	for _, file := range files {
+		if err := r.ReplaceInFile(ctx, file); err != nil {
+			mlog.Printf("Failed to process %s: %v", file, err)
+		}
+	}
+
+	return nil
+}
+
+// findGoFiles recursively finds all .go files in a directory
+func findGoFiles(dir string) ([]string, error) {
+	var files []string
+
+	err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() && strings.HasSuffix(path, ".go") {
+			files = append(files, path)
+		}
+		return nil
+	})
+
+	return files, err
+}
diff --git a/cmd/gf/internal/cmd/geninit/geninit_downloader.go b/cmd/gf/internal/cmd/geninit/geninit_downloader.go
new file mode 100644
index 000000000..cb3150e8c
--- /dev/null
+++ b/cmd/gf/internal/cmd/geninit/geninit_downloader.go
@@ -0,0 +1,111 @@
+// Copyright GoFrame gf 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 geninit
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gstr"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+)
+
+// downloadTemplate fetches the remote repository using go get
+func downloadTemplate(ctx context.Context, repo string) (string, error) {
+	// 1. Create a temporary directory workspace
+	tempDir := gfile.Temp("gf-init-cli")
+	if tempDir == "" {
+		return "", fmt.Errorf("failed to create temporary directory")
+	}
+	if err := gfile.Mkdir(tempDir); err != nil {
+		return "", err
+	}
+	defer func() {
+		if err := gfile.Remove(tempDir); err != nil {
+			mlog.Debugf("Failed to remove temp directory %s: %v", tempDir, err)
+		}
+	}() // Clean up the temp workspace
+
+	mlog.Debugf("Using temp workspace: %s", tempDir)
+
+	// 2. Initialize a temp go module to perform go get
+	// We run commands inside the temp directory
+	if err := runCmd(ctx, tempDir, "go", "mod", "init", "temp"); err != nil {
+		return "", err
+	}
+
+	// 3. Run go get <repo>
+	// Try different version strategies: original -> @latest -> @master
+	moduleName := repo
+	if gstr.Contains(repo, "@") {
+		moduleName = gstr.Split(repo, "@")[0]
+	}
+
+	var downloadErrs []string
+	versionsToTry := []string{repo}
+	if !gstr.Contains(repo, "@") {
+		versionsToTry = append(versionsToTry, repo+"@latest", repo+"@master")
+	}
+
+	var successRepo string
+	for _, tryRepo := range versionsToTry {
+		mlog.Printf("Downloading template %s...", tryRepo)
+		if err := runCmd(ctx, tempDir, "go", "get", tryRepo); err == nil {
+			successRepo = tryRepo
+			break
+		} else {
+			downloadErrs = append(downloadErrs, fmt.Sprintf("%s: %v", tryRepo, err))
+			mlog.Debugf("Failed to download %s, trying next...", tryRepo)
+		}
+	}
+
+	if successRepo == "" {
+		errMsg := "all download attempts failed"
+		if len(downloadErrs) > 0 {
+			errMsg = strings.Join(downloadErrs, "; ")
+		}
+		return "", fmt.Errorf("failed to download repo %s: %s", repo, errMsg)
+	}
+
+	// 4. Find the local path using go list -m -json <repo>
+	listCmd := exec.CommandContext(ctx, "go", "list", "-m", "-json", moduleName)
+	listCmd.Dir = tempDir
+	output, err := listCmd.Output()
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			return "", fmt.Errorf("go list failed: %s", string(exitErr.Stderr))
+		}
+		return "", fmt.Errorf("failed to locate module path: %w", err)
+	}
+
+	var modInfo struct {
+		Dir string `json:"Dir"`
+	}
+	if err := json.Unmarshal(output, &modInfo); err != nil {
+		return "", fmt.Errorf("failed to parse go list output: %w", err)
+	}
+
+	if modInfo.Dir == "" {
+		return "", fmt.Errorf("module directory not found for %s", repo)
+	}
+
+	return modInfo.Dir, nil
+}
+
+func runCmd(ctx context.Context, dir string, name string, args ...string) error {
+	cmd := exec.CommandContext(ctx, name, args...)
+	cmd.Dir = dir
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
diff --git a/cmd/gf/internal/cmd/geninit/geninit_env.go b/cmd/gf/internal/cmd/geninit/geninit_env.go
new file mode 100644
index 000000000..4f5b27812
--- /dev/null
+++ b/cmd/gf/internal/cmd/geninit/geninit_env.go
@@ -0,0 +1,90 @@
+// Copyright GoFrame gf 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 geninit
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+)
+
+// GoEnv represents Go environment variables
+type GoEnv struct {
+	GOVERSION   string `json:"GOVERSION"`
+	GOROOT      string `json:"GOROOT"`
+	GOPATH      string `json:"GOPATH"`
+	GOMODCACHE  string `json:"GOMODCACHE"`
+	GOPROXY     string `json:"GOPROXY"`
+	GO111MODULE string `json:"GO111MODULE"`
+}
+
+// CheckGoEnv verifies Go is installed and properly configured
+func CheckGoEnv(ctx context.Context) (*GoEnv, error) {
+	// 1. Check if go binary exists
+	goPath, err := exec.LookPath("go")
+	if err != nil {
+		return nil, fmt.Errorf("go is not installed or not in PATH: %w", err)
+	}
+	mlog.Debugf("Found go binary at: %s", goPath)
+
+	// 2. Get go env as JSON
+	cmd := exec.CommandContext(ctx, "go", "env", "-json")
+	output, err := cmd.Output()
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			return nil, fmt.Errorf("go env failed: %s", string(exitErr.Stderr))
+		}
+		return nil, fmt.Errorf("failed to run go env: %w", err)
+	}
+
+	// 3. Parse JSON output
+	var env GoEnv
+	if err := json.Unmarshal(output, &env); err != nil {
+		return nil, fmt.Errorf("failed to parse go env output: %w", err)
+	}
+
+	// 4. Validate critical environment variables
+	if env.GOROOT == "" {
+		return nil, fmt.Errorf("GOROOT is not set")
+	}
+	if env.GOMODCACHE == "" && env.GOPATH == "" {
+		return nil, fmt.Errorf("neither GOMODCACHE nor GOPATH is set")
+	}
+
+	mlog.Debugf("Go Version: %s", env.GOVERSION)
+	mlog.Debugf("GOROOT: %s", env.GOROOT)
+	mlog.Debugf("GOMODCACHE: %s", env.GOMODCACHE)
+	mlog.Debugf("GOPROXY: %s", env.GOPROXY)
+
+	return &env, nil
+}
+
+// CheckGitEnv verifies Git is installed and returns its version
+func CheckGitEnv(ctx context.Context) (string, error) {
+	// 1. Check if git binary exists
+	gitPath, err := exec.LookPath("git")
+	if err != nil {
+		return "", fmt.Errorf("git is not installed or not in PATH: %w", err)
+	}
+	mlog.Debugf("Found git binary at: %s", gitPath)
+
+	// 2. Get git version
+	cmd := exec.CommandContext(ctx, "git", "--version")
+	output, err := cmd.Output()
+	if err != nil {
+		return "", fmt.Errorf("failed to get git version: %w", err)
+	}
+
+	version := strings.TrimSpace(string(output))
+	mlog.Debugf("Git version: %s", version)
+
+	return version, nil
+}
diff --git a/cmd/gf/internal/cmd/geninit/geninit_generator.go b/cmd/gf/internal/cmd/geninit/geninit_generator.go
new file mode 100644
index 000000000..62fd395db
--- /dev/null
+++ b/cmd/gf/internal/cmd/geninit/geninit_generator.go
@@ -0,0 +1,146 @@
+// Copyright GoFrame gf 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 geninit
+
+import (
+	"context"
+	"fmt"
+	"go/format"
+	"path/filepath"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gstr"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+)
+
+// generateProject copies the template to the destination and performs cleanup
+// oldModule: original module path from template
+// newModule: target module path for go.mod (can be different from project name)
+func generateProject(ctx context.Context, srcPath, name, oldModule, newModule string) error {
+	pwd := gfile.Pwd()
+
+	dstPath := filepath.Join(pwd, name)
+	if name == "." {
+		dstPath = pwd
+	}
+
+	if gfile.Exists(dstPath) && !gfile.IsEmpty(dstPath) {
+		return fmt.Errorf("target directory %s is not empty", dstPath)
+	}
+
+	mlog.Printf("Generating project in %s...", dstPath)
+
+	// 1. Copy files
+	if err := gfile.Copy(srcPath, dstPath); err != nil {
+		return err
+	}
+
+	// 2. Clean up .git directory
+	gitDir := filepath.Join(dstPath, ".git")
+	if gfile.Exists(gitDir) {
+		if err := gfile.Remove(gitDir); err != nil {
+			mlog.Debugf("Failed to remove .git directory: %v", err)
+		}
+	}
+
+	// 3. Clean up go.work and go.work.sum (workspace files should not be in generated project)
+	for _, workFile := range []string{"go.work", "go.work.sum"} {
+		workPath := filepath.Join(dstPath, workFile)
+		if gfile.Exists(workPath) {
+			if err := gfile.Remove(workPath); err != nil {
+				mlog.Printf("Failed to remove %s: %v", workFile, err)
+			} else {
+				mlog.Debugf("Removed %s", workFile)
+			}
+		}
+	}
+
+	// 4. Update go.mod module name
+	goModPath := filepath.Join(dstPath, "go.mod")
+	if gfile.Exists(goModPath) {
+		content := gfile.GetContents(goModPath)
+		lines := gstr.Split(content, "\n")
+		if len(lines) > 0 && gstr.HasPrefix(lines[0], "module ") {
+			lines[0] = "module " + newModule
+			newContent := gstr.Join(lines, "\n")
+			if err := gfile.PutContents(goModPath, newContent); err != nil {
+				mlog.Printf("Failed to update go.mod: %v", err)
+			}
+		}
+	}
+
+	// 5. Use AST to replace import paths in all Go files
+	if oldModule != "" && oldModule != newModule {
+		replacer := NewASTReplacer(oldModule, newModule)
+		if err := replacer.ReplaceInDir(ctx, dstPath); err != nil {
+			return fmt.Errorf("failed to replace imports: %w", err)
+		}
+	}
+
+	// 6. Format the generated Go files using go/format (not imports.Process)
+	// Note: We use formatGoFiles instead of utils.GoFmt because imports.Process
+	// may incorrectly "fix" local import paths by replacing them with cached module paths.
+	formatGoFiles(dstPath)
+
+	mlog.Print("Project generated successfully!")
+	return nil
+}
+
+// tidyDependencies runs go mod tidy in the project directory
+func tidyDependencies(ctx context.Context, projectDir string) error {
+	mlog.Print("Tidying dependencies (go mod tidy)...")
+	if err := runCmd(ctx, projectDir, "go", "mod", "tidy"); err != nil {
+		return fmt.Errorf("go mod tidy failed: %w", err)
+	}
+	mlog.Print("Dependencies tidied successfully!")
+	return nil
+}
+
+// upgradeDependencies runs go get -u ./... to upgrade all dependencies to latest
+func upgradeDependencies(ctx context.Context, projectDir string) error {
+	mlog.Print("Upgrading dependencies to latest (go get -u ./...)...")
+	if err := runCmd(ctx, projectDir, "go", "get", "-u", "./..."); err != nil {
+		return fmt.Errorf("go get -u failed: %w", err)
+	}
+	// Run tidy again after upgrade
+	if err := runCmd(ctx, projectDir, "go", "mod", "tidy"); err != nil {
+		return fmt.Errorf("go mod tidy after upgrade failed: %w", err)
+	}
+	mlog.Print("Dependencies upgraded successfully!")
+	return nil
+}
+
+// formatGoFiles formats all Go files in the directory using go/format.
+// Unlike imports.Process, this only formats code without modifying imports,
+// which prevents incorrect "fixing" of local import paths.
+func formatGoFiles(dir string) {
+	files, err := findGoFiles(dir)
+	if err != nil {
+		mlog.Printf("Failed to find Go files for formatting: %v", err)
+		return
+	}
+
+	for _, file := range files {
+		content := gfile.GetContents(file)
+		if content == "" {
+			continue
+		}
+
+		formatted, err := format.Source([]byte(content))
+		if err != nil {
+			mlog.Debugf("Failed to format %s: %v", file, err)
+			continue
+		}
+
+		if string(formatted) != content {
+			if err := gfile.PutContents(file, string(formatted)); err != nil {
+				mlog.Debugf("Failed to write formatted file %s: %v", file, err)
+			}
+		}
+	}
+}
diff --git a/cmd/gf/internal/cmd/geninit/geninit_git_downloader.go b/cmd/gf/internal/cmd/geninit/geninit_git_downloader.go
new file mode 100644
index 000000000..ec26f13a1
--- /dev/null
+++ b/cmd/gf/internal/cmd/geninit/geninit_git_downloader.go
@@ -0,0 +1,241 @@
+// Copyright GoFrame gf 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 geninit
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gstr"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+)
+
+// GitRepoInfo holds parsed git repository information
+type GitRepoInfo struct {
+	Host     string // e.g., github.com
+	Owner    string // e.g., gogf
+	Repo     string // e.g., examples
+	Branch   string // e.g., main (default: main)
+	SubPath  string // e.g., httpserver/jwt
+	CloneURL string // e.g., https://github.com/gogf/examples.git
+}
+
+// ParseGitURL parses a git URL and extracts repository info
+// Supports formats:
+//   - github.com/owner/repo
+//   - github.com/owner/repo/subdir/path
+//   - github.com/owner/repo/tree/branch/subdir/path (from GitHub web URL)
+func ParseGitURL(url string) (*GitRepoInfo, error) {
+	// Remove protocol prefix if present
+	url = strings.TrimPrefix(url, "https://")
+	url = strings.TrimPrefix(url, "http://")
+	url = strings.TrimSuffix(url, ".git")
+
+	// Remove version suffix like @v1.0.0
+	if idx := strings.Index(url, "@"); idx != -1 {
+		url = url[:idx]
+	}
+
+	parts := strings.Split(url, "/")
+	if len(parts) < 3 {
+		return nil, fmt.Errorf("invalid git URL: %s", url)
+	}
+
+	info := &GitRepoInfo{
+		Host:   parts[0],
+		Owner:  parts[1],
+		Repo:   parts[2],
+		Branch: "main", // default branch
+	}
+
+	// Check for /tree/branch/ pattern (GitHub web URL)
+	if len(parts) > 4 && parts[3] == "tree" {
+		info.Branch = parts[4]
+		if len(parts) > 5 {
+			info.SubPath = strings.Join(parts[5:], "/")
+		}
+	} else if len(parts) > 3 {
+		// Direct subpath: github.com/owner/repo/subdir/path
+		info.SubPath = strings.Join(parts[3:], "/")
+	}
+
+	info.CloneURL = fmt.Sprintf("https://%s/%s/%s.git", info.Host, info.Owner, info.Repo)
+
+	return info, nil
+}
+
+// IsSubdirRepo checks if the URL points to a subdirectory of a repository
+// Returns false for Go module paths (which may have /vN suffix or nested module paths)
+// Note: This uses heuristics that may have false positives/negatives in edge cases
+func IsSubdirRepo(url string) bool {
+	info, err := ParseGitURL(url)
+	if err != nil {
+		return false
+	}
+	if info.SubPath == "" {
+		return false
+	}
+
+	// Check if this looks like a Go module path rather than a git subdirectory
+	// Go modules can have nested paths like github.com/owner/repo/cmd/tool/v2
+	// We should try to resolve it as a Go module first
+
+	// If the URL can be resolved as a Go module, it's not a subdir repo
+	// We use a heuristic: check if the full path looks like a valid Go module
+	// by checking if it ends with /vN (major version) or contains common module patterns
+
+	// Remove version suffix for checking
+	cleanURL := url
+	if before, _, ok := strings.Cut(url, "@"); ok {
+		cleanURL = before
+	}
+
+	// Check if the path ends with /vN (Go module major version)
+	parts := strings.Split(cleanURL, "/")
+	if len(parts) > 0 {
+		lastPart := parts[len(parts)-1]
+		if len(lastPart) >= 2 && lastPart[0] == 'v' {
+			// Check if it's v2, v3, etc.
+			if _, err := fmt.Sscanf(lastPart, "v%d", new(int)); err == nil {
+				// This looks like a Go module with major version suffix
+				// It could be either a versioned module or a subdir ending in vN
+				// We'll treat it as a Go module and let go get handle it
+				mlog.Debugf("URL %s detected as Go module (ends with /vN)", url)
+				return false
+			}
+		}
+	}
+
+	// For GitHub URLs, check if the subpath could be a nested Go module
+	// Common patterns: cmd/*, internal/*, pkg/*, contrib/*
+	subPathParts := strings.Split(info.SubPath, "/")
+	if len(subPathParts) > 0 {
+		firstPart := subPathParts[0]
+		// These are common Go module nesting patterns
+		if firstPart == "cmd" || firstPart == "contrib" || firstPart == "tools" {
+			// This might be a nested Go module, not a simple subdirectory
+			// Let go get try first
+			mlog.Debugf("URL %s detected as Go module (starts with common pattern)", url)
+			return false
+		}
+	}
+
+	mlog.Debugf("URL %s detected as git subdirectory", url)
+	return true
+}
+
+// downloadGitSubdir downloads a subdirectory from a git repository using sparse checkout
+func downloadGitSubdir(ctx context.Context, repoURL string) (string, *GitRepoInfo, error) {
+	info, err := ParseGitURL(repoURL)
+	if err != nil {
+		return "", nil, err
+	}
+
+	if info.SubPath == "" {
+		return "", nil, fmt.Errorf("not a subdirectory URL: %s", repoURL)
+	}
+
+	// Create temp directory for clone
+	tempDir := gfile.Temp("gf-init-git")
+	if tempDir == "" {
+		return "", nil, fmt.Errorf("failed to create temporary directory")
+	}
+	if err := gfile.Mkdir(tempDir); err != nil {
+		return "", nil, err
+	}
+
+	cloneDir := filepath.Join(tempDir, info.Repo)
+	mlog.Debugf("Using git temp workspace: %s", tempDir)
+	mlog.Printf("Cloning %s (sparse checkout: %s)...", info.CloneURL, info.SubPath)
+
+	// 1. Clone with no checkout, filter, and sparse
+	if err := runCmd(ctx, tempDir, "git", "clone", "--filter=blob:none", "--no-checkout", "--sparse", info.CloneURL); err != nil {
+		// Fallback: try without filter for older git versions
+		mlog.Debugf("Sparse clone failed, trying full clone...")
+		if err := gfile.Remove(cloneDir); err != nil {
+			mlog.Debugf("Failed to remove clone directory: %v", err)
+		}
+		if err := runCmd(ctx, tempDir, "git", "clone", "--no-checkout", info.CloneURL); err != nil {
+			if err := gfile.Remove(tempDir); err != nil {
+				mlog.Debugf("Failed to remove temp directory: %v", err)
+			}
+			return "", nil, fmt.Errorf("git clone failed: %w", err)
+		}
+	}
+
+	// 2. Set sparse-checkout to the subpath
+	if err := runCmd(ctx, cloneDir, "git", "sparse-checkout", "set", info.SubPath); err != nil {
+		// Fallback for older git: use sparse-checkout init + set
+		mlog.Debugf("sparse-checkout set failed, trying legacy method...")
+		if err := runCmd(ctx, cloneDir, "git", "sparse-checkout", "init", "--cone"); err != nil {
+			if err := gfile.Remove(tempDir); err != nil {
+				mlog.Debugf("Failed to remove temp directory: %v", err)
+			}
+			return "", nil, fmt.Errorf("git sparse-checkout init (legacy) failed: %w", err)
+		}
+		if err := runCmd(ctx, cloneDir, "git", "sparse-checkout", "set", info.SubPath); err != nil {
+			if err := gfile.Remove(tempDir); err != nil {
+				mlog.Debugf("Failed to remove temp directory: %v", err)
+			}
+			return "", nil, fmt.Errorf("git sparse-checkout set (legacy) failed: %w", err)
+		}
+	}
+
+	// 3. Checkout the branch
+	if err := runCmd(ctx, cloneDir, "git", "checkout", info.Branch); err != nil {
+		// Try master if main fails
+		if info.Branch == "main" {
+			mlog.Debugf("Branch 'main' not found, trying 'master'...")
+			info.Branch = "master"
+			if err := runCmd(ctx, cloneDir, "git", "checkout", "master"); err != nil {
+				if err := gfile.Remove(tempDir); err != nil {
+					mlog.Debugf("Failed to remove temp directory: %v", err)
+				}
+				return "", nil, fmt.Errorf("git checkout failed: %w", err)
+			}
+		} else {
+			if err := gfile.Remove(tempDir); err != nil {
+				mlog.Debugf("Failed to remove temp directory: %v", err)
+			}
+			return "", nil, fmt.Errorf("git checkout failed: %w", err)
+		}
+	}
+
+	// Return the path to the subdirectory
+	subDirPath := filepath.Join(cloneDir, info.SubPath)
+	if !gfile.Exists(subDirPath) {
+		if err := gfile.Remove(tempDir); err != nil {
+			mlog.Debugf("Failed to remove temp directory: %v", err)
+		}
+		return "", nil, fmt.Errorf("subdirectory not found: %s", info.SubPath)
+	}
+
+	mlog.Debugf("Subdirectory located at: %s", subDirPath)
+	return subDirPath, info, nil
+}
+
+// GetModuleNameFromGoMod reads module name from go.mod file
+func GetModuleNameFromGoMod(dir string) string {
+	goModPath := filepath.Join(dir, "go.mod")
+	if !gfile.Exists(goModPath) {
+		return ""
+	}
+
+	content := gfile.GetContents(goModPath)
+	lines := gstr.Split(content, "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if after, ok := strings.CutPrefix(line, "module "); ok {
+			return strings.TrimSpace(after)
+		}
+	}
+	return ""
+}
diff --git a/cmd/gf/internal/cmd/geninit/geninit_selector.go b/cmd/gf/internal/cmd/geninit/geninit_selector.go
new file mode 100644
index 000000000..61cec344b
--- /dev/null
+++ b/cmd/gf/internal/cmd/geninit/geninit_selector.go
@@ -0,0 +1,99 @@
+// Copyright GoFrame gf 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 geninit
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+)
+
+// SelectVersion prompts user to select a version interactively
+func SelectVersion(ctx context.Context, versions []string, modulePath string) (string, error) {
+	if len(versions) == 0 {
+		return "", fmt.Errorf("no versions available for selection")
+	}
+
+	if len(versions) == 1 {
+		mlog.Printf("Only one version available: %s", versions[0])
+		return versions[0], nil
+	}
+
+	// Display available versions
+	fmt.Printf("\nAvailable versions for %s:\n", modulePath)
+	fmt.Println(strings.Repeat("-", 40))
+
+	// Show versions with index (newest first)
+	maxDisplay := 20 // Limit display to avoid overwhelming output
+	displayCount := len(versions)
+	if displayCount > maxDisplay {
+		displayCount = maxDisplay
+	}
+
+	for i := 0; i < displayCount; i++ {
+		marker := ""
+		if i == 0 {
+			marker = " (latest)"
+		}
+		fmt.Printf("  [%2d] %s%s\n", i+1, versions[i], marker)
+	}
+
+	if len(versions) > maxDisplay {
+		fmt.Printf("  ... and %d more versions\n", len(versions)-maxDisplay)
+	}
+
+	fmt.Println(strings.Repeat("-", 40))
+
+	// Prompt for selection
+	reader := bufio.NewReader(os.Stdin)
+	for {
+		fmt.Printf("Select version [1-%d] or enter version string (default: 1 for latest): ", displayCount)
+
+		input, err := reader.ReadString('\n')
+		if err != nil {
+			return "", fmt.Errorf("failed to read input: %w", err)
+		}
+
+		input = strings.TrimSpace(input)
+
+		// Default to latest
+		if input == "" {
+			fmt.Printf("Selected: %s (latest)\n", versions[0])
+			return versions[0], nil
+		}
+
+		// Try parsing as number first
+		idx, err := strconv.Atoi(input)
+		if err == nil {
+			// Valid number - check if in range
+			if idx >= 1 && idx <= len(versions) {
+				// Allow selection from all versions, not just displayed ones
+				selected := versions[idx-1]
+				fmt.Printf("Selected: %s\n", selected)
+				return selected, nil
+			} else if idx < 1 || idx > displayCount {
+				fmt.Printf("Invalid selection. Please enter a number between 1 and %d, or type a version string.\n", displayCount)
+				continue
+			}
+		} else {
+			// Try matching the input as a version string (e.g., "v1.2.3")
+			for _, v := range versions {
+				if v == input || strings.Contains(v, input) {
+					fmt.Printf("Selected: %s\n", v)
+					return v, nil
+				}
+			}
+			fmt.Printf("Version '%s' not found. Please select by number or type a valid version string.\n", input)
+			continue
+		}
+	}
+}
diff --git a/cmd/gf/internal/cmd/geninit/geninit_version.go b/cmd/gf/internal/cmd/geninit/geninit_version.go
new file mode 100644
index 000000000..380cae227
--- /dev/null
+++ b/cmd/gf/internal/cmd/geninit/geninit_version.go
@@ -0,0 +1,138 @@
+// Copyright GoFrame gf 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 geninit
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"sort"
+	"strings"
+
+	"golang.org/x/mod/semver"
+
+	"github.com/gogf/gf/v2/os/gfile"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+)
+
+// VersionInfo contains module version information
+type VersionInfo struct {
+	Module   string   `json:"module"`
+	Versions []string `json:"versions"`
+	Latest   string   `json:"latest"`
+}
+
+// GetModuleVersions fetches available versions for a Go module
+func GetModuleVersions(ctx context.Context, modulePath string) (*VersionInfo, error) {
+	// Create a temporary directory for go list
+	tempDir := gfile.Temp("gf-init-version")
+	if tempDir == "" {
+		return nil, fmt.Errorf("failed to create temporary directory for go list")
+	}
+	if err := gfile.Mkdir(tempDir); err != nil {
+		return nil, err
+	}
+	defer func() {
+		if err := gfile.Remove(tempDir); err != nil {
+			mlog.Debugf("Failed to remove temp directory: %v", err)
+		}
+	}()
+
+	// Initialize a temp go module
+	if err := runCmd(ctx, tempDir, "go", "mod", "init", "temp"); err != nil {
+		return nil, fmt.Errorf("failed to init temp module: %w", err)
+	}
+
+	// Get versions using go list -m -versions
+	cmd := exec.CommandContext(ctx, "go", "list", "-m", "-versions", modulePath)
+	cmd.Dir = tempDir
+	output, err := cmd.Output()
+	if err != nil {
+		// Try with @latest to see if module exists
+		mlog.Debugf("go list -versions failed, trying @latest: %v", err)
+		return getLatestOnly(ctx, tempDir, modulePath)
+	}
+
+	// Parse output: "module/path v1.0.0 v1.1.0 v2.0.0"
+	parts := strings.Fields(strings.TrimSpace(string(output)))
+	if len(parts) < 1 {
+		return nil, fmt.Errorf("no version information found for %s", modulePath)
+	}
+
+	info := &VersionInfo{
+		Module:   parts[0],
+		Versions: []string{},
+	}
+
+	if len(parts) > 1 {
+		info.Versions = parts[1:]
+		// Sort versions in descending order (newest first)
+		sort.Slice(info.Versions, func(i, j int) bool {
+			return semver.Compare(info.Versions[i], info.Versions[j]) > 0
+		})
+		info.Latest = info.Versions[0]
+	}
+
+	// If no tagged versions, try to get latest
+	if len(info.Versions) == 0 {
+		latestInfo, err := getLatestOnly(ctx, tempDir, modulePath)
+		if err != nil {
+			return nil, err
+		}
+		info.Latest = latestInfo.Latest
+		if latestInfo.Latest != "" {
+			info.Versions = []string{latestInfo.Latest}
+		}
+	}
+
+	return info, nil
+}
+
+// getLatestOnly gets only the latest version when go list -versions fails
+func getLatestOnly(ctx context.Context, tempDir, modulePath string) (*VersionInfo, error) {
+	// Try go list -m modulePath@latest
+	cmd := exec.CommandContext(ctx, "go", "list", "-m", "-json", modulePath+"@latest")
+	cmd.Dir = tempDir
+	output, err := cmd.Output()
+	if err != nil {
+		// Try without @latest
+		cmd = exec.CommandContext(ctx, "go", "list", "-m", "-json", modulePath)
+		cmd.Dir = tempDir
+		output, err = cmd.Output()
+		if err != nil {
+			return nil, fmt.Errorf("failed to get module info for %s: %w", modulePath, err)
+		}
+	}
+
+	var modInfo struct {
+		Path    string `json:"Path"`
+		Version string `json:"Version"`
+	}
+	if err := json.Unmarshal(output, &modInfo); err != nil {
+		return nil, fmt.Errorf("failed to parse module info: %w", err)
+	}
+
+	return &VersionInfo{
+		Module:   modInfo.Path,
+		Versions: []string{modInfo.Version},
+		Latest:   modInfo.Version,
+	}, nil
+}
+
+// GetLatestVersion returns the latest version of a module
+func GetLatestVersion(ctx context.Context, modulePath string) (string, error) {
+	info, err := GetModuleVersions(ctx, modulePath)
+	if err != nil {
+		return "", err
+	}
+	if info.Latest == "" {
+		return "", fmt.Errorf("no version found for %s", modulePath)
+	}
+	return info.Latest, nil
+}
diff --git a/cmd/gf/internal/cmd/geninit/geninit_z_unit_test.go b/cmd/gf/internal/cmd/geninit/geninit_z_unit_test.go
new file mode 100644
index 000000000..6f05eddf0
--- /dev/null
+++ b/cmd/gf/internal/cmd/geninit/geninit_z_unit_test.go
@@ -0,0 +1,359 @@
+// Copyright GoFrame gf 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 geninit
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/guid"
+)
+
+func Test_ParseGitURL_Basic(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test basic github URL
+		info, err := ParseGitURL("github.com/gogf/gf")
+		t.AssertNil(err)
+		t.Assert(info.Host, "github.com")
+		t.Assert(info.Owner, "gogf")
+		t.Assert(info.Repo, "gf")
+		t.Assert(info.SubPath, "")
+		t.Assert(info.Branch, "main")
+		t.Assert(info.CloneURL, "https://github.com/gogf/gf.git")
+	})
+}
+
+func Test_ParseGitURL_WithHTTPS(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test URL with https prefix
+		info, err := ParseGitURL("https://github.com/gogf/gf")
+		t.AssertNil(err)
+		t.Assert(info.Host, "github.com")
+		t.Assert(info.Owner, "gogf")
+		t.Assert(info.Repo, "gf")
+	})
+}
+
+func Test_ParseGitURL_WithGitSuffix(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test URL with .git suffix
+		info, err := ParseGitURL("github.com/gogf/gf.git")
+		t.AssertNil(err)
+		t.Assert(info.Host, "github.com")
+		t.Assert(info.Owner, "gogf")
+		t.Assert(info.Repo, "gf")
+	})
+}
+
+func Test_ParseGitURL_WithSubPath(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test URL with subdirectory
+		info, err := ParseGitURL("github.com/gogf/examples/httpserver/jwt")
+		t.AssertNil(err)
+		t.Assert(info.Host, "github.com")
+		t.Assert(info.Owner, "gogf")
+		t.Assert(info.Repo, "examples")
+		t.Assert(info.SubPath, "httpserver/jwt")
+		t.Assert(info.CloneURL, "https://github.com/gogf/examples.git")
+	})
+}
+
+func Test_ParseGitURL_WithTreeBranch(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test GitHub web URL with /tree/branch/
+		info, err := ParseGitURL("github.com/gogf/examples/tree/develop/httpserver/jwt")
+		t.AssertNil(err)
+		t.Assert(info.Host, "github.com")
+		t.Assert(info.Owner, "gogf")
+		t.Assert(info.Repo, "examples")
+		t.Assert(info.Branch, "develop")
+		t.Assert(info.SubPath, "httpserver/jwt")
+	})
+}
+
+func Test_ParseGitURL_WithVersion(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test URL with version suffix
+		info, err := ParseGitURL("github.com/gogf/gf/cmd/gf/v2@v2.9.7")
+		t.AssertNil(err)
+		t.Assert(info.Host, "github.com")
+		t.Assert(info.Owner, "gogf")
+		t.Assert(info.Repo, "gf")
+		t.Assert(info.SubPath, "cmd/gf/v2")
+	})
+}
+
+func Test_ParseGitURL_Invalid(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test invalid URL (too short)
+		_, err := ParseGitURL("github.com/gogf")
+		t.AssertNE(err, nil)
+	})
+}
+
+func Test_IsSubdirRepo_NotSubdir(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Standard Go module paths should not be detected as subdirectory
+		t.Assert(IsSubdirRepo("github.com/gogf/gf"), false)
+		t.Assert(IsSubdirRepo("github.com/gogf/gf/v2"), false)
+	})
+}
+
+func Test_IsSubdirRepo_GoModuleWithCmd(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Go module paths with common patterns should not be detected as subdirectory
+		t.Assert(IsSubdirRepo("github.com/gogf/gf/cmd/gf/v2"), false)
+		t.Assert(IsSubdirRepo("github.com/gogf/gf/contrib/drivers/mysql/v2"), false)
+	})
+}
+
+func Test_IsSubdirRepo_ActualSubdir(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Actual subdirectories should be detected
+		t.Assert(IsSubdirRepo("github.com/gogf/examples/httpserver/jwt"), true)
+		t.Assert(IsSubdirRepo("github.com/gogf/examples/grpc/basic"), true)
+	})
+}
+
+func Test_GetModuleNameFromGoMod_Valid(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create temp directory with go.mod
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Write go.mod file
+		goModContent := `module github.com/test/myproject
+
+go 1.21
+
+require (
+	github.com/gogf/gf/v2 v2.9.0
+)
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "go.mod"), goModContent)
+		t.AssertNil(err)
+
+		// Test extraction
+		moduleName := GetModuleNameFromGoMod(tempDir)
+		t.Assert(moduleName, "github.com/test/myproject")
+	})
+}
+
+func Test_GetModuleNameFromGoMod_NoFile(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create temp directory without go.mod
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Test extraction - should return empty
+		moduleName := GetModuleNameFromGoMod(tempDir)
+		t.Assert(moduleName, "")
+	})
+}
+
+func Test_GetModuleNameFromGoMod_SimpleModule(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create temp directory with simple go.mod
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Write simple go.mod file
+		goModContent := `module main
+
+go 1.21
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "go.mod"), goModContent)
+		t.AssertNil(err)
+
+		// Test extraction
+		moduleName := GetModuleNameFromGoMod(tempDir)
+		t.Assert(moduleName, "main")
+	})
+}
+
+func Test_ASTReplacer_ReplaceInFile(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create temp directory
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Create a Go file with imports
+		goFileContent := `package main
+
+import (
+	"fmt"
+
+	"github.com/old/module/internal/service"
+	"github.com/old/module/pkg/utils"
+	"github.com/other/package"
+)
+
+func main() {
+	fmt.Println("Hello")
+}
+`
+		goFilePath := filepath.Join(tempDir, "main.go")
+		err = gfile.PutContents(goFilePath, goFileContent)
+		t.AssertNil(err)
+
+		// Replace imports
+		replacer := NewASTReplacer("github.com/old/module", "github.com/new/project")
+		err = replacer.ReplaceInFile(context.Background(), goFilePath)
+		t.AssertNil(err)
+
+		// Verify replacement
+		content := gfile.GetContents(goFilePath)
+		t.Assert(gfile.Exists(goFilePath), true)
+
+		// Check that old imports are replaced
+		t.AssertNE(content, "")
+		t.Assert(contains(content, `"github.com/new/project/internal/service"`), true)
+		t.Assert(contains(content, `"github.com/new/project/pkg/utils"`), true)
+
+		// Check that other imports are not affected
+		t.Assert(contains(content, `"github.com/other/package"`), true)
+		t.Assert(contains(content, `"fmt"`), true)
+	})
+}
+
+func Test_ASTReplacer_ReplaceInDir(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create temp directory structure
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Create subdirectory
+		subDir := filepath.Join(tempDir, "sub")
+		err = gfile.Mkdir(subDir)
+		t.AssertNil(err)
+
+		// Create main.go
+		mainContent := `package main
+
+import "github.com/old/module/sub"
+
+func main() {
+	sub.Hello()
+}
+`
+		err = gfile.PutContents(filepath.Join(tempDir, "main.go"), mainContent)
+		t.AssertNil(err)
+
+		// Create sub/sub.go
+		subContent := `package sub
+
+import "github.com/old/module/pkg"
+
+func Hello() {
+	pkg.Do()
+}
+`
+		err = gfile.PutContents(filepath.Join(subDir, "sub.go"), subContent)
+		t.AssertNil(err)
+
+		// Replace imports in directory
+		replacer := NewASTReplacer("github.com/old/module", "github.com/new/project")
+		err = replacer.ReplaceInDir(context.Background(), tempDir)
+		t.AssertNil(err)
+
+		// Verify main.go replacement
+		mainResult := gfile.GetContents(filepath.Join(tempDir, "main.go"))
+		t.Assert(contains(mainResult, `"github.com/new/project/sub"`), true)
+
+		// Verify sub/sub.go replacement
+		subResult := gfile.GetContents(filepath.Join(subDir, "sub.go"))
+		t.Assert(contains(subResult, `"github.com/new/project/pkg"`), true)
+	})
+}
+
+func Test_findGoFiles(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create temp directory structure
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Create subdirectories
+		subDir := filepath.Join(tempDir, "sub")
+		err = gfile.Mkdir(subDir)
+		t.AssertNil(err)
+
+		// Create various files
+		err = gfile.PutContents(filepath.Join(tempDir, "main.go"), "package main")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(tempDir, "readme.md"), "# README")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(subDir, "sub.go"), "package sub")
+		t.AssertNil(err)
+		err = gfile.PutContents(filepath.Join(subDir, "data.json"), "{}")
+		t.AssertNil(err)
+
+		// Find Go files
+		files, err := findGoFiles(tempDir)
+		t.AssertNil(err)
+
+		// Should find exactly 2 Go files
+		t.Assert(len(files), 2)
+
+		// Verify file names
+		hasMain := false
+		hasSub := false
+		for _, f := range files {
+			if filepath.Base(f) == "main.go" {
+				hasMain = true
+			}
+			if filepath.Base(f) == "sub.go" {
+				hasSub = true
+			}
+		}
+		t.Assert(hasMain, true)
+		t.Assert(hasSub, true)
+	})
+}
+
+func Test_findGoFiles_EmptyDir(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create empty temp directory
+		tempDir := gfile.Temp(guid.S())
+		err := gfile.Mkdir(tempDir)
+		t.AssertNil(err)
+		defer gfile.Remove(tempDir)
+
+		// Find Go files
+		files, err := findGoFiles(tempDir)
+		t.AssertNil(err)
+		t.Assert(len(files), 0)
+	})
+}
+
+// Helper function to check if string contains substring
+func contains(s, substr string) bool {
+	return len(s) >= len(substr) && (s == substr || len(s) > 0 && containsAt(s, substr))
+}
+
+func containsAt(s, substr string) bool {
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return true
+		}
+	}
+	return false
+}
diff --git a/cmd/gf/internal/cmd/genservice/genservice_calculate.go b/cmd/gf/internal/cmd/genservice/genservice_calculate.go
index 268585cb4..8a35318d7 100644
--- a/cmd/gf/internal/cmd/genservice/genservice_calculate.go
+++ b/cmd/gf/internal/cmd/genservice/genservice_calculate.go
@@ -12,7 +12,6 @@ import (
 
 	"github.com/gogf/gf/v2/container/garray"
 	"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"
 
@@ -37,21 +36,14 @@ func (c CGenService) calculateImportedItems(
 	}
 
 	for _, item := range pkgItems {
-		alias := item.Alias
-
-		// If the alias is _, it means that the package is not generated.
-		if alias == "_" {
+		// Skip anonymous imports
+		if item.Alias == "_" {
 			mlog.Debugf(`ignore anonymous package: %s`, item.RawImport)
 			continue
 		}
-		// If the alias is empty, it will use the package name as the alias.
-		if alias == "" {
-			alias = gfile.Basename(gstr.Trim(item.Path, `"`))
-		}
-		if !gstr.Contains(allFuncParamType.String(), alias) {
-			mlog.Debugf(`ignore unused package: %s`, item.RawImport)
-			continue
-		}
+		// Keep all imports, let gofmt clean up unused ones.
+		// We cannot accurately infer package name from import path
+		// (e.g., path "minio-go" but package name is "minio").
 		srcImportedPackages.Add(item.RawImport)
 	}
 	return nil
diff --git a/cmd/gf/internal/cmd/testdata/build/varmap/go.mod b/cmd/gf/internal/cmd/testdata/build/varmap/go.mod
index a2a4d9e0a..e73a529d0 100644
--- a/cmd/gf/internal/cmd/testdata/build/varmap/go.mod
+++ b/cmd/gf/internal/cmd/testdata/build/varmap/go.mod
@@ -4,11 +4,11 @@ go 1.23.0
 
 toolchain go1.24.6
 
-require github.com/gogf/gf/v2 v2.9.3
+require github.com/gogf/gf/v2 v2.9.8
 
 require (
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
 	golang.org/x/text v0.28.0 // indirect
 )
 
diff --git a/cmd/gf/internal/cmd/testdata/build/varmap/go.sum b/cmd/gf/internal/cmd/testdata/build/varmap/go.sum
index 7c5ad1392..949b5632f 100644
--- a/cmd/gf/internal/cmd/testdata/build/varmap/go.sum
+++ b/cmd/gf/internal/cmd/testdata/build/varmap/go.sum
@@ -4,8 +4,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -24,8 +24,8 @@ github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtg
 github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -34,26 +34,26 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
diff --git a/cmd/gf/internal/cmd/testdata/fix/fix25_content.go b/cmd/gf/internal/cmd/testdata/fix/fix25_content.go
index 934ebd2a8..9b5552458 100644
--- a/cmd/gf/internal/cmd/testdata/fix/fix25_content.go
+++ b/cmd/gf/internal/cmd/testdata/fix/fix25_content.go
@@ -1,13 +1,10 @@
 package testdata
 
 import (
-	"fmt"
 	"testing"
-	"time"
 
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/net/ghttp"
-	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/guid"
 )
 
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/api/article/article_expect.go b/cmd/gf/internal/cmd/testdata/genctrl/default/api/article/article_expect.go
similarity index 82%
rename from cmd/gf/internal/cmd/testdata/genctrl/api/article/article_expect.go
rename to cmd/gf/internal/cmd/testdata/genctrl/default/api/article/article_expect.go
index 3fd161752..ea193c77d 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl/api/article/article_expect.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/default/api/article/article_expect.go
@@ -7,8 +7,8 @@ package article
 import (
 	"context"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v1"
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v2"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v2"
 )
 
 type IArticleV1 interface {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/api/article/v1/edit.go b/cmd/gf/internal/cmd/testdata/genctrl/default/api/article/v1/edit.go
similarity index 100%
rename from cmd/gf/internal/cmd/testdata/genctrl/api/article/v1/edit.go
rename to cmd/gf/internal/cmd/testdata/genctrl/default/api/article/v1/edit.go
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/api/article/v1/get.go b/cmd/gf/internal/cmd/testdata/genctrl/default/api/article/v1/get.go
similarity index 100%
rename from cmd/gf/internal/cmd/testdata/genctrl/api/article/v1/get.go
rename to cmd/gf/internal/cmd/testdata/genctrl/default/api/article/v1/get.go
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/api/article/v2/edit.go b/cmd/gf/internal/cmd/testdata/genctrl/default/api/article/v2/edit.go
similarity index 100%
rename from cmd/gf/internal/cmd/testdata/genctrl/api/article/v2/edit.go
rename to cmd/gf/internal/cmd/testdata/genctrl/default/api/article/v2/edit.go
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article.go b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article.go
similarity index 100%
rename from cmd/gf/internal/cmd/testdata/genctrl/controller/article/article.go
rename to cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article.go
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_new.go b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_new.go
similarity index 84%
rename from cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_new.go
rename to cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_new.go
index d6b85c986..19355350b 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_new.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_new.go
@@ -5,7 +5,7 @@
 package article
 
 import (
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article"
 )
 
 type ControllerV1 struct{}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v1_create.go b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_create.go
similarity index 77%
rename from cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v1_create.go
rename to cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_create.go
index f5e39b5af..1feb329c8 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v1_create.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_create.go
@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v1"
 )
 
 // Create add title.
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v1_get_list.go b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_get_list.go
similarity index 76%
rename from cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v1_get_list.go
rename to cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_get_list.go
index 9f9b3cd88..650177a58 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v1_get_list.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_get_list.go
@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v1"
 )
 
 func (c *ControllerV1) GetList(ctx context.Context, req *v1.GetListReq) (res *v1.GetListRes, err error) {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v1_get_one.go b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_get_one.go
similarity index 76%
rename from cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v1_get_one.go
rename to cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_get_one.go
index 8b20a1dba..62aece2ee 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v1_get_one.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_get_one.go
@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v1"
 )
 
 func (c *ControllerV1) GetOne(ctx context.Context, req *v1.GetOneReq) (res *v1.GetOneRes, err error) {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v1_update.go b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_update.go
similarity index 76%
rename from cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v1_update.go
rename to cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_update.go
index d01e8b865..4d4e4feb7 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v1_update.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v1_update.go
@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v1"
 )
 
 func (c *ControllerV1) Update(ctx context.Context, req *v1.UpdateReq) (res *v1.UpdateRes, err error) {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v2_create.go b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v2_create.go
similarity index 76%
rename from cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v2_create.go
rename to cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v2_create.go
index 319407967..4ea4185b1 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v2_create.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v2_create.go
@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v2"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v2"
 )
 
 func (c *ControllerV2) Create(ctx context.Context, req *v2.CreateReq) (res *v2.CreateRes, err error) {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v2_update.go b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v2_update.go
similarity index 76%
rename from cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v2_update.go
rename to cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v2_update.go
index 25a9d03ab..4d47fc8ef 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl/controller/article/article_v2_update.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/default/controller/article/article_v2_update.go
@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/api/article/v2"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/default/api/article/v2"
 )
 
 func (c *ControllerV2) Update(ctx context.Context, req *v2.UpdateReq) (res *v2.UpdateRes, err error) {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/dict_add_new_ctrl_expect.gotest b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/dict_add_new_ctrl_expect.gotest
similarity index 89%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/dict_add_new_ctrl_expect.gotest
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/dict_add_new_ctrl_expect.gotest
index f6a0a55f7..0588aa284 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/dict_add_new_ctrl_expect.gotest
+++ b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/dict_add_new_ctrl_expect.gotest
@@ -7,7 +7,7 @@ package dict
 import (
 	"context"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/v1"
 )
 
 type IDictV1 interface {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/dict_expect.go b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/dict_expect.go
similarity index 87%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/dict_expect.go
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/dict_expect.go
index 8c69b527c..41036e9ae 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/dict_expect.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/dict_expect.go
@@ -7,7 +7,7 @@ package dict
 import (
 	"context"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/v1"
 )
 
 type IDictV1 interface {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/v1/dict_type.go b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/v1/dict_type.go
similarity index 100%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/v1/dict_type.go
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/v1/dict_type.go
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/controller/dict/dict.go b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict.go
similarity index 100%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/controller/dict/dict.go
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict.go
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/controller/dict/dict_new.go b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict_new.go
similarity index 85%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/controller/dict/dict_new.go
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict_new.go
index cf966e0f2..38e2ab2d5 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/controller/dict/dict_new.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict_new.go
@@ -5,7 +5,7 @@
 package dict
 
 import (
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict"
 )
 
 type ControllerV1 struct{}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/controller/dict/dict_v1_dict_type.go b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict_v1_dict_type.go
similarity index 83%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/controller/dict/dict_v1_dict_type.go
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict_v1_dict_type.go
index 56b407945..6675ef860 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/controller/dict/dict_v1_dict_type.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict_v1_dict_type.go
@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/v1"
 )
 
 func (c *ControllerV1) DictTypeAddPage(ctx context.Context, req *v1.DictTypeAddPageReq) (res *v1.DictTypeAddPageRes, err error) {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/controller/dict/dict_v1_test_new.gotest b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict_v1_test_new.gotest
similarity index 88%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/controller/dict/dict_v1_test_new.gotest
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict_v1_test_new.gotest
index 12c2fad89..5f741b281 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/controller/dict/dict_v1_test_new.gotest
+++ b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_ctrl/controller/dict/dict_v1_test_new.gotest
@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/v1"
 )
 
 func (c *ControllerV1) DictTypeAddPage(ctx context.Context, req *v1.DictTypeAddPageReq) (res *v1.DictTypeAddPageRes, err error) {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/dict_add_new_ctrl_expect.gotest b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/dict_add_new_ctrl_expect.gotest
similarity index 89%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/dict_add_new_ctrl_expect.gotest
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/dict_add_new_ctrl_expect.gotest
index f6a0a55f7..0588aa284 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/dict_add_new_ctrl_expect.gotest
+++ b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/dict_add_new_ctrl_expect.gotest
@@ -7,7 +7,7 @@ package dict
 import (
 	"context"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_ctrl/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_ctrl/api/dict/v1"
 )
 
 type IDictV1 interface {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/dict_expect.go b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/dict_expect.go
similarity index 87%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/dict_expect.go
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/dict_expect.go
index c41eb0571..8fd91c940 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/dict_expect.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/dict_expect.go
@@ -7,7 +7,7 @@ package dict
 import (
 	"context"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/v1"
 )
 
 type IDictV1 interface {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/v1/dict_type.go b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/v1/dict_type.go
similarity index 100%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/v1/dict_type.go
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/v1/dict_type.go
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/controller/dict/dict.go b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict.go
similarity index 100%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/controller/dict/dict.go
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict.go
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/controller/dict/dict_new.go b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict_new.go
similarity index 85%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/controller/dict/dict_new.go
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict_new.go
index 8cf1e87fc..afb9ecb7c 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/controller/dict/dict_new.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict_new.go
@@ -5,7 +5,7 @@
 package dict
 
 import (
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict"
 )
 
 type ControllerV1 struct{}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/controller/dict/dict_v1_dict_type.go b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict_v1_dict_type.go
similarity index 83%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/controller/dict/dict_v1_dict_type.go
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict_v1_dict_type.go
index 507d8e4be..1d0d41913 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/controller/dict/dict_v1_dict_type.go
+++ b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict_v1_dict_type.go
@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/v1"
 )
 
 func (c *ControllerV1) DictTypeAddPage(ctx context.Context, req *v1.DictTypeAddPageReq) (res *v1.DictTypeAddPageRes, err error) {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/controller/dict/dict_v1_test_new.gotest b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict_v1_test_new.gotest
similarity index 83%
rename from cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/controller/dict/dict_v1_test_new.gotest
rename to cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict_v1_test_new.gotest
index 13cac3c7c..7ceead760 100644
--- a/cmd/gf/internal/cmd/testdata/genctrl-merge/add_new_file/controller/dict/dict_v1_test_new.gotest
+++ b/cmd/gf/internal/cmd/testdata/genctrl/merge/add_new_file/controller/dict/dict_v1_test_new.gotest
@@ -6,7 +6,7 @@ import (
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl-merge/add_new_file/api/dict/v1"
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/merge/add_new_file/api/dict/v1"
 )
 
 func (c *ControllerV1) DictTypeAdd(ctx context.Context, req *v1.DictTypeAddReq) (res *v1.DictTypeAddRes, err error) {
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/article/article_expect.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/article/article_expect.go
new file mode 100644
index 000000000..be3f52f9f
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/article/article_expect.go
@@ -0,0 +1,15 @@
+// =================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// =================================================================================
+
+package article
+
+import (
+	"context"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/admin/article/v1"
+)
+
+type IArticleV1 interface {
+	Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error)
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/article/v1/edit.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/article/v1/edit.go
new file mode 100644
index 000000000..d8171bee8
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/article/v1/edit.go
@@ -0,0 +1,19 @@
+// 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 v1
+
+import "github.com/gogf/gf/v2/frame/g"
+
+type (
+	// CreateReq add title.
+	CreateReq struct {
+		g.Meta `path:"/article/create" method:"post" tags:"ArticleService"`
+		Title  string `v:"required"`
+	}
+
+	CreateRes struct{}
+)
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/user/user_expect.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/user/user_expect.go
new file mode 100644
index 000000000..d51d3abba
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/user/user_expect.go
@@ -0,0 +1,15 @@
+// =================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// =================================================================================
+
+package user
+
+import (
+	"context"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/admin/user/v1"
+)
+
+type IUserV1 interface {
+	Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error)
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/user/v1/edit.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/user/v1/edit.go
new file mode 100644
index 000000000..d8171bee8
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/admin/user/v1/edit.go
@@ -0,0 +1,19 @@
+// 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 v1
+
+import "github.com/gogf/gf/v2/frame/g"
+
+type (
+	// CreateReq add title.
+	CreateReq struct {
+		g.Meta `path:"/article/create" method:"post" tags:"ArticleService"`
+		Title  string `v:"required"`
+	}
+
+	CreateRes struct{}
+)
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/user_expect.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/user_expect.go
new file mode 100644
index 000000000..094fbf261
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/user_expect.go
@@ -0,0 +1,16 @@
+// =================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// =================================================================================
+
+package user
+
+import (
+	"context"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/v1"
+)
+
+type IUserV1 interface {
+	Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error)
+	Update(ctx context.Context, req *v1.UpdateReq) (res *v1.UpdateRes, err error)
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/user_ext_expect.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/user_ext_expect.go
new file mode 100644
index 000000000..652c4c93b
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/user_ext_expect.go
@@ -0,0 +1,16 @@
+// =================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// =================================================================================
+
+package user_ext
+
+import (
+	"context"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/v1"
+)
+
+type IUserExtV1 interface {
+	Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error)
+	Update(ctx context.Context, req *v1.UpdateReq) (res *v1.UpdateRes, err error)
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/v1/edit.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/v1/edit.go
new file mode 100644
index 000000000..195ceda0f
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/v1/edit.go
@@ -0,0 +1,28 @@
+// 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 v1
+
+import "github.com/gogf/gf/v2/frame/g"
+
+type (
+	// CreateReq add title.
+	CreateReq struct {
+		g.Meta `path:"/article/create" method:"post" tags:"ArticleService"`
+		Title  string `v:"required"`
+	}
+
+	CreateRes struct{}
+)
+
+type (
+	UpdateReq struct {
+		g.Meta `path:"/article/update" method:"post" tags:"ArticleService"`
+		Title  string `v:"required"`
+	}
+
+	UpdateRes struct{}
+)
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/v1/edit.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/v1/edit.go
new file mode 100644
index 000000000..195ceda0f
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/api/app/user/v1/edit.go
@@ -0,0 +1,28 @@
+// 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 v1
+
+import "github.com/gogf/gf/v2/frame/g"
+
+type (
+	// CreateReq add title.
+	CreateReq struct {
+		g.Meta `path:"/article/create" method:"post" tags:"ArticleService"`
+		Title  string `v:"required"`
+	}
+
+	CreateRes struct{}
+)
+
+type (
+	UpdateReq struct {
+		g.Meta `path:"/article/update" method:"post" tags:"ArticleService"`
+		Title  string `v:"required"`
+	}
+
+	UpdateRes struct{}
+)
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/article/article.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/article/article.go
new file mode 100644
index 000000000..4bd478c5d
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/article/article.go
@@ -0,0 +1,5 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package article
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/article/article_new.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/article/article_new.go
new file mode 100644
index 000000000..d50928fc7
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/article/article_new.go
@@ -0,0 +1,15 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package article
+
+import (
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/admin/article"
+)
+
+type ControllerV1 struct{}
+
+func NewV1() article.IArticleV1 {
+	return &ControllerV1{}
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/article/article_v1_create.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/article/article_v1_create.go
new file mode 100644
index 000000000..c54f57119
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/article/article_v1_create.go
@@ -0,0 +1,15 @@
+package article
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/admin/article/v1"
+)
+
+// Create add title.
+func (c *ControllerV1) Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error) {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/user/user.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/user/user.go
new file mode 100644
index 000000000..8220c1afe
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/user/user.go
@@ -0,0 +1,5 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package user
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/user/user_new.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/user/user_new.go
new file mode 100644
index 000000000..df3736d3b
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/user/user_new.go
@@ -0,0 +1,15 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package user
+
+import (
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/admin/user"
+)
+
+type ControllerV1 struct{}
+
+func NewV1() user.IUserV1 {
+	return &ControllerV1{}
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/user/user_v1_create.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/user/user_v1_create.go
new file mode 100644
index 000000000..3d2f0cc3c
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/admin/user/user_v1_create.go
@@ -0,0 +1,15 @@
+package user
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/admin/user/v1"
+)
+
+// Create add title.
+func (c *ControllerV1) Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error) {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user.go
new file mode 100644
index 000000000..8220c1afe
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user.go
@@ -0,0 +1,5 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package user
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext.go
new file mode 100644
index 000000000..6c073a867
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext.go
@@ -0,0 +1,5 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package user_ext
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext_new.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext_new.go
new file mode 100644
index 000000000..cdad023ba
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext_new.go
@@ -0,0 +1,15 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package user_ext
+
+import (
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext"
+)
+
+type ControllerV1 struct{}
+
+func NewV1() user_ext.IUserExtV1 {
+	return &ControllerV1{}
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext_v1_create.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext_v1_create.go
new file mode 100644
index 000000000..37047ef9e
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext_v1_create.go
@@ -0,0 +1,15 @@
+package user_ext
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/v1"
+)
+
+// Create add title.
+func (c *ControllerV1) Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error) {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext_v1_update.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext_v1_update.go
new file mode 100644
index 000000000..9f8e4a8f2
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_ext/user_ext_v1_update.go
@@ -0,0 +1,14 @@
+package user_ext
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/user_ext/v1"
+)
+
+func (c *ControllerV1) Update(ctx context.Context, req *v1.UpdateReq) (res *v1.UpdateRes, err error) {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_new.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_new.go
new file mode 100644
index 000000000..bc64f4ec4
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_new.go
@@ -0,0 +1,15 @@
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package user
+
+import (
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user"
+)
+
+type ControllerV1 struct{}
+
+func NewV1() user.IUserV1 {
+	return &ControllerV1{}
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_v1_create.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_v1_create.go
new file mode 100644
index 000000000..69b6e82d7
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_v1_create.go
@@ -0,0 +1,15 @@
+package user
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/v1"
+)
+
+// Create add title.
+func (c *ControllerV1) Create(ctx context.Context, req *v1.CreateReq) (res *v1.CreateRes, err error) {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}
diff --git a/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_v1_update.go b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_v1_update.go
new file mode 100644
index 000000000..747a7a73c
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genctrl/multi/controller/app/user/user_v1_update.go
@@ -0,0 +1,14 @@
+package user
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/genctrl/multi/api/app/user/v1"
+)
+
+func (c *ControllerV1) Update(ctx context.Context, req *v1.UpdateReq) (res *v1.UpdateRes, err error) {
+	return nil, gerror.NewCode(gcode.CodeNotImplemented)
+}
diff --git a/cmd/gf/internal/cmd/testdata/gendao/sharding/sharding_overlapping.sql b/cmd/gf/internal/cmd/testdata/gendao/sharding/sharding_overlapping.sql
new file mode 100644
index 000000000..6e6a8e928
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/gendao/sharding/sharding_overlapping.sql
@@ -0,0 +1,47 @@
+-- Test case for issue #4603: overlapping sharding patterns
+-- https://github.com/gogf/gf/issues/4603
+--
+-- Patterns: "a_?", "a_b_?", "a_c_?"
+-- Expected: a_1/a_2 -> "a", a_b_1/a_b_2 -> "a_b", a_c_1/a_c_2 -> "a_c"
+
+CREATE TABLE `a_1`
+(
+    `id`        int unsigned NOT NULL AUTO_INCREMENT,
+    `name`      varchar(45) NOT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `a_2`
+(
+    `id`        int unsigned NOT NULL AUTO_INCREMENT,
+    `name`      varchar(45) NOT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `a_b_1`
+(
+    `id`        int unsigned NOT NULL AUTO_INCREMENT,
+    `name`      varchar(45) NOT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `a_b_2`
+(
+    `id`        int unsigned NOT NULL AUTO_INCREMENT,
+    `name`      varchar(45) NOT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `a_c_1`
+(
+    `id`        int unsigned NOT NULL AUTO_INCREMENT,
+    `name`      varchar(45) NOT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `a_c_2`
+(
+    `id`        int unsigned NOT NULL AUTO_INCREMENT,
+    `name`      varchar(45) NOT NULL,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
diff --git a/cmd/gf/internal/cmd/testdata/gendao/tables_pattern.sql b/cmd/gf/internal/cmd/testdata/gendao/tables_pattern.sql
new file mode 100644
index 000000000..0d122de3a
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/gendao/tables_pattern.sql
@@ -0,0 +1,30 @@
+-- Test case for issue #4629: tables pattern matching
+-- https://github.com/gogf/gf/issues/4629
+-- Standard SQL syntax compatible with MySQL and PostgreSQL
+--
+-- Tables: trade_order, trade_item, user_info, user_log, config
+
+CREATE TABLE trade_order (
+    id   INTEGER PRIMARY KEY,
+    name VARCHAR(45) NOT NULL
+);
+
+CREATE TABLE trade_item (
+    id   INTEGER PRIMARY KEY,
+    name VARCHAR(45) NOT NULL
+);
+
+CREATE TABLE user_info (
+    id   INTEGER PRIMARY KEY,
+    name VARCHAR(45) NOT NULL
+);
+
+CREATE TABLE user_log (
+    id   INTEGER PRIMARY KEY,
+    name VARCHAR(45) NOT NULL
+);
+
+CREATE TABLE config (
+    id   INTEGER PRIMARY KEY,
+    name VARCHAR(45) NOT NULL
+);
diff --git a/cmd/gf/internal/cmd/testdata/genpb/multiple_tags.proto b/cmd/gf/internal/cmd/testdata/genpb/multiple_tags.proto
new file mode 100644
index 000000000..0f15b4217
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genpb/multiple_tags.proto
@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+package genpb;
+
+option go_package = "genpb/v1";
+
+message UserReq {
+  // v:required
+  // v:#Id > 0
+  int64 Id = 1;
+  // User name for login
+  string Name = 2;
+  // v:required
+  // v:email
+  string Email = 3; // User email address
+}
+
+message UserResp {
+  int64 Id = 1;
+  string Name = 2;
+  string Email = 3;
+}
diff --git a/cmd/gf/internal/cmd/testdata/genpb/nested_message.proto b/cmd/gf/internal/cmd/testdata/genpb/nested_message.proto
new file mode 100644
index 000000000..c7a832f5d
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/genpb/nested_message.proto
@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+package genpb;
+
+option go_package = "genpb/v1";
+
+message Order {
+  // v:required
+  int64 OrderId = 1;
+  // Order details
+  OrderDetail Detail = 2;
+}
+
+message OrderDetail {
+  // v:required
+  string ProductName = 1;
+  // v:min:1
+  int32 Quantity = 2;
+  // v:min:0.01
+  double Price = 3;
+}
diff --git a/cmd/gf/internal/cmd/testdata/issue/4242/logic/issue4242/issue4242.go b/cmd/gf/internal/cmd/testdata/issue/4242/logic/issue4242/issue4242.go
new file mode 100644
index 000000000..11174d08a
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/issue/4242/logic/issue4242/issue4242.go
@@ -0,0 +1,34 @@
+package issue4242
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/net/ghttp"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4242/service"
+
+	"github.com/gogf/gf/contrib/drivers/mysql/v2"
+)
+
+func init() {
+	service.RegisterIssue4242(New())
+}
+
+type sIssue4242 struct {
+}
+
+func New() *sIssue4242 {
+	return &sIssue4242{}
+}
+
+// GetDriver tests versioned import path is preserved.
+func (s *sIssue4242) GetDriver(ctx context.Context) (d mysql.Driver, err error) {
+	return mysql.Driver{}, nil
+}
+
+// GetRequest tests another versioned import.
+func (s *sIssue4242) GetRequest(ctx context.Context) (*ghttp.Request, error) {
+	g.Log().Info(ctx, "getting request")
+	return nil, nil
+}
diff --git a/cmd/gf/internal/cmd/testdata/issue/4242/logic/issue4242alias/issue4242alias.go b/cmd/gf/internal/cmd/testdata/issue/4242/logic/issue4242alias/issue4242alias.go
new file mode 100644
index 000000000..e1faa8e88
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/issue/4242/logic/issue4242alias/issue4242alias.go
@@ -0,0 +1,37 @@
+package issue4242alias
+
+import (
+	"context"
+
+	// Anonymous import (should be skipped)
+	_ "github.com/gogf/gf/v2/os/gres"
+
+	// Versioned import without alias
+	"github.com/gogf/gf/v2/net/ghttp"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4242/service"
+
+	// Explicit alias import
+	mysqlDriver "github.com/gogf/gf/contrib/drivers/mysql/v2"
+)
+
+func init() {
+	service.RegisterIssue4242Alias(New())
+}
+
+type sIssue4242Alias struct {
+}
+
+func New() *sIssue4242Alias {
+	return &sIssue4242Alias{}
+}
+
+// GetDriver tests explicit alias import.
+func (s *sIssue4242Alias) GetDriver(ctx context.Context) (d mysqlDriver.Driver, err error) {
+	return mysqlDriver.Driver{}, nil
+}
+
+// GetRequest tests versioned import.
+func (s *sIssue4242Alias) GetRequest(ctx context.Context) (*ghttp.Request, error) {
+	return nil, nil
+}
diff --git a/cmd/gf/internal/cmd/testdata/issue/4242/logic/logic.go b/cmd/gf/internal/cmd/testdata/issue/4242/logic/logic.go
new file mode 100644
index 000000000..e877cd4f9
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/issue/4242/logic/logic.go
@@ -0,0 +1,10 @@
+// ==========================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// ==========================================================================
+
+package logic
+
+import (
+	_ "github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4242/logic/issue4242"
+	_ "github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4242/logic/issue4242alias"
+)
diff --git a/cmd/gf/internal/cmd/testdata/issue/4242/service/issue_4242.go b/cmd/gf/internal/cmd/testdata/issue/4242/service/issue_4242.go
new file mode 100644
index 000000000..c1cb50fca
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/issue/4242/service/issue_4242.go
@@ -0,0 +1,37 @@
+// ================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// You can delete these comments if you wish manually maintain this interface file.
+// ================================================================================
+
+package service
+
+import (
+	"context"
+
+	"github.com/gogf/gf/contrib/drivers/mysql/v2"
+	"github.com/gogf/gf/v2/net/ghttp"
+)
+
+type (
+	IIssue4242 interface {
+		// GetDriver tests versioned import path is preserved.
+		GetDriver(ctx context.Context) (d mysql.Driver, err error)
+		// GetRequest tests another versioned import.
+		GetRequest(ctx context.Context) (*ghttp.Request, error)
+	}
+)
+
+var (
+	localIssue4242 IIssue4242
+)
+
+func Issue4242() IIssue4242 {
+	if localIssue4242 == nil {
+		panic("implement not found for interface IIssue4242, forgot register?")
+	}
+	return localIssue4242
+}
+
+func RegisterIssue4242(i IIssue4242) {
+	localIssue4242 = i
+}
diff --git a/cmd/gf/internal/cmd/testdata/issue/4242/service/issue_4242_alias.go b/cmd/gf/internal/cmd/testdata/issue/4242/service/issue_4242_alias.go
new file mode 100644
index 000000000..1b79023b0
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/issue/4242/service/issue_4242_alias.go
@@ -0,0 +1,37 @@
+// ================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// You can delete these comments if you wish manually maintain this interface file.
+// ================================================================================
+
+package service
+
+import (
+	"context"
+
+	mysqlDriver "github.com/gogf/gf/contrib/drivers/mysql/v2"
+	"github.com/gogf/gf/v2/net/ghttp"
+)
+
+type (
+	IIssue4242Alias interface {
+		// GetDriver tests explicit alias import.
+		GetDriver(ctx context.Context) (d mysqlDriver.Driver, err error)
+		// GetRequest tests versioned import.
+		GetRequest(ctx context.Context) (*ghttp.Request, error)
+	}
+)
+
+var (
+	localIssue4242Alias IIssue4242Alias
+)
+
+func Issue4242Alias() IIssue4242Alias {
+	if localIssue4242Alias == nil {
+		panic("implement not found for interface IIssue4242Alias, forgot register?")
+	}
+	return localIssue4242Alias
+}
+
+func RegisterIssue4242Alias(i IIssue4242Alias) {
+	localIssue4242Alias = i
+}
diff --git a/cmd/gf/internal/cmd/testdata/issue/4387/api/types.go b/cmd/gf/internal/cmd/testdata/issue/4387/api/types.go
new file mode 100644
index 000000000..9af24e033
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/issue/4387/api/types.go
@@ -0,0 +1,16 @@
+// Copyright GoFrame gf 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 api
+
+// Status is a sample enum type for testing.
+type Status int
+
+const (
+	StatusPending Status = iota
+	StatusActive
+	StatusDone
+)
diff --git a/cmd/gf/internal/cmd/testdata/issue/4387/go.mod b/cmd/gf/internal/cmd/testdata/issue/4387/go.mod
new file mode 100644
index 000000000..f2ecd4c8d
--- /dev/null
+++ b/cmd/gf/internal/cmd/testdata/issue/4387/go.mod
@@ -0,0 +1,3 @@
+module github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4387
+
+go 1.20
diff --git a/cmd/gf/internal/consts/consts_gen_dao_template_table.go b/cmd/gf/internal/consts/consts_gen_dao_template_table.go
new file mode 100644
index 000000000..a60c92d5d
--- /dev/null
+++ b/cmd/gf/internal/consts/consts_gen_dao_template_table.go
@@ -0,0 +1,35 @@
+// Copyright GoFrame gf 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 consts
+
+const TemplateGenTableContent = `
+// =================================================================================
+// This file is auto-generated by the GoFrame CLI tool. You may modify it as needed.
+// =================================================================================
+
+package {{.TplPackageName}}
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/database/gdb"
+)
+
+// {{.TplTableNameCamelCase}} defines the fields of table "{{.TplTableName}}" with their properties.
+// This map is used internally by GoFrame ORM to understand table structure.
+var {{.TplTableNameCamelCase}} = map[string]*gdb.TableField{
+{{.TplTableFields}}
+}
+
+// Set{{.TplTableNameCamelCase}}TableFields registers the table fields definition to the database instance.
+// db: database instance that implements gdb.DB interface.
+// schema: optional schema/namespace name, especially for databases that support schemas.
+func Set{{.TplTableNameCamelCase}}TableFields(ctx context.Context, db gdb.DB, schema ...string) error {
+	return db.GetCore().SetTableFields(ctx, "{{.TplTableName}}", {{.TplTableNameCamelCase}}, schema...)
+}
+
+`
diff --git a/container/garray/garray_func.go b/container/garray/garray_func.go
index 155cca0d8..4bf5fbba4 100644
--- a/container/garray/garray_func.go
+++ b/container/garray/garray_func.go
@@ -6,7 +6,10 @@
 
 package garray
 
-import "strings"
+import (
+	"sort"
+	"strings"
+)
 
 // defaultComparatorInt for int comparison.
 func defaultComparatorInt(a, b int) int {
@@ -24,6 +27,14 @@ func defaultComparatorStr(a, b string) int {
 	return strings.Compare(a, b)
 }
 
+// defaultSorter is a generic sorting function that sorts a slice of comparable types
+// using the provided comparator function.
+func defaultSorter[T comparable](values []T, comparator func(a T, b T) int) {
+	sort.Slice(values, func(i, j int) bool {
+		return comparator(values[i], values[j]) < 0
+	})
+}
+
 // quickSortInt is the quick-sorting algorithm implements for int.
 func quickSortInt(values []int, comparator func(a, b int) int) {
 	if len(values) <= 1 {
@@ -67,3 +78,51 @@ func quickSortStr(values []string, comparator func(a, b string) int) {
 	quickSortStr(values[:head], comparator)
 	quickSortStr(values[head+1:], comparator)
 }
+
+// tToAnySlice converts []T to []any
+func tToAnySlice[T any](values []T) []any {
+	if values == nil {
+		return nil
+	}
+	anyValues := make([]any, len(values), cap(values))
+	for k, v := range values {
+		anyValues[k] = v
+	}
+	return anyValues
+}
+
+// anyToTSlice is convert []any to []T
+func anyToTSlice[T any](values []any) []T {
+	if values == nil {
+		return nil
+	}
+	tValues := make([]T, len(values), cap(values))
+	for k, v := range values {
+		tValues[k], _ = v.(T)
+	}
+	return tValues
+}
+
+// tToAnySlices converts [][]T to [][]any
+func tToAnySlices[T any](values [][]T) [][]any {
+	if values == nil {
+		return nil
+	}
+	anyValues := make([][]any, len(values), cap(values))
+	for k, v := range values {
+		anyValues[k] = tToAnySlice(v)
+	}
+	return anyValues
+}
+
+// anyToTSlices converts [][]any to [][]T
+func anyToTSlices[T any](values [][]any) [][]T {
+	if values == nil {
+		return nil
+	}
+	tValues := make([][]T, len(values), cap(values))
+	for k, v := range values {
+		tValues[k] = anyToTSlice[T](v)
+	}
+	return tValues
+}
diff --git a/container/garray/garray_normal_any.go b/container/garray/garray_normal_any.go
index cc17dcb37..2c22125e1 100644
--- a/container/garray/garray_normal_any.go
+++ b/container/garray/garray_normal_any.go
@@ -7,28 +7,18 @@
 package garray
 
 import (
-	"bytes"
 	"fmt"
-	"math"
-	"sort"
+	"sync"
 
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/deepcopy"
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/grand"
 )
 
 // Array is a golang array with rich features.
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type Array struct {
-	mu    rwmutex.RWMutex
-	array []any
+	*TArray[any]
+	once sync.Once
 }
 
 // New creates and returns an empty array.
@@ -48,8 +38,7 @@ func NewArray(safe ...bool) *Array {
 // which is false in default.
 func NewArraySize(size int, cap int, safe ...bool) *Array {
 	return &Array{
-		mu:    rwmutex.Create(safe...),
-		array: make([]any, size, cap),
+		TArray: NewTArraySize[any](size, cap, safe...),
 	}
 }
 
@@ -85,8 +74,7 @@ func NewFromCopy(array []any, safe ...bool) *Array {
 // which is false in default.
 func NewArrayFrom(array []any, safe ...bool) *Array {
 	return &Array{
-		mu:    rwmutex.Create(safe...),
-		array: array,
+		TArray: NewTArrayFrom(array, safe...),
 	}
 }
 
@@ -96,265 +84,149 @@ func NewArrayFrom(array []any, safe ...bool) *Array {
 func NewArrayFromCopy(array []any, safe ...bool) *Array {
 	newArray := make([]any, len(array))
 	copy(newArray, array)
-	return &Array{
-		mu:    rwmutex.Create(safe...),
-		array: newArray,
-	}
+	return NewArrayFrom(newArray, safe...)
+}
+
+// lazyInit lazily initializes the array.
+func (a *Array) lazyInit() {
+	a.once.Do(func() {
+		if a.TArray == nil {
+			a.TArray = NewTArray[any](false)
+		}
+	})
 }
 
 // At returns the value by the specified index.
 // If the given `index` is out of range of the array, it returns `nil`.
 func (a *Array) At(index int) (value any) {
-	value, _ = a.Get(index)
-	return
+	a.lazyInit()
+	return a.TArray.At(index)
 }
 
 // Get returns the value by the specified index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *Array) Get(index int) (value any, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if index < 0 || index >= len(a.array) {
-		return nil, false
-	}
-	return a.array[index], true
+	a.lazyInit()
+	return a.TArray.Get(index)
 }
 
 // Set sets value to specified index.
 func (a *Array) Set(index int, value any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	a.array[index] = value
-	return nil
+	a.lazyInit()
+	return a.TArray.Set(index, value)
 }
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *Array) SetArray(array []any) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array = array
+	a.lazyInit()
+	a.TArray.SetArray(array)
 	return a
 }
 
 // Replace replaces the array items by given `array` from the beginning of array.
 func (a *Array) Replace(array []any) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	max := len(array)
-	if max > len(a.array) {
-		max = len(a.array)
-	}
-	for i := 0; i < max; i++ {
-		a.array[i] = array[i]
-	}
+	a.lazyInit()
+	a.TArray.Replace(array)
 	return a
 }
 
 // Sum returns the sum of values in an array.
 func (a *Array) Sum() (sum int) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		sum += gconv.Int(v)
-	}
-	return
+	a.lazyInit()
+	return a.TArray.Sum()
 }
 
 // SortFunc sorts the array by custom function `less`.
 func (a *Array) SortFunc(less func(v1, v2 any) bool) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	sort.Slice(a.array, func(i, j int) bool {
-		return less(a.array[i], a.array[j])
-	})
+	a.lazyInit()
+	a.TArray.SortFunc(less)
 	return a
 }
 
 // InsertBefore inserts the `values` to the front of `index`.
 func (a *Array) InsertBefore(index int, values ...any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	rear := append([]any{}, a.array[index:]...)
-	a.array = append(a.array[0:index], values...)
-	a.array = append(a.array, rear...)
-	return nil
+	a.lazyInit()
+	return a.TArray.InsertBefore(index, values...)
 }
 
 // InsertAfter inserts the `values` to the back of `index`.
 func (a *Array) InsertAfter(index int, values ...any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	rear := append([]any{}, a.array[index+1:]...)
-	a.array = append(a.array[0:index+1], values...)
-	a.array = append(a.array, rear...)
-	return nil
+	a.lazyInit()
+	return a.TArray.InsertAfter(index, values...)
 }
 
 // Remove removes an item by index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *Array) Remove(index int) (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(index)
-}
-
-// doRemoveWithoutLock removes an item by index without lock.
-func (a *Array) doRemoveWithoutLock(index int) (value any, found bool) {
-	if index < 0 || index >= len(a.array) {
-		return nil, false
-	}
-	// Determine array boundaries when deleting to improve deletion efficiency.
-	if index == 0 {
-		value := a.array[0]
-		a.array = a.array[1:]
-		return value, true
-	} else if index == len(a.array)-1 {
-		value := a.array[index]
-		a.array = a.array[:index]
-		return value, true
-	}
-	// If it is a non-boundary delete,
-	// it will involve the creation of an array,
-	// then the deletion is less efficient.
-	value = a.array[index]
-	a.array = append(a.array[:index], a.array[index+1:]...)
-	return value, true
+	a.lazyInit()
+	return a.TArray.Remove(index)
 }
 
 // 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 any) bool {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if i := a.doSearchWithoutLock(value); i != -1 {
-		a.doRemoveWithoutLock(i)
-		return true
-	}
-	return false
+	a.lazyInit()
+	return a.TArray.RemoveValue(value)
 }
 
 // RemoveValues removes multiple items by `values`.
 func (a *Array) RemoveValues(values ...any) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		if i := a.doSearchWithoutLock(value); i != -1 {
-			a.doRemoveWithoutLock(i)
-		}
-	}
+	a.lazyInit()
+	a.TArray.RemoveValues(values...)
 }
 
 // PushLeft pushes one or multiple items to the beginning of array.
 func (a *Array) PushLeft(value ...any) *Array {
-	a.mu.Lock()
-	a.array = append(value, a.array...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.PushLeft(value...)
 	return a
 }
 
 // PushRight pushes one or multiple items to the end of array.
 // It equals to Append.
 func (a *Array) PushRight(value ...any) *Array {
-	a.mu.Lock()
-	a.array = append(a.array, value...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.PushRight(value...)
 	return a
 }
 
 // PopRand randomly pops and return an item out of array.
 // Note that if the array is empty, the `found` is false.
 func (a *Array) PopRand() (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	a.lazyInit()
+	return a.TArray.PopRand()
 }
 
 // PopRands randomly pops and returns `size` items out of array.
 func (a *Array) PopRands(size int) []any {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		size = len(a.array)
-	}
-	array := make([]any, size)
-	for i := 0; i < size; i++ {
-		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.PopRands(size)
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 // Note that if the array is empty, the `found` is false.
 func (a *Array) PopLeft() (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return nil, false
-	}
-	value = a.array[0]
-	a.array = a.array[1:]
-	return value, true
+	a.lazyInit()
+	return a.TArray.PopLeft()
 }
 
 // PopRight pops and returns an item from the end of array.
 // Note that if the array is empty, the `found` is false.
 func (a *Array) PopRight() (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	index := len(a.array) - 1
-	if index < 0 {
-		return nil, false
-	}
-	value = a.array[index]
-	a.array = a.array[:index]
-	return value, true
+	a.lazyInit()
+	return a.TArray.PopRight()
 }
 
 // PopLefts pops and returns `size` items from the beginning of array.
 func (a *Array) PopLefts(size int) []any {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[0:size]
-	a.array = a.array[size:]
-	return value
+	a.lazyInit()
+	return a.TArray.PopLefts(size)
 }
 
 // PopRights pops and returns `size` items from the end of array.
 func (a *Array) PopRights(size int) []any {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	index := len(a.array) - size
-	if index <= 0 {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[index:]
-	a.array = a.array[:index]
-	return value
+	a.lazyInit()
+	return a.TArray.PopRights(size)
 }
 
 // Range picks and returns items by range, like array[start:end].
@@ -365,26 +237,8 @@ func (a *Array) PopRights(size int) []any {
 // If `end` is omitted, then the sequence will have everything from start up
 // until the end of the array.
 func (a *Array) Range(start int, end ...int) []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	offsetEnd := len(a.array)
-	if len(end) > 0 && end[0] < offsetEnd {
-		offsetEnd = end[0]
-	}
-	if start > offsetEnd {
-		return nil
-	}
-	if start < 0 {
-		start = 0
-	}
-	array := ([]any)(nil)
-	if a.mu.IsSafe() {
-		array = make([]any, offsetEnd-start)
-		copy(array, a.array[start:offsetEnd])
-	} else {
-		array = a.array[start:offsetEnd]
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Range(start, end...)
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -401,69 +255,29 @@ func (a *Array) Range(start int, end ...int) []any {
 //
 // Any possibility crossing the left border of array, it will fail.
 func (a *Array) SubSlice(offset int, length ...int) []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	size := len(a.array)
-	if len(length) > 0 {
-		size = length[0]
-	}
-	if offset > len(a.array) {
-		return nil
-	}
-	if offset < 0 {
-		offset = len(a.array) + offset
-		if offset < 0 {
-			return nil
-		}
-	}
-	if size < 0 {
-		offset += size
-		size = -size
-		if offset < 0 {
-			return nil
-		}
-	}
-	end := offset + size
-	if end > len(a.array) {
-		end = len(a.array)
-		size = len(a.array) - offset
-	}
-	if a.mu.IsSafe() {
-		s := make([]any, size)
-		copy(s, a.array[offset:])
-		return s
-	} else {
-		return a.array[offset:end]
-	}
+	a.lazyInit()
+	return a.TArray.SubSlice(offset, length...)
 }
 
 // Append is alias of PushRight, please See PushRight.
 func (a *Array) Append(value ...any) *Array {
-	a.PushRight(value...)
+	a.lazyInit()
+	a.TArray.Append(value...)
 	return a
 }
 
 // Len returns the length of array.
 func (a *Array) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
+	a.lazyInit()
+	return a.TArray.Len()
 }
 
 // Slice returns the underlying data of array.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (a *Array) Slice() []any {
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-		array := make([]any, len(a.array))
-		copy(array, a.array)
-		return array
-	} else {
-		return a.array
-	}
+	a.lazyInit()
+	return a.TArray.Slice()
 }
 
 // Interfaces returns current array as []any.
@@ -473,89 +287,49 @@ func (a *Array) Interfaces() []any {
 
 // Clone returns a new array, which is a copy of current array.
 func (a *Array) Clone() (newArray *Array) {
-	a.mu.RLock()
-	array := make([]any, len(a.array))
-	copy(array, a.array)
-	a.mu.RUnlock()
-	return NewArrayFrom(array, a.mu.IsSafe())
+	a.lazyInit()
+	return &Array{TArray: a.TArray.Clone()}
 }
 
 // Clear deletes all items of current array.
 func (a *Array) Clear() *Array {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		a.array = make([]any, 0)
-	}
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.Clear()
 	return a
 }
 
 // Contains checks whether a value exists in the array.
 func (a *Array) Contains(value any) bool {
-	return a.Search(value) != -1
+	a.lazyInit()
+	return a.TArray.Contains(value)
 }
 
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 func (a *Array) Search(value any) int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return a.doSearchWithoutLock(value)
-}
-
-func (a *Array) doSearchWithoutLock(value any) int {
-	if len(a.array) == 0 {
-		return -1
-	}
-	result := -1
-	for index, v := range a.array {
-		if v == value {
-			result = index
-			break
-		}
-	}
-	return result
+	a.lazyInit()
+	return a.TArray.Search(value)
 }
 
 // Unique uniques the array, clear repeated items.
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *Array) Unique() *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return a
-	}
-	var (
-		ok          bool
-		temp        any
-		uniqueSet   = make(map[any]struct{})
-		uniqueArray = make([]any, 0, len(a.array))
-	)
-	for i := 0; i < len(a.array); i++ {
-		temp = a.array[i]
-		if _, ok = uniqueSet[temp]; ok {
-			continue
-		}
-		uniqueSet[temp] = struct{}{}
-		uniqueArray = append(uniqueArray, temp)
-	}
-	a.array = uniqueArray
+	a.lazyInit()
+	a.TArray.Unique()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *Array) LockFunc(f func(array []any)) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	f(a.array)
+	a.lazyInit()
+	a.TArray.LockFunc(f)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *Array) RLockFunc(f func(array []any)) *Array {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	f(a.array)
+	a.lazyInit()
+	a.TArray.RLockFunc(f)
 	return a
 }
 
@@ -564,48 +338,23 @@ func (a *Array) RLockFunc(f func(array []any)) *Array {
 // The difference between Merge and Append is Append supports only specified slice type,
 // but Merge supports more parameter types.
 func (a *Array) Merge(array any) *Array {
+	a.lazyInit()
 	return a.Append(gconv.Interfaces(array)...)
 }
 
 // Fill fills an array with num entries of the value `value`,
 // keys starting at the `startIndex` parameter.
 func (a *Array) Fill(startIndex int, num int, value any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if startIndex < 0 || startIndex > len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", startIndex, len(a.array))
-	}
-	for i := startIndex; i < startIndex+num; i++ {
-		if i > len(a.array)-1 {
-			a.array = append(a.array, value)
-		} else {
-			a.array[i] = value
-		}
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.Fill(startIndex, num, value)
 }
 
 // Chunk splits an array into multiple arrays,
 // the size of each array is determined by `size`.
 // The last chunk may contain less than size elements.
 func (a *Array) Chunk(size int) [][]any {
-	if size < 1 {
-		return nil
-	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	length := len(a.array)
-	chunks := int(math.Ceil(float64(length) / float64(size)))
-	var n [][]any
-	for i, end := 0, 0; chunks > 0; chunks-- {
-		end = (i + 1) * size
-		if end > length {
-			end = length
-		}
-		n = append(n, a.array[i*size:end])
-		i++
-	}
-	return n
+	a.lazyInit()
+	return a.TArray.Chunk(size)
 }
 
 // Pad pads array to the specified length with `value`.
@@ -613,98 +362,47 @@ func (a *Array) Chunk(size int) [][]any {
 // If the absolute value of `size` is less than or equal to the length of the array
 // then no padding takes place.
 func (a *Array) Pad(size int, val any) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size == 0 || (size > 0 && size < len(a.array)) || (size < 0 && size > -len(a.array)) {
-		return a
-	}
-	n := size
-	if size < 0 {
-		n = -size
-	}
-	n -= len(a.array)
-	tmp := make([]any, n)
-	for i := 0; i < n; i++ {
-		tmp[i] = val
-	}
-	if size > 0 {
-		a.array = append(a.array, tmp...)
-	} else {
-		a.array = append(tmp, a.array...)
-	}
+	a.lazyInit()
+	a.TArray.Pad(size, val)
 	return a
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *Array) Rand() (value any, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return nil, false
-	}
-	return a.array[grand.Intn(len(a.array))], true
+	a.lazyInit()
+	return a.TArray.Rand()
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *Array) Rands(size int) []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	array := make([]any, size)
-	for i := 0; i < size; i++ {
-		array[i] = a.array[grand.Intn(len(a.array))]
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Rands(size)
 }
 
 // Shuffle randomly shuffles the array.
 func (a *Array) Shuffle() *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, v := range grand.Perm(len(a.array)) {
-		a.array[i], a.array[v] = a.array[v], a.array[i]
-	}
+	a.lazyInit()
+	a.TArray.Shuffle()
 	return a
 }
 
 // Reverse makes array with elements in reverse order.
 func (a *Array) Reverse() *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, j := 0, len(a.array)-1; i < j; i, j = i+1, j-1 {
-		a.array[i], a.array[j] = a.array[j], a.array[i]
-	}
+	a.lazyInit()
+	a.TArray.Reverse()
 	return a
 }
 
 // Join joins array elements with a string `glue`.
 func (a *Array) Join(glue string) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return ""
-	}
-	buffer := bytes.NewBuffer(nil)
-	for k, v := range a.array {
-		buffer.WriteString(gconv.String(v))
-		if k != len(a.array)-1 {
-			buffer.WriteString(glue)
-		}
-	}
-	return buffer.String()
+	a.lazyInit()
+	return a.TArray.Join(glue)
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *Array) CountValues() map[any]int {
-	m := make(map[any]int)
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		m[v]++
-	}
-	return m
+	a.lazyInit()
+	return a.TArray.CountValues()
 }
 
 // Iterator is alias of IteratorAsc.
@@ -715,25 +413,15 @@ func (a *Array) Iterator(f func(k int, v any) bool) {
 // IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *Array) IteratorAsc(f func(k int, v any) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for k, v := range a.array {
-		if !f(k, v) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.TArray.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the array readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *Array) IteratorDesc(f func(k int, v any) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for i := len(a.array) - 1; i >= 0; i-- {
-		if !f(i, a.array[i]) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.TArray.IteratorDesc(f)
 }
 
 // String returns current array as a string, which implements like json.Marshal does.
@@ -741,118 +429,64 @@ func (a *Array) String() string {
 	if a == nil {
 		return ""
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	buffer := bytes.NewBuffer(nil)
-	buffer.WriteByte('[')
-	s := ""
-	for k, v := range a.array {
-		s = gconv.String(v)
-		if gstr.IsNumeric(s) {
-			buffer.WriteString(s)
-		} else {
-			buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
-		}
-		if k != len(a.array)-1 {
-			buffer.WriteByte(',')
-		}
-	}
-	buffer.WriteByte(']')
-	return buffer.String()
+	a.lazyInit()
+	return a.TArray.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (a Array) MarshalJSON() ([]byte, error) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return json.Marshal(a.array)
+	a.lazyInit()
+	return a.TArray.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *Array) UnmarshalJSON(b []byte) error {
-	if a.array == nil {
-		a.array = make([]any, 0)
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
-		return err
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
 func (a *Array) UnmarshalValue(value any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	switch value.(type) {
-	case string, []byte:
-		return json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
-	default:
-		a.array = gconv.SliceAny(value)
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.UnmarshalValue(value)
 }
 
 // Filter iterates array and filters elements using custom callback function.
 // It removes the element from array if callback function `filter` returns true,
 // it or else does nothing and continues iterating.
 func (a *Array) Filter(filter func(index int, value any) 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++
-		}
-	}
+	a.lazyInit()
+	a.TArray.Filter(filter)
 	return a
 }
 
 // FilterNil removes all nil value of the array.
 func (a *Array) FilterNil() *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if empty.IsNil(a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.TArray.FilterNil()
 	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 *Array) FilterEmpty() *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if empty.IsEmpty(a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.TArray.FilterEmpty()
 	return a
 }
 
 // Walk applies a user supplied function `f` to every item of array.
 func (a *Array) Walk(f func(value any) any) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, v := range a.array {
-		a.array[i] = f(v)
-	}
+	a.lazyInit()
+	a.TArray.Walk(f)
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *Array) IsEmpty() bool {
-	return a.Len() == 0
+	a.lazyInit()
+	return a.TArray.IsEmpty()
 }
 
 // DeepCopy implements interface for deep copy of current type.
@@ -860,11 +494,8 @@ func (a *Array) DeepCopy() any {
 	if a == nil {
 		return nil
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	newSlice := make([]any, len(a.array))
-	for i, v := range a.array {
-		newSlice[i] = deepcopy.Copy(v)
+	a.lazyInit()
+	return &Array{
+		TArray: a.TArray.DeepCopy().(*TArray[any]),
 	}
-	return NewArrayFrom(newSlice, a.mu.IsSafe())
 }
diff --git a/container/garray/garray_normal_int.go b/container/garray/garray_normal_int.go
index 87526a9f2..aa7eca72a 100644
--- a/container/garray/garray_normal_int.go
+++ b/container/garray/garray_normal_int.go
@@ -7,25 +7,19 @@
 package garray
 
 import (
-	"bytes"
 	"fmt"
-	"math"
 	"sort"
+	"sync"
 
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/grand"
 )
 
 // IntArray is a golang int array with rich features.
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type IntArray struct {
-	mu    rwmutex.RWMutex
-	array []int
+	*TArray[int]
+	once sync.Once
 }
 
 // NewIntArray creates and returns an empty array.
@@ -40,8 +34,7 @@ func NewIntArray(safe ...bool) *IntArray {
 // which is false in default.
 func NewIntArraySize(size int, cap int, safe ...bool) *IntArray {
 	return &IntArray{
-		mu:    rwmutex.Create(safe...),
-		array: make([]int, size, cap),
+		TArray: NewTArraySize[int](size, cap, safe...),
 	}
 }
 
@@ -65,8 +58,7 @@ func NewIntArrayRange(start, end, step int, safe ...bool) *IntArray {
 // which is false in default.
 func NewIntArrayFrom(array []int, safe ...bool) *IntArray {
 	return &IntArray{
-		mu:    rwmutex.Create(safe...),
-		array: array,
+		TArray: NewTArrayFrom(array, safe...),
 	}
 }
 
@@ -76,78 +68,66 @@ func NewIntArrayFrom(array []int, safe ...bool) *IntArray {
 func NewIntArrayFromCopy(array []int, safe ...bool) *IntArray {
 	newArray := make([]int, len(array))
 	copy(newArray, array)
-	return &IntArray{
-		mu:    rwmutex.Create(safe...),
-		array: newArray,
-	}
+	return NewIntArrayFrom(newArray, safe...)
+}
+
+// lazyInit lazily initializes the array.
+func (a *IntArray) lazyInit() {
+	a.once.Do(func() {
+		if a.TArray == nil {
+			a.TArray = NewTArray[int](false)
+		}
+	})
 }
 
 // At returns the value by the specified index.
 // If the given `index` is out of range of the array, it returns `0`.
 func (a *IntArray) At(index int) (value int) {
-	value, _ = a.Get(index)
-	return
+	a.lazyInit()
+	return a.TArray.At(index)
 }
 
 // Get returns the value by the specified index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *IntArray) Get(index int) (value int, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if index < 0 || index >= len(a.array) {
-		return 0, false
-	}
-	return a.array[index], true
+	a.lazyInit()
+	return a.TArray.Get(index)
 }
 
 // Set sets value to specified index.
 func (a *IntArray) Set(index int, value int) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	a.array[index] = value
-	return nil
+	a.lazyInit()
+	return a.TArray.Set(index, value)
 }
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *IntArray) SetArray(array []int) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array = array
+	a.lazyInit()
+	a.TArray.SetArray(array)
 	return a
 }
 
 // Replace replaces the array items by given `array` from the beginning of array.
 func (a *IntArray) Replace(array []int) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	max := len(array)
-	if max > len(a.array) {
-		max = len(a.array)
-	}
-	for i := 0; i < max; i++ {
-		a.array[i] = array[i]
-	}
+	a.lazyInit()
+	a.TArray.Replace(array)
 	return a
 }
 
 // Sum returns the sum of values in an array.
 func (a *IntArray) Sum() (sum int) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		sum += v
-	}
-	return
+	a.lazyInit()
+	return a.TArray.Sum()
 }
 
 // Sort sorts the array in increasing order.
 // The parameter `reverse` controls whether sort in increasing order(default) or decreasing order.
 func (a *IntArray) Sort(reverse ...bool) *IntArray {
+	a.lazyInit()
+
 	a.mu.Lock()
 	defer a.mu.Unlock()
+
 	if len(reverse) > 0 && reverse[0] {
 		sort.Slice(a.array, func(i, j int) bool {
 			return a.array[i] >= a.array[j]
@@ -160,210 +140,101 @@ func (a *IntArray) Sort(reverse ...bool) *IntArray {
 
 // SortFunc sorts the array by custom function `less`.
 func (a *IntArray) SortFunc(less func(v1, v2 int) bool) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	sort.Slice(a.array, func(i, j int) bool {
-		return less(a.array[i], a.array[j])
-	})
+	a.lazyInit()
+	a.TArray.SortFunc(less)
 	return a
 }
 
 // InsertBefore inserts the `values` to the front of `index`.
 func (a *IntArray) InsertBefore(index int, values ...int) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			"index %d out of array range %d",
-			index, len(a.array),
-		)
-	}
-	rear := append([]int{}, a.array[index:]...)
-	a.array = append(a.array[0:index], values...)
-	a.array = append(a.array, rear...)
-	return nil
+	a.lazyInit()
+	return a.TArray.InsertBefore(index, values...)
 }
 
 // InsertAfter inserts the `value` to the back of `index`.
 func (a *IntArray) InsertAfter(index int, values ...int) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			"index %d out of array range %d",
-			index, len(a.array),
-		)
-	}
-	rear := append([]int{}, a.array[index+1:]...)
-	a.array = append(a.array[0:index+1], values...)
-	a.array = append(a.array, rear...)
-	return nil
+	a.lazyInit()
+	return a.TArray.InsertAfter(index, values...)
 }
 
 // Remove removes an item by index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *IntArray) Remove(index int) (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(index)
-}
-
-// doRemoveWithoutLock removes an item by index without lock.
-func (a *IntArray) doRemoveWithoutLock(index int) (value int, found bool) {
-	if index < 0 || index >= len(a.array) {
-		return 0, false
-	}
-	// Determine array boundaries when deleting to improve deletion efficiency.
-	if index == 0 {
-		value := a.array[0]
-		a.array = a.array[1:]
-		return value, true
-	} else if index == len(a.array)-1 {
-		value := a.array[index]
-		a.array = a.array[:index]
-		return value, true
-	}
-	// If it is a non-boundary delete,
-	// it will involve the creation of an array,
-	// then the deletion is less efficient.
-	value = a.array[index]
-	a.array = append(a.array[:index], a.array[index+1:]...)
-	return value, true
+	a.lazyInit()
+	return a.TArray.Remove(index)
 }
 
 // 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 {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if i := a.doSearchWithoutLock(value); i != -1 {
-		a.doRemoveWithoutLock(i)
-		return true
-	}
-	return false
+	a.lazyInit()
+	return a.TArray.RemoveValue(value)
 }
 
 // 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)
-		}
-	}
+	a.lazyInit()
+	a.TArray.RemoveValues(values...)
 }
 
 // PushLeft pushes one or multiple items to the beginning of array.
 func (a *IntArray) PushLeft(value ...int) *IntArray {
-	a.mu.Lock()
-	a.array = append(value, a.array...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.PushLeft(value...)
 	return a
 }
 
 // PushRight pushes one or multiple items to the end of array.
 // It equals to Append.
 func (a *IntArray) PushRight(value ...int) *IntArray {
-	a.mu.Lock()
-	a.array = append(a.array, value...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.PushRight(value...)
 	return a
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 // Note that if the array is empty, the `found` is false.
 func (a *IntArray) PopLeft() (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return 0, false
-	}
-	value = a.array[0]
-	a.array = a.array[1:]
-	return value, true
+	a.lazyInit()
+	return a.TArray.PopLeft()
 }
 
 // PopRight pops and returns an item from the end of array.
 // Note that if the array is empty, the `found` is false.
 func (a *IntArray) PopRight() (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	index := len(a.array) - 1
-	if index < 0 {
-		return 0, false
-	}
-	value = a.array[index]
-	a.array = a.array[:index]
-	return value, true
+	a.lazyInit()
+	return a.TArray.PopRight()
 }
 
 // PopRand randomly pops and return an item out of array.
 // Note that if the array is empty, the `found` is false.
 func (a *IntArray) PopRand() (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	a.lazyInit()
+	return a.TArray.PopRand()
 }
 
 // PopRands randomly pops and returns `size` items out of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *IntArray) PopRands(size int) []int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		size = len(a.array)
-	}
-	array := make([]int, size)
-	for i := 0; i < size; i++ {
-		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.PopRands(size)
 }
 
 // PopLefts pops and returns `size` items from the beginning of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *IntArray) PopLefts(size int) []int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[0:size]
-	a.array = a.array[size:]
-	return value
+	a.lazyInit()
+	return a.TArray.PopLefts(size)
 }
 
 // PopRights pops and returns `size` items from the end of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *IntArray) PopRights(size int) []int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	index := len(a.array) - size
-	if index <= 0 {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[index:]
-	a.array = a.array[:index]
-	return value
+	a.lazyInit()
+	return a.TArray.PopRights(size)
 }
 
 // Range picks and returns items by range, like array[start:end].
@@ -374,26 +245,8 @@ func (a *IntArray) PopRights(size int) []int {
 // If `end` is omitted, then the sequence will have everything from start up
 // until the end of the array.
 func (a *IntArray) Range(start int, end ...int) []int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	offsetEnd := len(a.array)
-	if len(end) > 0 && end[0] < offsetEnd {
-		offsetEnd = end[0]
-	}
-	if start > offsetEnd {
-		return nil
-	}
-	if start < 0 {
-		start = 0
-	}
-	array := ([]int)(nil)
-	if a.mu.IsSafe() {
-		array = make([]int, offsetEnd-start)
-		copy(array, a.array[start:offsetEnd])
-	} else {
-		array = a.array[start:offsetEnd]
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Range(start, end...)
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -410,170 +263,84 @@ func (a *IntArray) Range(start int, end ...int) []int {
 //
 // Any possibility crossing the left border of array, it will fail.
 func (a *IntArray) SubSlice(offset int, length ...int) []int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	size := len(a.array)
-	if len(length) > 0 {
-		size = length[0]
-	}
-	if offset > len(a.array) {
-		return nil
-	}
-	if offset < 0 {
-		offset = len(a.array) + offset
-		if offset < 0 {
-			return nil
-		}
-	}
-	if size < 0 {
-		offset += size
-		size = -size
-		if offset < 0 {
-			return nil
-		}
-	}
-	end := offset + size
-	if end > len(a.array) {
-		end = len(a.array)
-		size = len(a.array) - offset
-	}
-	if a.mu.IsSafe() {
-		s := make([]int, size)
-		copy(s, a.array[offset:])
-		return s
-	} else {
-		return a.array[offset:end]
-	}
+	a.lazyInit()
+	return a.TArray.SubSlice(offset, length...)
 }
 
 // Append is alias of PushRight,please See PushRight.
 func (a *IntArray) Append(value ...int) *IntArray {
-	a.mu.Lock()
-	a.array = append(a.array, value...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.Append(value...)
 	return a
 }
 
 // Len returns the length of array.
 func (a *IntArray) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
+	a.lazyInit()
+	return a.TArray.Len()
 }
 
 // Slice returns the underlying data of array.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (a *IntArray) Slice() []int {
-	array := ([]int)(nil)
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-		array = make([]int, len(a.array))
-		copy(array, a.array)
-	} else {
-		array = a.array
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Slice()
 }
 
 // Interfaces returns current array as []any.
 func (a *IntArray) Interfaces() []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	array := make([]any, len(a.array))
-	for k, v := range a.array {
-		array[k] = v
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Interfaces()
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *IntArray) Clone() (newArray *IntArray) {
-	a.mu.RLock()
-	array := make([]int, len(a.array))
-	copy(array, a.array)
-	a.mu.RUnlock()
-	return NewIntArrayFrom(array, a.mu.IsSafe())
+	a.lazyInit()
+	return &IntArray{
+		TArray: a.TArray.Clone(),
+	}
 }
 
 // Clear deletes all items of current array.
 func (a *IntArray) Clear() *IntArray {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		a.array = make([]int, 0)
-	}
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.Clear()
 	return a
 }
 
 // Contains checks whether a value exists in the array.
 func (a *IntArray) Contains(value int) bool {
-	return a.Search(value) != -1
+	a.lazyInit()
+	return a.TArray.Contains(value)
 }
 
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 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
-	}
-	result := -1
-	for index, v := range a.array {
-		if v == value {
-			result = index
-			break
-		}
-	}
-	return result
+	a.lazyInit()
+	return a.TArray.Search(value)
 }
 
 // Unique uniques the array, clear repeated items.
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *IntArray) Unique() *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return a
-	}
-	var (
-		ok          bool
-		temp        int
-		uniqueSet   = make(map[int]struct{})
-		uniqueArray = make([]int, 0, len(a.array))
-	)
-	for i := 0; i < len(a.array); i++ {
-		temp = a.array[i]
-		if _, ok = uniqueSet[temp]; ok {
-			continue
-		}
-		uniqueSet[temp] = struct{}{}
-		uniqueArray = append(uniqueArray, temp)
-	}
-	a.array = uniqueArray
+	a.lazyInit()
+	a.TArray.Unique()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *IntArray) LockFunc(f func(array []int)) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	f(a.array)
+	a.lazyInit()
+	a.TArray.LockFunc(f)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *IntArray) RLockFunc(f func(array []int)) *IntArray {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	f(a.array)
+	a.lazyInit()
+	a.TArray.RLockFunc(f)
 	return a
 }
 
@@ -588,46 +355,16 @@ func (a *IntArray) Merge(array any) *IntArray {
 // Fill fills an array with num entries of the value `value`,
 // keys starting at the `startIndex` parameter.
 func (a *IntArray) Fill(startIndex int, num int, value int) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if startIndex < 0 || startIndex > len(a.array) {
-		return gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			"index %d out of array range %d",
-			startIndex, len(a.array),
-		)
-	}
-	for i := startIndex; i < startIndex+num; i++ {
-		if i > len(a.array)-1 {
-			a.array = append(a.array, value)
-		} else {
-			a.array[i] = value
-		}
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.Fill(startIndex, num, value)
 }
 
 // Chunk splits an array into multiple arrays,
 // the size of each array is determined by `size`.
 // The last chunk may contain less than size elements.
 func (a *IntArray) Chunk(size int) [][]int {
-	if size < 1 {
-		return nil
-	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	length := len(a.array)
-	chunks := int(math.Ceil(float64(length) / float64(size)))
-	var n [][]int
-	for i, end := 0, 0; chunks > 0; chunks-- {
-		end = (i + 1) * size
-		if end > length {
-			end = length
-		}
-		n = append(n, a.array[i*size:end])
-		i++
-	}
-	return n
+	a.lazyInit()
+	return a.TArray.Chunk(size)
 }
 
 // Pad pads array to the specified length with `value`.
@@ -635,98 +372,47 @@ func (a *IntArray) Chunk(size int) [][]int {
 // If the absolute value of `size` is less than or equal to the length of the array
 // then no padding takes place.
 func (a *IntArray) Pad(size int, value int) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size == 0 || (size > 0 && size < len(a.array)) || (size < 0 && size > -len(a.array)) {
-		return a
-	}
-	n := size
-	if size < 0 {
-		n = -size
-	}
-	n -= len(a.array)
-	tmp := make([]int, n)
-	for i := 0; i < n; i++ {
-		tmp[i] = value
-	}
-	if size > 0 {
-		a.array = append(a.array, tmp...)
-	} else {
-		a.array = append(tmp, a.array...)
-	}
+	a.lazyInit()
+	a.TArray.Pad(size, value)
 	return a
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *IntArray) Rand() (value int, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return 0, false
-	}
-	return a.array[grand.Intn(len(a.array))], true
+	a.lazyInit()
+	return a.TArray.Rand()
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *IntArray) Rands(size int) []int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	array := make([]int, size)
-	for i := 0; i < size; i++ {
-		array[i] = a.array[grand.Intn(len(a.array))]
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Rands(size)
 }
 
 // Shuffle randomly shuffles the array.
 func (a *IntArray) Shuffle() *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, v := range grand.Perm(len(a.array)) {
-		a.array[i], a.array[v] = a.array[v], a.array[i]
-	}
+	a.lazyInit()
+	a.TArray.Shuffle()
 	return a
 }
 
 // Reverse makes array with elements in reverse order.
 func (a *IntArray) Reverse() *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, j := 0, len(a.array)-1; i < j; i, j = i+1, j-1 {
-		a.array[i], a.array[j] = a.array[j], a.array[i]
-	}
+	a.lazyInit()
+	a.TArray.Reverse()
 	return a
 }
 
 // Join joins array elements with a string `glue`.
 func (a *IntArray) Join(glue string) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return ""
-	}
-	buffer := bytes.NewBuffer(nil)
-	for k, v := range a.array {
-		buffer.WriteString(gconv.String(v))
-		if k != len(a.array)-1 {
-			buffer.WriteString(glue)
-		}
-	}
-	return buffer.String()
+	a.lazyInit()
+	return a.TArray.Join(glue)
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *IntArray) CountValues() map[int]int {
-	m := make(map[int]int)
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		m[v]++
-	}
-	return m
+	a.lazyInit()
+	return a.TArray.CountValues()
 }
 
 // Iterator is alias of IteratorAsc.
@@ -737,25 +423,15 @@ func (a *IntArray) Iterator(f func(k int, v int) bool) {
 // IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *IntArray) IteratorAsc(f func(k int, v int) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for k, v := range a.array {
-		if !f(k, v) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.TArray.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the array readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *IntArray) IteratorDesc(f func(k int, v int) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for i := len(a.array) - 1; i >= 0; i-- {
-		if !f(i, a.array[i]) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.TArray.IteratorDesc(f)
 }
 
 // String returns current array as a string, which implements like json.Marshal does.
@@ -769,80 +445,49 @@ func (a *IntArray) String() string {
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (a IntArray) MarshalJSON() ([]byte, error) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return json.Marshal(a.array)
+	a.lazyInit()
+	return a.TArray.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *IntArray) UnmarshalJSON(b []byte) error {
-	if a.array == nil {
-		a.array = make([]int, 0)
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
-		return err
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
 func (a *IntArray) UnmarshalValue(value any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	switch value.(type) {
-	case string, []byte:
-		return json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
-	default:
-		a.array = gconv.SliceInt(value)
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.UnmarshalValue(value)
 }
 
 // Filter iterates array and filters elements using custom callback function.
 // It removes the element from array if callback function `filter` returns true,
 // it or else does nothing and continues iterating.
 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++
-		}
-	}
+	a.lazyInit()
+	a.TArray.Filter(filter)
 	return a
 }
 
 // FilterEmpty removes all zero value of the array.
 func (a *IntArray) FilterEmpty() *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if a.array[i] == 0 {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.TArray.FilterEmpty()
 	return a
 }
 
 // Walk applies a user supplied function `f` to every item of array.
 func (a *IntArray) Walk(f func(value int) int) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, v := range a.array {
-		a.array[i] = f(v)
-	}
+	a.lazyInit()
+	a.TArray.Walk(f)
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *IntArray) IsEmpty() bool {
-	return a.Len() == 0
+	a.lazyInit()
+	return a.TArray.IsEmpty()
 }
 
 // DeepCopy implements interface for deep copy of current type.
@@ -850,9 +495,8 @@ func (a *IntArray) DeepCopy() any {
 	if a == nil {
 		return nil
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	newSlice := make([]int, len(a.array))
-	copy(newSlice, a.array)
-	return NewIntArrayFrom(newSlice, a.mu.IsSafe())
+	a.lazyInit()
+	return &IntArray{
+		TArray: a.TArray.DeepCopy().(*TArray[int]),
+	}
 }
diff --git a/container/garray/garray_normal_str.go b/container/garray/garray_normal_str.go
index 06b61c3a3..cb5440326 100644
--- a/container/garray/garray_normal_str.go
+++ b/container/garray/garray_normal_str.go
@@ -8,25 +8,20 @@ package garray
 
 import (
 	"bytes"
-	"math"
 	"sort"
 	"strings"
+	"sync"
 
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/grand"
 )
 
 // StrArray is a golang string array with rich features.
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type StrArray struct {
-	mu    rwmutex.RWMutex
-	array []string
+	*TArray[string]
+	once sync.Once
 }
 
 // NewStrArray creates and returns an empty array.
@@ -41,8 +36,7 @@ func NewStrArray(safe ...bool) *StrArray {
 // which is false in default.
 func NewStrArraySize(size int, cap int, safe ...bool) *StrArray {
 	return &StrArray{
-		mu:    rwmutex.Create(safe...),
-		array: make([]string, size, cap),
+		TArray: NewTArraySize[string](size, cap, safe...),
 	}
 }
 
@@ -51,8 +45,7 @@ func NewStrArraySize(size int, cap int, safe ...bool) *StrArray {
 // which is false in default.
 func NewStrArrayFrom(array []string, safe ...bool) *StrArray {
 	return &StrArray{
-		mu:    rwmutex.Create(safe...),
-		array: array,
+		TArray: NewTArrayFrom(array, safe...),
 	}
 }
 
@@ -62,77 +55,64 @@ func NewStrArrayFrom(array []string, safe ...bool) *StrArray {
 func NewStrArrayFromCopy(array []string, safe ...bool) *StrArray {
 	newArray := make([]string, len(array))
 	copy(newArray, array)
-	return &StrArray{
-		mu:    rwmutex.Create(safe...),
-		array: newArray,
-	}
+	return NewStrArrayFrom(newArray, safe...)
+}
+
+// lazyInit lazily initializes the array.
+func (a *StrArray) lazyInit() {
+	a.once.Do(func() {
+		if a.TArray == nil {
+			a.TArray = NewTArray[string](false)
+		}
+	})
 }
 
 // At returns the value by the specified index.
 // If the given `index` is out of range of the array, it returns an empty string.
 func (a *StrArray) At(index int) (value string) {
-	value, _ = a.Get(index)
-	return
+	a.lazyInit()
+	return a.TArray.At(index)
 }
 
 // Get returns the value by the specified index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *StrArray) Get(index int) (value string, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if index < 0 || index >= len(a.array) {
-		return "", false
-	}
-	return a.array[index], true
+	a.lazyInit()
+	return a.TArray.Get(index)
 }
 
 // Set sets value to specified index.
 func (a *StrArray) Set(index int, value string) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	a.array[index] = value
-	return nil
+	a.lazyInit()
+	return a.TArray.Set(index, value)
 }
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *StrArray) SetArray(array []string) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array = array
+	a.lazyInit()
+	a.TArray.SetArray(array)
 	return a
 }
 
 // Replace replaces the array items by given `array` from the beginning of array.
 func (a *StrArray) Replace(array []string) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	max := len(array)
-	if max > len(a.array) {
-		max = len(a.array)
-	}
-	for i := 0; i < max; i++ {
-		a.array[i] = array[i]
-	}
+	a.lazyInit()
+	a.TArray.Replace(array)
 	return a
 }
 
 // Sum returns the sum of values in an array.
 func (a *StrArray) Sum() (sum int) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		sum += gconv.Int(v)
-	}
-	return
+	a.lazyInit()
+	return a.TArray.Sum()
 }
 
 // Sort sorts the array in increasing order.
 // The parameter `reverse` controls whether sort
 // in increasing order(default) or decreasing order
 func (a *StrArray) Sort(reverse ...bool) *StrArray {
+	a.lazyInit()
+
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	if len(reverse) > 0 && reverse[0] {
@@ -147,200 +127,101 @@ func (a *StrArray) Sort(reverse ...bool) *StrArray {
 
 // SortFunc sorts the array by custom function `less`.
 func (a *StrArray) SortFunc(less func(v1, v2 string) bool) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	sort.Slice(a.array, func(i, j int) bool {
-		return less(a.array[i], a.array[j])
-	})
+	a.lazyInit()
+	a.TArray.SortFunc(less)
 	return a
 }
 
 // InsertBefore inserts the `values` to the front of `index`.
 func (a *StrArray) InsertBefore(index int, values ...string) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	rear := append([]string{}, a.array[index:]...)
-	a.array = append(a.array[0:index], values...)
-	a.array = append(a.array, rear...)
-	return nil
+	a.lazyInit()
+	return a.TArray.InsertBefore(index, values...)
 }
 
 // InsertAfter inserts the `values` to the back of `index`.
 func (a *StrArray) InsertAfter(index int, values ...string) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	rear := append([]string{}, a.array[index+1:]...)
-	a.array = append(a.array[0:index+1], values...)
-	a.array = append(a.array, rear...)
-	return nil
+	a.lazyInit()
+	return a.TArray.InsertAfter(index, values...)
 }
 
 // Remove removes an item by index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *StrArray) Remove(index int) (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(index)
-}
-
-// doRemoveWithoutLock removes an item by index without lock.
-func (a *StrArray) doRemoveWithoutLock(index int) (value string, found bool) {
-	if index < 0 || index >= len(a.array) {
-		return "", false
-	}
-	// Determine array boundaries when deleting to improve deletion efficiency.
-	if index == 0 {
-		value := a.array[0]
-		a.array = a.array[1:]
-		return value, true
-	} else if index == len(a.array)-1 {
-		value := a.array[index]
-		a.array = a.array[:index]
-		return value, true
-	}
-	// If it is a non-boundary delete,
-	// it will involve the creation of an array,
-	// then the deletion is less efficient.
-	value = a.array[index]
-	a.array = append(a.array[:index], a.array[index+1:]...)
-	return value, true
+	a.lazyInit()
+	return a.TArray.Remove(index)
 }
 
 // RemoveValue removes an item by value.
 // It returns true if value is found in the array, or else false if not found.
 func (a *StrArray) RemoveValue(value string) bool {
-	if i := a.Search(value); i != -1 {
-		_, found := a.Remove(i)
-		return found
-	}
-	return false
+	a.lazyInit()
+	return a.TArray.RemoveValue(value)
 }
 
 // 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)
-		}
-	}
+	a.lazyInit()
+	a.TArray.RemoveValues(values...)
 }
 
 // PushLeft pushes one or multiple items to the beginning of array.
 func (a *StrArray) PushLeft(value ...string) *StrArray {
-	a.mu.Lock()
-	a.array = append(value, a.array...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.PushLeft(value...)
 	return a
 }
 
 // PushRight pushes one or multiple items to the end of array.
 // It equals to Append.
 func (a *StrArray) PushRight(value ...string) *StrArray {
-	a.mu.Lock()
-	a.array = append(a.array, value...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.PushRight(value...)
 	return a
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 // Note that if the array is empty, the `found` is false.
 func (a *StrArray) PopLeft() (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return "", false
-	}
-	value = a.array[0]
-	a.array = a.array[1:]
-	return value, true
+	a.lazyInit()
+	return a.TArray.PopLeft()
 }
 
 // PopRight pops and returns an item from the end of array.
 // Note that if the array is empty, the `found` is false.
 func (a *StrArray) PopRight() (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	index := len(a.array) - 1
-	if index < 0 {
-		return "", false
-	}
-	value = a.array[index]
-	a.array = a.array[:index]
-	return value, true
+	a.lazyInit()
+	return a.TArray.PopRight()
 }
 
 // PopRand randomly pops and return an item out of array.
 // Note that if the array is empty, the `found` is false.
 func (a *StrArray) PopRand() (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	a.lazyInit()
+	return a.TArray.PopRand()
 }
 
 // PopRands randomly pops and returns `size` items out of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *StrArray) PopRands(size int) []string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		size = len(a.array)
-	}
-	array := make([]string, size)
-	for i := 0; i < size; i++ {
-		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.PopRands(size)
 }
 
 // PopLefts pops and returns `size` items from the beginning of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *StrArray) PopLefts(size int) []string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[0:size]
-	a.array = a.array[size:]
-	return value
+	a.lazyInit()
+	return a.TArray.PopLefts(size)
 }
 
 // PopRights pops and returns `size` items from the end of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *StrArray) PopRights(size int) []string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	index := len(a.array) - size
-	if index <= 0 {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[index:]
-	a.array = a.array[:index]
-	return value
+	a.lazyInit()
+	return a.TArray.PopRights(size)
 }
 
 // Range picks and returns items by range, like array[start:end].
@@ -351,26 +232,8 @@ func (a *StrArray) PopRights(size int) []string {
 // If `end` is omitted, then the sequence will have everything from start up
 // until the end of the array.
 func (a *StrArray) Range(start int, end ...int) []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	offsetEnd := len(a.array)
-	if len(end) > 0 && end[0] < offsetEnd {
-		offsetEnd = end[0]
-	}
-	if start > offsetEnd {
-		return nil
-	}
-	if start < 0 {
-		start = 0
-	}
-	array := ([]string)(nil)
-	if a.mu.IsSafe() {
-		array = make([]string, offsetEnd-start)
-		copy(array, a.array[start:offsetEnd])
-	} else {
-		array = a.array[start:offsetEnd]
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Range(start, end...)
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -387,111 +250,63 @@ func (a *StrArray) Range(start int, end ...int) []string {
 //
 // Any possibility crossing the left border of array, it will fail.
 func (a *StrArray) SubSlice(offset int, length ...int) []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	size := len(a.array)
-	if len(length) > 0 {
-		size = length[0]
-	}
-	if offset > len(a.array) {
-		return nil
-	}
-	if offset < 0 {
-		offset = len(a.array) + offset
-		if offset < 0 {
-			return nil
-		}
-	}
-	if size < 0 {
-		offset += size
-		size = -size
-		if offset < 0 {
-			return nil
-		}
-	}
-	end := offset + size
-	if end > len(a.array) {
-		end = len(a.array)
-		size = len(a.array) - offset
-	}
-	if a.mu.IsSafe() {
-		s := make([]string, size)
-		copy(s, a.array[offset:])
-		return s
-	}
-	return a.array[offset:end]
+	a.lazyInit()
+	return a.TArray.SubSlice(offset, length...)
 }
 
 // Append is alias of PushRight,please See PushRight.
 func (a *StrArray) Append(value ...string) *StrArray {
-	a.mu.Lock()
-	a.array = append(a.array, value...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.Append(value...)
 	return a
 }
 
 // Len returns the length of array.
 func (a *StrArray) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
+	a.lazyInit()
+	return a.TArray.Len()
 }
 
 // Slice returns the underlying data of array.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (a *StrArray) Slice() []string {
-	array := ([]string)(nil)
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-		array = make([]string, len(a.array))
-		copy(array, a.array)
-	} else {
-		array = a.array
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Slice()
 }
 
 // Interfaces returns current array as []any.
 func (a *StrArray) Interfaces() []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	array := make([]any, len(a.array))
-	for k, v := range a.array {
-		array[k] = v
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Interfaces()
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *StrArray) Clone() (newArray *StrArray) {
-	a.mu.RLock()
-	array := make([]string, len(a.array))
-	copy(array, a.array)
-	a.mu.RUnlock()
-	return NewStrArrayFrom(array, a.mu.IsSafe())
+	a.lazyInit()
+	return &StrArray{
+		TArray: a.TArray.Clone(),
+	}
 }
 
 // Clear deletes all items of current array.
 func (a *StrArray) Clear() *StrArray {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		a.array = make([]string, 0)
-	}
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.Clear()
 	return a
 }
 
 // Contains checks whether a value exists in the array.
 func (a *StrArray) Contains(value string) bool {
-	return a.Search(value) != -1
+	a.lazyInit()
+	return a.TArray.Contains(value)
 }
 
 // ContainsI checks whether a value exists in the array with case-insensitively.
 // Note that it internally iterates the whole array to do the comparison with case-insensitively.
 func (a *StrArray) ContainsI(value string) bool {
+	a.lazyInit()
+
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	if len(a.array) == 0 {
@@ -508,64 +323,29 @@ func (a *StrArray) ContainsI(value string) bool {
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 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
-	}
-	result := -1
-	for index, v := range a.array {
-		if strings.Compare(v, value) == 0 {
-			result = index
-			break
-		}
-	}
-	return result
+	a.lazyInit()
+	return a.TArray.Search(value)
 }
 
 // Unique uniques the array, clear repeated items.
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *StrArray) Unique() *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return a
-	}
-	var (
-		ok          bool
-		temp        string
-		uniqueSet   = make(map[string]struct{})
-		uniqueArray = make([]string, 0, len(a.array))
-	)
-	for i := 0; i < len(a.array); i++ {
-		temp = a.array[i]
-		if _, ok = uniqueSet[temp]; ok {
-			continue
-		}
-		uniqueSet[temp] = struct{}{}
-		uniqueArray = append(uniqueArray, temp)
-	}
-	a.array = uniqueArray
+	a.lazyInit()
+	a.TArray.Unique()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *StrArray) LockFunc(f func(array []string)) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	f(a.array)
+	a.lazyInit()
+	a.TArray.LockFunc(f)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *StrArray) RLockFunc(f func(array []string)) *StrArray {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	f(a.array)
+	a.lazyInit()
+	a.TArray.RLockFunc(f)
 	return a
 }
 
@@ -580,42 +360,16 @@ func (a *StrArray) Merge(array any) *StrArray {
 // Fill fills an array with num entries of the value `value`,
 // keys starting at the `startIndex` parameter.
 func (a *StrArray) Fill(startIndex int, num int, value string) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if startIndex < 0 || startIndex > len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", startIndex, len(a.array))
-	}
-	for i := startIndex; i < startIndex+num; i++ {
-		if i > len(a.array)-1 {
-			a.array = append(a.array, value)
-		} else {
-			a.array[i] = value
-		}
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.Fill(startIndex, num, value)
 }
 
 // Chunk splits an array into multiple arrays,
 // the size of each array is determined by `size`.
 // The last chunk may contain less than size elements.
 func (a *StrArray) Chunk(size int) [][]string {
-	if size < 1 {
-		return nil
-	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	length := len(a.array)
-	chunks := int(math.Ceil(float64(length) / float64(size)))
-	var n [][]string
-	for i, end := 0, 0; chunks > 0; chunks-- {
-		end = (i + 1) * size
-		if end > length {
-			end = length
-		}
-		n = append(n, a.array[i*size:end])
-		i++
-	}
-	return n
+	a.lazyInit()
+	return a.TArray.Chunk(size)
 }
 
 // Pad pads array to the specified length with `value`.
@@ -623,98 +377,47 @@ func (a *StrArray) Chunk(size int) [][]string {
 // If the absolute value of `size` is less than or equal to the length of the array
 // then no padding takes place.
 func (a *StrArray) Pad(size int, value string) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size == 0 || (size > 0 && size < len(a.array)) || (size < 0 && size > -len(a.array)) {
-		return a
-	}
-	n := size
-	if size < 0 {
-		n = -size
-	}
-	n -= len(a.array)
-	tmp := make([]string, n)
-	for i := 0; i < n; i++ {
-		tmp[i] = value
-	}
-	if size > 0 {
-		a.array = append(a.array, tmp...)
-	} else {
-		a.array = append(tmp, a.array...)
-	}
+	a.lazyInit()
+	a.TArray.Pad(size, value)
 	return a
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *StrArray) Rand() (value string, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return "", false
-	}
-	return a.array[grand.Intn(len(a.array))], true
+	a.lazyInit()
+	return a.TArray.Rand()
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *StrArray) Rands(size int) []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	array := make([]string, size)
-	for i := 0; i < size; i++ {
-		array[i] = a.array[grand.Intn(len(a.array))]
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Rands(size)
 }
 
 // Shuffle randomly shuffles the array.
 func (a *StrArray) Shuffle() *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, v := range grand.Perm(len(a.array)) {
-		a.array[i], a.array[v] = a.array[v], a.array[i]
-	}
+	a.lazyInit()
+	a.TArray.Shuffle()
 	return a
 }
 
 // Reverse makes array with elements in reverse order.
 func (a *StrArray) Reverse() *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, j := 0, len(a.array)-1; i < j; i, j = i+1, j-1 {
-		a.array[i], a.array[j] = a.array[j], a.array[i]
-	}
+	a.lazyInit()
+	a.TArray.Reverse()
 	return a
 }
 
 // Join joins array elements with a string `glue`.
 func (a *StrArray) Join(glue string) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return ""
-	}
-	buffer := bytes.NewBuffer(nil)
-	for k, v := range a.array {
-		buffer.WriteString(v)
-		if k != len(a.array)-1 {
-			buffer.WriteString(glue)
-		}
-	}
-	return buffer.String()
+	a.lazyInit()
+	return a.TArray.Join(glue)
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *StrArray) CountValues() map[string]int {
-	m := make(map[string]int)
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		m[v]++
-	}
-	return m
+	a.lazyInit()
+	return a.TArray.CountValues()
 }
 
 // Iterator is alias of IteratorAsc.
@@ -725,25 +428,15 @@ func (a *StrArray) Iterator(f func(k int, v string) bool) {
 // IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *StrArray) IteratorAsc(f func(k int, v string) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for k, v := range a.array {
-		if !f(k, v) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.TArray.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the array readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *StrArray) IteratorDesc(f func(k int, v string) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for i := len(a.array) - 1; i >= 0; i-- {
-		if !f(i, a.array[i]) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.TArray.IteratorDesc(f)
 }
 
 // String returns current array as a string, which implements like json.Marshal does.
@@ -751,6 +444,9 @@ func (a *StrArray) String() string {
 	if a == nil {
 		return ""
 	}
+
+	a.lazyInit()
+
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)
@@ -768,80 +464,49 @@ func (a *StrArray) String() string {
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (a StrArray) MarshalJSON() ([]byte, error) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return json.Marshal(a.array)
+	a.lazyInit()
+	return a.TArray.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *StrArray) UnmarshalJSON(b []byte) error {
-	if a.array == nil {
-		a.array = make([]string, 0)
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
-		return err
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
 func (a *StrArray) UnmarshalValue(value any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	switch value.(type) {
-	case string, []byte:
-		return json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
-	default:
-		a.array = gconv.SliceStr(value)
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.UnmarshalValue(value)
 }
 
 // Filter iterates array and filters elements using custom callback function.
 // It removes the element from array if callback function `filter` returns true,
 // it or else does nothing and continues iterating.
 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++
-		}
-	}
+	a.lazyInit()
+	a.TArray.Filter(filter)
 	return a
 }
 
 // FilterEmpty removes all empty string value of the array.
 func (a *StrArray) FilterEmpty() *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if a.array[i] == "" {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.TArray.FilterEmpty()
 	return a
 }
 
 // Walk applies a user supplied function `f` to every item of array.
 func (a *StrArray) Walk(f func(value string) string) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, v := range a.array {
-		a.array[i] = f(v)
-	}
+	a.lazyInit()
+	a.TArray.Walk(f)
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *StrArray) IsEmpty() bool {
-	return a.Len() == 0
+	a.lazyInit()
+	return a.TArray.IsEmpty()
 }
 
 // DeepCopy implements interface for deep copy of current type.
@@ -849,9 +514,8 @@ func (a *StrArray) DeepCopy() any {
 	if a == nil {
 		return nil
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	newSlice := make([]string, len(a.array))
-	copy(newSlice, a.array)
-	return NewStrArrayFrom(newSlice, a.mu.IsSafe())
+	a.lazyInit()
+	return &StrArray{
+		TArray: a.TArray.DeepCopy().(*TArray[string]),
+	}
 }
diff --git a/container/garray/garray_normal_t.go b/container/garray/garray_normal_t.go
new file mode 100644
index 000000000..98a8ec7b8
--- /dev/null
+++ b/container/garray/garray_normal_t.go
@@ -0,0 +1,861 @@
+// 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 garray
+
+import (
+	"bytes"
+	"math"
+	"sort"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/deepcopy"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/grand"
+)
+
+// TArray is a golang array with rich features.
+// It contains a concurrent-safe/unsafe switch, which should be set
+// when its initialization and cannot be changed then.
+type TArray[T comparable] struct {
+	mu    rwmutex.RWMutex
+	array []T
+}
+
+// NewTArray creates and returns an empty array.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewTArray[T comparable](safe ...bool) *TArray[T] {
+	return NewTArraySize[T](0, 0, safe...)
+}
+
+// NewTArraySize create and returns an array with given size and cap.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewTArraySize[T comparable](size int, cap int, safe ...bool) *TArray[T] {
+	return &TArray[T]{
+		mu:    rwmutex.Create(safe...),
+		array: make([]T, size, cap),
+	}
+}
+
+// NewTArrayFrom creates and returns an array with given slice `array`.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewTArrayFrom[T comparable](array []T, safe ...bool) *TArray[T] {
+	return &TArray[T]{
+		mu:    rwmutex.Create(safe...),
+		array: array,
+	}
+}
+
+// NewTArrayFromCopy creates and returns an array from a copy of given slice `array`.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewTArrayFromCopy[T comparable](array []T, safe ...bool) *TArray[T] {
+	newArray := make([]T, len(array))
+	copy(newArray, array)
+	return &TArray[T]{
+		mu:    rwmutex.Create(safe...),
+		array: newArray,
+	}
+}
+
+// At returns the value by the specified index.
+// If the given `index` is out of range of the array, it returns `nil`.
+func (a *TArray[T]) At(index int) (value T) {
+	value, _ = a.Get(index)
+	return
+}
+
+// Get returns the value by the specified index.
+// If the given `index` is out of range of the array, the `found` is false.
+func (a *TArray[T]) Get(index int) (value T, found bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if index < 0 || index >= len(a.array) {
+		found = false
+		return
+	}
+	return a.array[index], true
+}
+
+// Set sets value to specified index.
+func (a *TArray[T]) Set(index int, value T) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if index < 0 || index >= len(a.array) {
+		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
+	}
+	a.array[index] = value
+	return nil
+}
+
+// SetArray sets the underlying slice array with the given `array`.
+func (a *TArray[T]) SetArray(array []T) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.array = array
+	return a
+}
+
+// Replace replaces the array items by given `array` from the beginning of array.
+func (a *TArray[T]) Replace(array []T) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	max := len(array)
+	if max > len(a.array) {
+		max = len(a.array)
+	}
+	for i := 0; i < max; i++ {
+		a.array[i] = array[i]
+	}
+	return a
+}
+
+// Sum returns the sum of values in an array.
+func (a *TArray[T]) Sum() (sum int) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		sum += gconv.Int(v)
+	}
+	return
+}
+
+// SortFunc sorts the array by custom function `less`.
+func (a *TArray[T]) SortFunc(less func(v1, v2 T) bool) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	sort.Slice(a.array, func(i, j int) bool {
+		return less(a.array[i], a.array[j])
+	})
+	return a
+}
+
+// InsertBefore inserts the `values` to the front of `index`.
+func (a *TArray[T]) InsertBefore(index int, values ...T) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if index < 0 || index >= len(a.array) {
+		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
+	}
+	rear := append([]T{}, a.array[index:]...)
+	a.array = append(a.array[0:index], values...)
+	a.array = append(a.array, rear...)
+	return nil
+}
+
+// InsertAfter inserts the `values` to the back of `index`.
+func (a *TArray[T]) InsertAfter(index int, values ...T) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if index < 0 || index >= len(a.array) {
+		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
+	}
+	rear := append([]T{}, a.array[index+1:]...)
+	a.array = append(a.array[0:index+1], values...)
+	a.array = append(a.array, rear...)
+	return nil
+}
+
+// Remove removes an item by index.
+// If the given `index` is out of range of the array, the `found` is false.
+func (a *TArray[T]) Remove(index int) (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.doRemoveWithoutLock(index)
+}
+
+// doRemoveWithoutLock removes an item by index without lock.
+func (a *TArray[T]) doRemoveWithoutLock(index int) (value T, found bool) {
+	if index < 0 || index >= len(a.array) {
+		found = false
+		return
+	}
+	// Determine array boundaries when deleting to improve deletion efficiency.
+	if index == 0 {
+		value := a.array[0]
+		a.array = a.array[1:]
+		return value, true
+	} else if index == len(a.array)-1 {
+		value := a.array[index]
+		a.array = a.array[:index]
+		return value, true
+	}
+	// If it is a non-boundary delete,
+	// it will involve the creation of an array,
+	// then the deletion is less efficient.
+	value = a.array[index]
+	a.array = append(a.array[:index], a.array[index+1:]...)
+	return value, true
+}
+
+// RemoveValue removes an item by value.
+// It returns true if value is found in the array, or else false if not found.
+func (a *TArray[T]) RemoveValue(value T) bool {
+	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 *TArray[T]) RemoveValues(values ...T) {
+	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 *TArray[T]) PushLeft(value ...T) *TArray[T] {
+	a.mu.Lock()
+	a.array = append(value, a.array...)
+	a.mu.Unlock()
+	return a
+}
+
+// PushRight pushes one or multiple items to the end of array.
+// It equals to Append.
+func (a *TArray[T]) PushRight(value ...T) *TArray[T] {
+	a.mu.Lock()
+	a.array = append(a.array, value...)
+	a.mu.Unlock()
+	return a
+}
+
+// PopRand randomly pops and return an item out of array.
+// Note that if the array is empty, the `found` is false.
+func (a *TArray[T]) PopRand() (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+}
+
+// PopRands randomly pops and returns `size` items out of array.
+func (a *TArray[T]) PopRands(size int) []T {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	if size >= len(a.array) {
+		size = len(a.array)
+	}
+	array := make([]T, size)
+	for i := 0; i < size; i++ {
+		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	}
+	return array
+}
+
+// PopLeft pops and returns an item from the beginning of array.
+// Note that if the array is empty, the `found` is false.
+func (a *TArray[T]) PopLeft() (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		found = false
+		return
+	}
+	value = a.array[0]
+	a.array = a.array[1:]
+	return value, true
+}
+
+// PopRight pops and returns an item from the end of array.
+// Note that if the array is empty, the `found` is false.
+func (a *TArray[T]) PopRight() (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - 1
+	if index < 0 {
+		found = false
+		return
+	}
+	value = a.array[index]
+	a.array = a.array[:index]
+	return value, true
+}
+
+// PopLefts pops and returns `size` items from the beginning of array.
+func (a *TArray[T]) PopLefts(size int) []T {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	if size >= len(a.array) {
+		array := a.array
+		a.array = a.array[:0]
+		return array
+	}
+	value := a.array[0:size]
+	a.array = a.array[size:]
+	return value
+}
+
+// PopRights pops and returns `size` items from the end of array.
+func (a *TArray[T]) PopRights(size int) []T {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	index := len(a.array) - size
+	if index <= 0 {
+		array := a.array
+		a.array = a.array[:0]
+		return array
+	}
+	value := a.array[index:]
+	a.array = a.array[:index]
+	return value
+}
+
+// Range picks and returns items by range, like array[start:end].
+// Notice, if in concurrent-safe usage, it returns a copy of slice;
+// else a pointer to the underlying data.
+//
+// If `end` is negative, then the offset will start from the end of array.
+// If `end` is omitted, then the sequence will have everything from start up
+// until the end of the array.
+func (a *TArray[T]) Range(start int, end ...int) []T {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	offsetEnd := len(a.array)
+	if len(end) > 0 && end[0] < offsetEnd {
+		offsetEnd = end[0]
+	}
+	if start > offsetEnd {
+		return nil
+	}
+	if start < 0 {
+		start = 0
+	}
+	array := ([]T)(nil)
+	if a.mu.IsSafe() {
+		array = make([]T, offsetEnd-start)
+		copy(array, a.array[start:offsetEnd])
+	} else {
+		array = a.array[start:offsetEnd]
+	}
+	return array
+}
+
+// SubSlice returns a slice of elements from the array as specified
+// by the `offset` and `size` parameters.
+// If in concurrent safe usage, it returns a copy of the slice; else a pointer.
+//
+// If offset is non-negative, the sequence will start at that offset in the array.
+// If offset is negative, the sequence will start that far from the end of the array.
+//
+// If length is given and is positive, then the sequence will have up to that many elements in it.
+// If the array is shorter than the length, then only the available array elements will be present.
+// If length is given and is negative then the sequence will stop that many elements from the end of the array.
+// If it is omitted, then the sequence will have everything from offset up until the end of the array.
+//
+// Any possibility crossing the left border of array, it will fail.
+func (a *TArray[T]) SubSlice(offset int, length ...int) []T {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	size := len(a.array)
+	if len(length) > 0 {
+		size = length[0]
+	}
+	if offset > len(a.array) {
+		return nil
+	}
+	if offset < 0 {
+		offset = len(a.array) + offset
+		if offset < 0 {
+			return nil
+		}
+	}
+	if size < 0 {
+		offset += size
+		size = -size
+		if offset < 0 {
+			return nil
+		}
+	}
+	end := offset + size
+	if end > len(a.array) {
+		end = len(a.array)
+		size = len(a.array) - offset
+	}
+	if a.mu.IsSafe() {
+		s := make([]T, size)
+		copy(s, a.array[offset:])
+		return s
+	} else {
+		return a.array[offset:end]
+	}
+}
+
+// Append is alias of PushRight, please See PushRight.
+func (a *TArray[T]) Append(value ...T) *TArray[T] {
+	a.PushRight(value...)
+	return a
+}
+
+// Len returns the length of array.
+func (a *TArray[T]) Len() int {
+	a.mu.RLock()
+	length := len(a.array)
+	a.mu.RUnlock()
+	return length
+}
+
+// Slice returns the underlying data of array.
+// Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
+// or else a pointer to the underlying data.
+func (a *TArray[T]) Slice() []T {
+	if a.mu.IsSafe() {
+		a.mu.RLock()
+		defer a.mu.RUnlock()
+		array := make([]T, len(a.array))
+		copy(array, a.array)
+		return array
+	} else {
+		return a.array
+	}
+}
+
+// Interfaces returns current array as []any.
+func (a *TArray[T]) Interfaces() []any {
+	return tToAnySlice(a.Slice())
+}
+
+// Clone returns a new array, which is a copy of current array.
+func (a *TArray[T]) Clone() (newArray *TArray[T]) {
+	a.mu.RLock()
+	array := make([]T, len(a.array))
+	copy(array, a.array)
+	a.mu.RUnlock()
+	return NewTArrayFrom(array, a.mu.IsSafe())
+}
+
+// Clear deletes all items of current array.
+func (a *TArray[T]) Clear() *TArray[T] {
+	a.mu.Lock()
+	if len(a.array) > 0 {
+		a.array = make([]T, 0)
+	}
+	a.mu.Unlock()
+	return a
+}
+
+// Contains checks whether a value exists in the array.
+func (a *TArray[T]) Contains(value T) bool {
+	return a.Search(value) != -1
+}
+
+// Search searches array by `value`, returns the index of `value`,
+// or returns -1 if not exists.
+func (a *TArray[T]) Search(value T) int {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return a.doSearchWithoutLock(value)
+}
+
+func (a *TArray[T]) doSearchWithoutLock(value T) int {
+	if len(a.array) == 0 {
+		return -1
+	}
+	result := -1
+	for index, v := range a.array {
+		if v == value {
+			result = index
+			break
+		}
+	}
+	return result
+}
+
+// Unique uniques the array, clear repeated items.
+// Example: [1,1,2,3,2] -> [1,2,3]
+func (a *TArray[T]) Unique() *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
+	}
+	var (
+		ok          bool
+		temp        T
+		uniqueSet   = make(map[T]struct{})
+		uniqueArray = make([]T, 0, len(a.array))
+	)
+	for i := 0; i < len(a.array); i++ {
+		temp = a.array[i]
+		if _, ok = uniqueSet[temp]; ok {
+			continue
+		}
+		uniqueSet[temp] = struct{}{}
+		uniqueArray = append(uniqueArray, temp)
+	}
+	a.array = uniqueArray
+	return a
+}
+
+// LockFunc locks writing by callback function `f`.
+func (a *TArray[T]) LockFunc(f func(array []T)) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	f(a.array)
+	return a
+}
+
+// RLockFunc locks reading by callback function `f`.
+func (a *TArray[T]) RLockFunc(f func(array []T)) *TArray[T] {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
+	return a
+}
+
+// Merge merges `array` into current array.
+// The parameter `array` can be any garray or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more parameter types.
+func (a *TArray[T]) Merge(array any) *TArray[T] {
+	var vals []T
+	switch v := array.(type) {
+	case *SortedTArray[T]:
+		vals = v.Slice()
+	case *TArray[T]:
+		vals = v.Slice()
+	case []T:
+		vals = v
+	default:
+		interfaces := gconv.Interfaces(v)
+		if err := gconv.Scan(interfaces, &vals); err != nil {
+			panic(err)
+		}
+	}
+
+	return a.Append(vals...)
+}
+
+// Fill fills an array with num entries of the value `value`,
+// keys starting at the `startIndex` parameter.
+func (a *TArray[T]) Fill(startIndex int, num int, value T) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if startIndex < 0 || startIndex > len(a.array) {
+		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", startIndex, len(a.array))
+	}
+	for i := startIndex; i < startIndex+num; i++ {
+		if i > len(a.array)-1 {
+			a.array = append(a.array, value)
+		} else {
+			a.array[i] = value
+		}
+	}
+	return nil
+}
+
+// Chunk splits an array into multiple arrays,
+// the size of each array is determined by `size`.
+// The last chunk may contain less than size elements.
+func (a *TArray[T]) Chunk(size int) [][]T {
+	if size < 1 {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	length := len(a.array)
+	chunks := int(math.Ceil(float64(length) / float64(size)))
+	var n [][]T
+	for i, end := 0, 0; chunks > 0; chunks-- {
+		end = (i + 1) * size
+		if end > length {
+			end = length
+		}
+		n = append(n, a.array[i*size:end])
+		i++
+	}
+	return n
+}
+
+// Pad pads array to the specified length with `value`.
+// If size is positive then the array is padded on the right, or negative on the left.
+// If the absolute value of `size` is less than or equal to the length of the array
+// then no padding takes place.
+func (a *TArray[T]) Pad(size int, val T) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size == 0 || (size > 0 && size < len(a.array)) || (size < 0 && size > -len(a.array)) {
+		return a
+	}
+	n := size
+	if size < 0 {
+		n = -size
+	}
+	n -= len(a.array)
+	tmp := make([]T, n)
+	for i := 0; i < n; i++ {
+		tmp[i] = val
+	}
+	if size > 0 {
+		a.array = append(a.array, tmp...)
+	} else {
+		a.array = append(tmp, a.array...)
+	}
+	return a
+}
+
+// Rand randomly returns one item from array(no deleting).
+func (a *TArray[T]) Rand() (value T, found bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		found = false
+		return
+	}
+	return a.array[grand.Intn(len(a.array))], true
+}
+
+// Rands randomly returns `size` items from array(no deleting).
+func (a *TArray[T]) Rands(size int) []T {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	array := make([]T, size)
+	for i := 0; i < size; i++ {
+		array[i] = a.array[grand.Intn(len(a.array))]
+	}
+	return array
+}
+
+// Shuffle randomly shuffles the array.
+func (a *TArray[T]) Shuffle() *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i, v := range grand.Perm(len(a.array)) {
+		a.array[i], a.array[v] = a.array[v], a.array[i]
+	}
+	return a
+}
+
+// Reverse makes array with elements in reverse order.
+func (a *TArray[T]) Reverse() *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i, j := 0, len(a.array)-1; i < j; i, j = i+1, j-1 {
+		a.array[i], a.array[j] = a.array[j], a.array[i]
+	}
+	return a
+}
+
+// Join joins array elements with a string `glue`.
+func (a *TArray[T]) Join(glue string) string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		return ""
+	}
+	buffer := bytes.NewBuffer(nil)
+	for k, v := range a.array {
+		buffer.WriteString(gconv.String(v))
+		if k != len(a.array)-1 {
+			buffer.WriteString(glue)
+		}
+	}
+	return buffer.String()
+}
+
+// CountValues counts the number of occurrences of all values in the array.
+func (a *TArray[T]) CountValues() map[T]int {
+	m := make(map[T]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
+}
+
+// Iterator is alias of IteratorAsc.
+func (a *TArray[T]) Iterator(f func(k int, v T) bool) {
+	a.IteratorAsc(f)
+}
+
+// IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (a *TArray[T]) IteratorAsc(f func(k int, v T) bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for k, v := range a.array {
+		if !f(k, v) {
+			break
+		}
+	}
+}
+
+// IteratorDesc iterates the array readonly in descending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (a *TArray[T]) IteratorDesc(f func(k int, v T) bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for i := len(a.array) - 1; i >= 0; i-- {
+		if !f(i, a.array[i]) {
+			break
+		}
+	}
+}
+
+// String returns current array as a string, which implements like json.Marshal does.
+func (a *TArray[T]) String() string {
+	if a == nil {
+		return ""
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	buffer := bytes.NewBuffer(nil)
+	buffer.WriteByte('[')
+	s := ""
+	for k, v := range a.array {
+		s = gconv.String(v)
+		if gstr.IsNumeric(s) {
+			buffer.WriteString(s)
+		} else {
+			buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
+		}
+		if k != len(a.array)-1 {
+			buffer.WriteByte(',')
+		}
+	}
+	buffer.WriteByte(']')
+	return buffer.String()
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+// DO NOT change this receiver to pointer type, as the TArray can be used as a var defined variable, like:
+// var a TArray[int]
+// Please refer to corresponding tests for more details.
+func (a TArray[T]) MarshalJSON() ([]byte, error) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
+}
+
+// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
+func (a *TArray[T]) UnmarshalJSON(b []byte) error {
+	if a.array == nil {
+		a.array = make([]T, 0)
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
+		return err
+	}
+	return nil
+}
+
+// UnmarshalValue is an interface implement which sets any type of value for array.
+func (a *TArray[T]) UnmarshalValue(value any) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		return json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
+	default:
+		if err := gconv.Scan(gconv.SliceAny(value), &a.array); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Filter iterates array and filters elements using custom callback function.
+// It removes the element from array if callback function `filter` returns true,
+// it or else does nothing and continues iterating.
+func (a *TArray[T]) Filter(filter func(index int, value T) bool) *TArray[T] {
+	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 *TArray[T]) FilterNil() *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if empty.IsNil(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 *TArray[T]) FilterEmpty() *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if empty.IsEmpty(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
+// Walk applies a user supplied function `f` to every item of array.
+func (a *TArray[T]) Walk(f func(value T) T) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i, v := range a.array {
+		a.array[i] = f(v)
+	}
+	return a
+}
+
+// IsEmpty checks whether the array is empty.
+func (a *TArray[T]) IsEmpty() bool {
+	return a.Len() == 0
+}
+
+// DeepCopy implements interface for deep copy of current type.
+func (a *TArray[T]) DeepCopy() any {
+	if a == nil {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]T, len(a.array))
+	for i, v := range a.array {
+		newSlice[i] = deepcopy.Copy(v).(T)
+	}
+	return NewTArrayFrom(newSlice, a.mu.IsSafe())
+}
diff --git a/container/garray/garray_sorted_any.go b/container/garray/garray_sorted_any.go
index 3644933ae..00029bff0 100644
--- a/container/garray/garray_sorted_any.go
+++ b/container/garray/garray_sorted_any.go
@@ -7,19 +7,11 @@
 package garray
 
 import (
-	"bytes"
 	"fmt"
-	"math"
 	"sort"
+	"sync"
 
-	"github.com/gogf/gf/v2/internal/deepcopy"
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/grand"
-	"github.com/gogf/gf/v2/util/gutil"
 )
 
 // SortedArray is a golang sorted array with rich features.
@@ -28,10 +20,17 @@ import (
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type SortedArray struct {
-	mu         rwmutex.RWMutex
-	array      []any
-	unique     bool               // Whether enable unique feature(false)
-	comparator func(a, b any) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b)
+	*SortedTArray[any]
+	once sync.Once
+}
+
+// lazyInit lazily initializes the array.
+func (a *SortedArray) lazyInit() {
+	a.once.Do(func() {
+		if a.SortedTArray == nil {
+			a.SortedTArray = NewSortedTArraySize[any](0, nil, false)
+		}
+	})
 }
 
 // NewSortedArray creates and returns an empty sorted array.
@@ -49,9 +48,7 @@ func NewSortedArray(comparator func(a, b any) int, safe ...bool) *SortedArray {
 // which is false in default.
 func NewSortedArraySize(cap int, comparator func(a, b any) int, safe ...bool) *SortedArray {
 	return &SortedArray{
-		mu:         rwmutex.Create(safe...),
-		array:      make([]any, 0, cap),
-		comparator: comparator,
+		SortedTArray: NewSortedTArraySize(cap, comparator, safe...),
 	}
 }
 
@@ -94,224 +91,111 @@ func NewSortedArrayFromCopy(array []any, comparator func(a, b any) int, safe ...
 // At returns the value by the specified index.
 // If the given `index` is out of range of the array, it returns `nil`.
 func (a *SortedArray) At(index int) (value any) {
-	value, _ = a.Get(index)
-	return
+	a.lazyInit()
+	return a.SortedTArray.At(index)
 }
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *SortedArray) SetArray(array []any) *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array = array
-	sort.Slice(a.array, func(i, j int) bool {
-		return a.getComparator()(a.array[i], a.array[j]) < 0
-	})
+	a.lazyInit()
+	a.SortedTArray.SetArray(array)
 	return a
 }
 
 // SetComparator sets/changes the comparator for sorting.
 // It resorts the array as the comparator is changed.
 func (a *SortedArray) SetComparator(comparator func(a, b any) int) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.comparator = comparator
-	sort.Slice(a.array, func(i, j int) bool {
-		return a.getComparator()(a.array[i], a.array[j]) < 0
-	})
+	a.lazyInit()
+	a.SortedTArray.SetComparator(comparator)
 }
 
 // Sort sorts the array in increasing order.
 // The parameter `reverse` controls whether sort
 // in increasing order(default) or decreasing order
 func (a *SortedArray) Sort() *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	sort.Slice(a.array, func(i, j int) bool {
-		return a.getComparator()(a.array[i], a.array[j]) < 0
-	})
+	a.lazyInit()
+	a.SortedTArray.Sort()
 	return a
 }
 
 // Add adds one or multiple values to sorted array, the array always keeps sorted.
 // It's alias of function Append, see Append.
 func (a *SortedArray) Add(values ...any) *SortedArray {
-	return a.Append(values...)
+	a.lazyInit()
+	a.SortedTArray.Add(values...)
+	return a
 }
 
 // Append adds one or multiple values to sorted array, the array always keeps sorted.
 func (a *SortedArray) Append(values ...any) *SortedArray {
-	if len(values) == 0 {
-		return a
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		index, cmp := a.binSearch(value, false)
-		if a.unique && cmp == 0 {
-			continue
-		}
-		if index < 0 {
-			a.array = append(a.array, value)
-			continue
-		}
-		if cmp > 0 {
-			index++
-		}
-		a.array = append(a.array[:index], append([]any{value}, a.array[index:]...)...)
-	}
+	a.SortedTArray.Append(values...)
 	return a
 }
 
 // Get returns the value by the specified index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *SortedArray) Get(index int) (value any, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if index < 0 || index >= len(a.array) {
-		return nil, false
-	}
-	return a.array[index], true
+	a.lazyInit()
+	return a.SortedTArray.Get(index)
 }
 
 // Remove removes an item by index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *SortedArray) Remove(index int) (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(index)
-}
-
-// doRemoveWithoutLock removes an item by index without lock.
-func (a *SortedArray) doRemoveWithoutLock(index int) (value any, found bool) {
-	if index < 0 || index >= len(a.array) {
-		return nil, false
-	}
-	// Determine array boundaries when deleting to improve deletion efficiency.
-	if index == 0 {
-		value := a.array[0]
-		a.array = a.array[1:]
-		return value, true
-	} else if index == len(a.array)-1 {
-		value := a.array[index]
-		a.array = a.array[:index]
-		return value, true
-	}
-	// If it is a non-boundary delete,
-	// it will involve the creation of an array,
-	// then the deletion is less efficient.
-	value = a.array[index]
-	a.array = append(a.array[:index], a.array[index+1:]...)
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.Remove(index)
 }
 
 // RemoveValue removes an item by value.
 // It returns true if value is found in the array, or else false if not found.
 func (a *SortedArray) RemoveValue(value any) bool {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if i, r := a.binSearch(value, false); r == 0 {
-		_, res := a.doRemoveWithoutLock(i)
-		return res
-	}
-	return false
+	a.lazyInit()
+	return a.SortedTArray.RemoveValue(value)
 }
 
 // RemoveValues removes an item by `values`.
 func (a *SortedArray) RemoveValues(values ...any) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		if i, r := a.binSearch(value, false); r == 0 {
-			a.doRemoveWithoutLock(i)
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.RemoveValues(values...)
 }
 
 // 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 any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return nil, false
-	}
-	value = a.array[0]
-	a.array = a.array[1:]
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.PopLeft()
 }
 
 // PopRight pops and returns an item from the end of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedArray) PopRight() (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	index := len(a.array) - 1
-	if index < 0 {
-		return nil, false
-	}
-	value = a.array[index]
-	a.array = a.array[:index]
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.PopRight()
 }
 
 // PopRand randomly pops and return an item out of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedArray) PopRand() (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	a.lazyInit()
+	return a.SortedTArray.PopRand()
 }
 
 // PopRands randomly pops and returns `size` items out of array.
 func (a *SortedArray) PopRands(size int) []any {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		size = len(a.array)
-	}
-	array := make([]any, size)
-	for i := 0; i < size; i++ {
-		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.PopRands(size)
 }
 
 // PopLefts pops and returns `size` items from the beginning of array.
 func (a *SortedArray) PopLefts(size int) []any {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[0:size]
-	a.array = a.array[size:]
-	return value
+	a.lazyInit()
+	return a.SortedTArray.PopLefts(size)
 }
 
 // PopRights pops and returns `size` items from the end of array.
 func (a *SortedArray) PopRights(size int) []any {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	index := len(a.array) - size
-	if index <= 0 {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[index:]
-	a.array = a.array[:index]
-	return value
+	a.lazyInit()
+	return a.SortedTArray.PopRights(size)
 }
 
 // Range picks and returns items by range, like array[start:end].
@@ -322,26 +206,7 @@ func (a *SortedArray) PopRights(size int) []any {
 // If `end` is omitted, then the sequence will have everything from start up
 // until the end of the array.
 func (a *SortedArray) Range(start int, end ...int) []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	offsetEnd := len(a.array)
-	if len(end) > 0 && end[0] < offsetEnd {
-		offsetEnd = end[0]
-	}
-	if start > offsetEnd {
-		return nil
-	}
-	if start < 0 {
-		start = 0
-	}
-	array := ([]any)(nil)
-	if a.mu.IsSafe() {
-		array = make([]any, offsetEnd-start)
-		copy(array, a.array[start:offsetEnd])
-	} else {
-		array = a.array[start:offsetEnd]
-	}
-	return array
+	return a.SortedTArray.Range(start, end...)
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -358,194 +223,91 @@ func (a *SortedArray) Range(start int, end ...int) []any {
 //
 // Any possibility crossing the left border of array, it will fail.
 func (a *SortedArray) SubSlice(offset int, length ...int) []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	size := len(a.array)
-	if len(length) > 0 {
-		size = length[0]
-	}
-	if offset > len(a.array) {
-		return nil
-	}
-	if offset < 0 {
-		offset = len(a.array) + offset
-		if offset < 0 {
-			return nil
-		}
-	}
-	if size < 0 {
-		offset += size
-		size = -size
-		if offset < 0 {
-			return nil
-		}
-	}
-	end := offset + size
-	if end > len(a.array) {
-		end = len(a.array)
-		size = len(a.array) - offset
-	}
-	if a.mu.IsSafe() {
-		s := make([]any, size)
-		copy(s, a.array[offset:])
-		return s
-	} else {
-		return a.array[offset:end]
-	}
+	a.lazyInit()
+	return a.SortedTArray.SubSlice(offset, length...)
 }
 
 // Sum returns the sum of values in an array.
 func (a *SortedArray) Sum() (sum int) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		sum += gconv.Int(v)
-	}
-	return
+	a.lazyInit()
+	return a.SortedTArray.Sum()
 }
 
 // Len returns the length of array.
 func (a *SortedArray) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
+	a.lazyInit()
+	return a.SortedTArray.Len()
 }
 
 // Slice returns the underlying data of array.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (a *SortedArray) Slice() []any {
-	var array []any
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-		array = make([]any, len(a.array))
-		copy(array, a.array)
-	} else {
-		array = a.array
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Slice()
 }
 
 // Interfaces returns current array as []any.
 func (a *SortedArray) Interfaces() []any {
-	return a.Slice()
+	a.lazyInit()
+	return a.SortedTArray.Interfaces()
 }
 
 // Contains checks whether a value exists in the array.
 func (a *SortedArray) Contains(value any) bool {
-	return a.Search(value) != -1
+	a.lazyInit()
+	return a.SortedTArray.Contains(value)
 }
 
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 func (a *SortedArray) Search(value any) (index int) {
-	if i, r := a.binSearch(value, true); r == 0 {
-		return i
-	}
-	return -1
-}
-
-// Binary search.
-// It returns the last compared index and the result.
-// If `result` equals to 0, it means the value at `index` is equals to `value`.
-// If `result` lesser than 0, it means the value at `index` is lesser than `value`.
-// If `result` greater than 0, it means the value at `index` is greater than `value`.
-func (a *SortedArray) binSearch(value any, lock bool) (index int, result int) {
-	if lock {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-	}
-	if len(a.array) == 0 {
-		return -1, -2
-	}
-	min := 0
-	max := len(a.array) - 1
-	mid := 0
-	cmp := -2
-	for min <= max {
-		mid = min + (max-min)/2
-		cmp = a.getComparator()(value, a.array[mid])
-		switch {
-		case cmp < 0:
-			max = mid - 1
-		case cmp > 0:
-			min = mid + 1
-		default:
-			return mid, cmp
-		}
-	}
-	return mid, cmp
+	a.lazyInit()
+	return a.SortedTArray.Search(value)
 }
 
 // SetUnique sets unique mark to the array,
 // which means it does not contain any repeated items.
 // It also does unique check, remove all repeated items.
 func (a *SortedArray) SetUnique(unique bool) *SortedArray {
-	oldUnique := a.unique
-	a.unique = unique
-	if unique && oldUnique != unique {
-		a.Unique()
-	}
+	a.lazyInit()
+	a.SortedTArray.SetUnique(unique)
 	return a
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *SortedArray) Unique() *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return a
-	}
-	for i := 0; i < len(a.array)-1; {
-		if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
-			a.array = append(a.array[:i+1], a.array[i+2:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.Unique()
 	return a
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *SortedArray) Clone() (newArray *SortedArray) {
-	a.mu.RLock()
-	array := make([]any, len(a.array))
-	copy(array, a.array)
-	a.mu.RUnlock()
-	return NewSortedArrayFrom(array, a.comparator, a.mu.IsSafe())
+	a.lazyInit()
+	return &SortedArray{
+		SortedTArray: a.SortedTArray.Clone(),
+	}
 }
 
 // Clear deletes all items of current array.
 func (a *SortedArray) Clear() *SortedArray {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		a.array = make([]any, 0)
-	}
-	a.mu.Unlock()
+	a.lazyInit()
+	a.SortedTArray.Clear()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *SortedArray) LockFunc(f func(array []any)) *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-
-	// Keep the array always sorted.
-	defer sort.Slice(a.array, func(i, j int) bool {
-		return a.getComparator()(a.array[i], a.array[j]) < 0
-	})
-
-	f(a.array)
+	a.lazyInit()
+	a.SortedTArray.LockFunc(f)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *SortedArray) RLockFunc(f func(array []any)) *SortedArray {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	f(a.array)
+	a.lazyInit()
+	a.SortedTArray.RLockFunc(f)
 	return a
 }
 
@@ -561,104 +323,52 @@ func (a *SortedArray) Merge(array any) *SortedArray {
 // the size of each array is determined by `size`.
 // The last chunk may contain less than size elements.
 func (a *SortedArray) Chunk(size int) [][]any {
-	if size < 1 {
-		return nil
-	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	length := len(a.array)
-	chunks := int(math.Ceil(float64(length) / float64(size)))
-	var n [][]any
-	for i, end := 0, 0; chunks > 0; chunks-- {
-		end = (i + 1) * size
-		if end > length {
-			end = length
-		}
-		n = append(n, a.array[i*size:end])
-		i++
-	}
-	return n
+	a.lazyInit()
+	return a.SortedTArray.Chunk(size)
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *SortedArray) Rand() (value any, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return nil, false
-	}
-	return a.array[grand.Intn(len(a.array))], true
+	a.lazyInit()
+	return a.SortedTArray.Rand()
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *SortedArray) Rands(size int) []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	array := make([]any, size)
-	for i := 0; i < size; i++ {
-		array[i] = a.array[grand.Intn(len(a.array))]
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Rands(size)
 }
 
 // Join joins array elements with a string `glue`.
 func (a *SortedArray) Join(glue string) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return ""
-	}
-	buffer := bytes.NewBuffer(nil)
-	for k, v := range a.array {
-		buffer.WriteString(gconv.String(v))
-		if k != len(a.array)-1 {
-			buffer.WriteString(glue)
-		}
-	}
-	return buffer.String()
+	a.lazyInit()
+	return a.SortedTArray.Join(glue)
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *SortedArray) CountValues() map[any]int {
-	m := make(map[any]int)
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		m[v]++
-	}
-	return m
+	a.lazyInit()
+	return a.SortedTArray.CountValues()
 }
 
 // Iterator is alias of IteratorAsc.
 func (a *SortedArray) Iterator(f func(k int, v any) bool) {
-	a.IteratorAsc(f)
+	a.lazyInit()
+	a.SortedTArray.Iterator(f)
 }
 
 // IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *SortedArray) IteratorAsc(f func(k int, v any) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for k, v := range a.array {
-		if !f(k, v) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the array readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *SortedArray) IteratorDesc(f func(k int, v any) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for i := len(a.array) - 1; i >= 0; i-- {
-		if !f(i, a.array[i]) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.IteratorDesc(f)
 }
 
 // String returns current array as a string, which implements like json.Marshal does.
@@ -666,94 +376,35 @@ func (a *SortedArray) String() string {
 	if a == nil {
 		return ""
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	buffer := bytes.NewBuffer(nil)
-	buffer.WriteByte('[')
-	s := ""
-	for k, v := range a.array {
-		s = gconv.String(v)
-		if gstr.IsNumeric(s) {
-			buffer.WriteString(s)
-		} else {
-			buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
-		}
-		if k != len(a.array)-1 {
-			buffer.WriteByte(',')
-		}
-	}
-	buffer.WriteByte(']')
-	return buffer.String()
+	a.lazyInit()
+	return a.SortedTArray.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (a SortedArray) MarshalJSON() ([]byte, error) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return json.Marshal(a.array)
+	a.lazyInit()
+	return a.SortedTArray.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 // Note that the comparator is set as string comparator in default.
 func (a *SortedArray) UnmarshalJSON(b []byte) error {
-	if a.comparator == nil {
-		a.array = make([]any, 0)
-		a.comparator = gutil.ComparatorString
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
-		return err
-	}
-	if a.comparator != nil && a.array != nil {
-		sort.Slice(a.array, func(i, j int) bool {
-			return a.comparator(a.array[i], a.array[j]) < 0
-		})
-	}
-	return nil
+	a.lazyInit()
+	return a.SortedTArray.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
 // Note that the comparator is set as string comparator in default.
 func (a *SortedArray) UnmarshalValue(value any) (err error) {
-	if a.comparator == nil {
-		a.comparator = gutil.ComparatorString
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	switch value.(type) {
-	case string, []byte:
-		err = json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
-	default:
-		a.array = gconv.SliceAny(value)
-	}
-	if a.comparator != nil && a.array != nil {
-		sort.Slice(a.array, func(i, j int) bool {
-			return a.comparator(a.array[i], a.array[j]) < 0
-		})
-	}
-	return err
+	a.lazyInit()
+	return a.SortedTArray.UnmarshalValue(value)
 }
 
 // FilterNil removes all nil value of the array.
 func (a *SortedArray) FilterNil() *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if empty.IsNil(a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			break
-		}
-	}
-	for i := len(a.array) - 1; i >= 0; {
-		if empty.IsNil(a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.FilterNil()
 	return a
 }
 
@@ -761,78 +412,36 @@ func (a *SortedArray) FilterNil() *SortedArray {
 // It removes the element from array if callback function `filter` returns true,
 // it or else does nothing and continues iterating.
 func (a *SortedArray) Filter(filter func(index int, value any) 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++
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.Filter(filter)
 	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.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if empty.IsEmpty(a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			break
-		}
-	}
-	for i := len(a.array) - 1; i >= 0; {
-		if empty.IsEmpty(a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.FilterEmpty()
 	return a
 }
 
 // Walk applies a user supplied function `f` to every item of array.
 func (a *SortedArray) Walk(f func(value any) any) *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	// Keep the array always sorted.
-	defer sort.Slice(a.array, func(i, j int) bool {
-		return a.getComparator()(a.array[i], a.array[j]) < 0
-	})
-	for i, v := range a.array {
-		a.array[i] = f(v)
-	}
+	a.lazyInit()
+	a.SortedTArray.Walk(f)
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *SortedArray) IsEmpty() bool {
-	return a.Len() == 0
-}
-
-// getComparator returns the comparator if it's previously set,
-// or else it panics.
-func (a *SortedArray) getComparator() func(a, b any) int {
-	if a.comparator == nil {
-		panic("comparator is missing for sorted array")
-	}
-	return a.comparator
+	a.lazyInit()
+	return a.SortedTArray.IsEmpty()
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *SortedArray) DeepCopy() any {
-	if a == nil {
-		return nil
+	a.lazyInit()
+	return &SortedArray{
+		SortedTArray: a.SortedTArray.DeepCopy().(*SortedTArray[any]),
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	newSlice := make([]any, len(a.array))
-	for i, v := range a.array {
-		newSlice[i] = deepcopy.Copy(v)
-	}
-	return NewSortedArrayFrom(newSlice, a.comparator, a.mu.IsSafe())
 }
diff --git a/container/garray/garray_sorted_int.go b/container/garray/garray_sorted_int.go
index 48d8469b1..a4a27a06e 100644
--- a/container/garray/garray_sorted_int.go
+++ b/container/garray/garray_sorted_int.go
@@ -7,15 +7,10 @@
 package garray
 
 import (
-	"bytes"
 	"fmt"
-	"math"
-	"sort"
+	"sync"
 
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/grand"
 )
 
 // SortedIntArray is a golang sorted int array with rich features.
@@ -24,10 +19,18 @@ import (
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type SortedIntArray struct {
-	mu         rwmutex.RWMutex
-	array      []int
-	unique     bool               // Whether enable unique feature(false)
-	comparator func(a, b int) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b)
+	*SortedTArray[int]
+	once sync.Once
+}
+
+// lazyInit lazily initializes the array.
+func (a *SortedIntArray) lazyInit() {
+	a.once.Do(func() {
+		if a.SortedTArray == nil {
+			a.SortedTArray = NewSortedTArraySize(0, defaultComparatorInt, false)
+			a.SetSorter(quickSortInt)
+		}
+	})
 }
 
 // NewSortedIntArray creates and returns an empty sorted array.
@@ -49,10 +52,10 @@ func NewSortedIntArrayComparator(comparator func(a, b int) int, safe ...bool) *S
 // The parameter `safe` is used to specify whether using array in concurrent-safety,
 // which is false in default.
 func NewSortedIntArraySize(cap int, safe ...bool) *SortedIntArray {
+	a := NewSortedTArraySize(cap, defaultComparatorInt, safe...)
+	a.SetSorter(quickSortInt)
 	return &SortedIntArray{
-		mu:         rwmutex.Create(safe...),
-		array:      make([]int, 0, cap),
-		comparator: defaultComparatorInt,
+		SortedTArray: a,
 	}
 }
 
@@ -77,7 +80,7 @@ func NewSortedIntArrayRange(start, end, step int, safe ...bool) *SortedIntArray
 func NewSortedIntArrayFrom(array []int, safe ...bool) *SortedIntArray {
 	a := NewSortedIntArraySize(0, safe...)
 	a.array = array
-	sort.Ints(a.array)
+	a.sorter(a.array, defaultComparatorInt)
 	return a
 }
 
@@ -93,16 +96,14 @@ func NewSortedIntArrayFromCopy(array []int, safe ...bool) *SortedIntArray {
 // At returns the value by the specified index.
 // If the given `index` is out of range of the array, it returns `0`.
 func (a *SortedIntArray) At(index int) (value int) {
-	value, _ = a.Get(index)
-	return
+	a.lazyInit()
+	return a.SortedTArray.At(index)
 }
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *SortedIntArray) SetArray(array []int) *SortedIntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array = array
-	quickSortInt(a.array, a.getComparator())
+	a.lazyInit()
+	a.SortedTArray.SetArray(array)
 	return a
 }
 
@@ -110,200 +111,95 @@ func (a *SortedIntArray) SetArray(array []int) *SortedIntArray {
 // The parameter `reverse` controls whether sort
 // in increasing order(default) or decreasing order.
 func (a *SortedIntArray) Sort() *SortedIntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	quickSortInt(a.array, a.getComparator())
+	a.lazyInit()
+	a.SortedTArray.Sort()
 	return a
 }
 
 // Add adds one or multiple values to sorted array, the array always keeps sorted.
 // It's alias of function Append, see Append.
 func (a *SortedIntArray) Add(values ...int) *SortedIntArray {
+	a.lazyInit()
 	return a.Append(values...)
 }
 
 // Append adds one or multiple values to sorted array, the array always keeps sorted.
 func (a *SortedIntArray) Append(values ...int) *SortedIntArray {
-	if len(values) == 0 {
-		return a
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		index, cmp := a.binSearch(value, false)
-		if a.unique && cmp == 0 {
-			continue
-		}
-		if index < 0 {
-			a.array = append(a.array, value)
-			continue
-		}
-		if cmp > 0 {
-			index++
-		}
-		rear := append([]int{}, a.array[index:]...)
-		a.array = append(a.array[0:index], value)
-		a.array = append(a.array, rear...)
-	}
+	a.lazyInit()
+	a.SortedTArray.Append(values...)
 	return a
 }
 
 // Get returns the value by the specified index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *SortedIntArray) Get(index int) (value int, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if index < 0 || index >= len(a.array) {
-		return 0, false
-	}
-	return a.array[index], true
+	a.lazyInit()
+	return a.SortedTArray.Get(index)
 }
 
 // Remove removes an item by index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *SortedIntArray) Remove(index int) (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(index)
-}
-
-// doRemoveWithoutLock removes an item by index without lock.
-func (a *SortedIntArray) doRemoveWithoutLock(index int) (value int, found bool) {
-	if index < 0 || index >= len(a.array) {
-		return 0, false
-	}
-	// Determine array boundaries when deleting to improve deletion efficiency.
-	if index == 0 {
-		value := a.array[0]
-		a.array = a.array[1:]
-		return value, true
-	} else if index == len(a.array)-1 {
-		value := a.array[index]
-		a.array = a.array[:index]
-		return value, true
-	}
-	// If it is a non-boundary delete,
-	// it will involve the creation of an array,
-	// then the deletion is less efficient.
-	value = a.array[index]
-	a.array = append(a.array[:index], a.array[index+1:]...)
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.Remove(index)
 }
 
 // RemoveValue removes an item by value.
 // It returns true if value is found in the array, or else false if not found.
 func (a *SortedIntArray) RemoveValue(value int) bool {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if i, r := a.binSearch(value, false); r == 0 {
-		_, res := a.doRemoveWithoutLock(i)
-		return res
-	}
-	return false
+	a.lazyInit()
+	return a.SortedTArray.RemoveValue(value)
 }
 
 // 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)
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.RemoveValues(values...)
 }
 
 // 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) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return 0, false
-	}
-	value = a.array[0]
-	a.array = a.array[1:]
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.PopLeft()
 }
 
 // PopRight pops and returns an item from the end of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedIntArray) PopRight() (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	index := len(a.array) - 1
-	if index < 0 {
-		return 0, false
-	}
-	value = a.array[index]
-	a.array = a.array[:index]
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.PopRight()
 }
 
 // PopRand randomly pops and return an item out of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedIntArray) PopRand() (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	a.lazyInit()
+	return a.SortedTArray.PopRand()
 }
 
 // PopRands randomly pops and returns `size` items out of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *SortedIntArray) PopRands(size int) []int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		size = len(a.array)
-	}
-	array := make([]int, size)
-	for i := 0; i < size; i++ {
-		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.PopRands(size)
 }
 
 // PopLefts pops and returns `size` items from the beginning of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *SortedIntArray) PopLefts(size int) []int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[0:size]
-	a.array = a.array[size:]
-	return value
+	a.lazyInit()
+	return a.SortedTArray.PopLefts(size)
 }
 
 // PopRights pops and returns `size` items from the end of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *SortedIntArray) PopRights(size int) []int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	index := len(a.array) - size
-	if index <= 0 {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[index:]
-	a.array = a.array[:index]
-	return value
+	a.lazyInit()
+	return a.SortedTArray.PopRights(size)
 }
 
 // Range picks and returns items by range, like array[start:end].
@@ -314,26 +210,8 @@ func (a *SortedIntArray) PopRights(size int) []int {
 // If `end` is omitted, then the sequence will have everything from start up
 // until the end of the array.
 func (a *SortedIntArray) Range(start int, end ...int) []int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	offsetEnd := len(a.array)
-	if len(end) > 0 && end[0] < offsetEnd {
-		offsetEnd = end[0]
-	}
-	if start > offsetEnd {
-		return nil
-	}
-	if start < 0 {
-		start = 0
-	}
-	array := ([]int)(nil)
-	if a.mu.IsSafe() {
-		array = make([]int, offsetEnd-start)
-		copy(array, a.array[start:offsetEnd])
-	} else {
-		array = a.array[start:offsetEnd]
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Range(start, end...)
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -350,194 +228,91 @@ func (a *SortedIntArray) Range(start int, end ...int) []int {
 //
 // Any possibility crossing the left border of array, it will fail.
 func (a *SortedIntArray) SubSlice(offset int, length ...int) []int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	size := len(a.array)
-	if len(length) > 0 {
-		size = length[0]
-	}
-	if offset > len(a.array) {
-		return nil
-	}
-	if offset < 0 {
-		offset = len(a.array) + offset
-		if offset < 0 {
-			return nil
-		}
-	}
-	if size < 0 {
-		offset += size
-		size = -size
-		if offset < 0 {
-			return nil
-		}
-	}
-	end := offset + size
-	if end > len(a.array) {
-		end = len(a.array)
-		size = len(a.array) - offset
-	}
-	if a.mu.IsSafe() {
-		s := make([]int, size)
-		copy(s, a.array[offset:])
-		return s
-	} else {
-		return a.array[offset:end]
-	}
+	a.lazyInit()
+	return a.SortedTArray.SubSlice(offset, length...)
 }
 
 // Len returns the length of array.
 func (a *SortedIntArray) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
+	a.lazyInit()
+	return a.SortedTArray.Len()
 }
 
 // Sum returns the sum of values in an array.
 func (a *SortedIntArray) Sum() (sum int) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		sum += v
-	}
-	return
+	a.lazyInit()
+	return a.SortedTArray.Sum()
 }
 
 // Slice returns the underlying data of array.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (a *SortedIntArray) Slice() []int {
-	array := ([]int)(nil)
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-		array = make([]int, len(a.array))
-		copy(array, a.array)
-	} else {
-		array = a.array
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Slice()
 }
 
 // Interfaces returns current array as []any.
 func (a *SortedIntArray) Interfaces() []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	array := make([]any, len(a.array))
-	for k, v := range a.array {
-		array[k] = v
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Interfaces()
 }
 
 // Contains checks whether a value exists in the array.
 func (a *SortedIntArray) Contains(value int) bool {
-	return a.Search(value) != -1
+	a.lazyInit()
+	return a.SortedTArray.Contains(value)
 }
 
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 func (a *SortedIntArray) Search(value int) (index int) {
-	if i, r := a.binSearch(value, true); r == 0 {
-		return i
-	}
-	return -1
-}
-
-// Binary search.
-// It returns the last compared index and the result.
-// If `result` equals to 0, it means the value at `index` is equals to `value`.
-// If `result` lesser than 0, it means the value at `index` is lesser than `value`.
-// If `result` greater than 0, it means the value at `index` is greater than `value`.
-func (a *SortedIntArray) binSearch(value int, lock bool) (index int, result int) {
-	if lock {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-	}
-	if len(a.array) == 0 {
-		return -1, -2
-	}
-	min := 0
-	max := len(a.array) - 1
-	mid := 0
-	cmp := -2
-	for min <= max {
-		mid = min + int((max-min)/2)
-		cmp = a.getComparator()(value, a.array[mid])
-		switch {
-		case cmp < 0:
-			max = mid - 1
-		case cmp > 0:
-			min = mid + 1
-		default:
-			return mid, cmp
-		}
-	}
-	return mid, cmp
+	a.lazyInit()
+	return a.SortedTArray.Search(value)
 }
 
 // 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.
 func (a *SortedIntArray) SetUnique(unique bool) *SortedIntArray {
-	oldUnique := a.unique
-	a.unique = unique
-	if unique && oldUnique != unique {
-		a.Unique()
-	}
+	a.lazyInit()
+	a.SortedTArray.SetUnique(unique)
 	return a
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *SortedIntArray) Unique() *SortedIntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return a
-	}
-	for i := 0; i < len(a.array)-1; {
-		if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
-			a.array = append(a.array[:i+1], a.array[i+2:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.Unique()
 	return a
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *SortedIntArray) Clone() (newArray *SortedIntArray) {
-	a.mu.RLock()
-	array := make([]int, len(a.array))
-	copy(array, a.array)
-	a.mu.RUnlock()
-	return NewSortedIntArrayFrom(array, a.mu.IsSafe())
+	a.lazyInit()
+	return &SortedIntArray{
+		SortedTArray: a.SortedTArray.Clone(),
+	}
 }
 
 // Clear deletes all items of current array.
 func (a *SortedIntArray) Clear() *SortedIntArray {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		a.array = make([]int, 0)
-	}
-	a.mu.Unlock()
+	a.lazyInit()
+	a.SortedTArray.Clear()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *SortedIntArray) LockFunc(f func(array []int)) *SortedIntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	f(a.array)
+	a.lazyInit()
+	a.SortedTArray.LockFunc(f)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	f(a.array)
+	a.lazyInit()
+	a.SortedTArray.RLockFunc(f)
 	return a
 }
 
@@ -546,6 +321,7 @@ func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray {
 // The difference between Merge and Append is Append supports only specified slice type,
 // but Merge supports more parameter types.
 func (a *SortedIntArray) Merge(array any) *SortedIntArray {
+	a.lazyInit()
 	return a.Add(gconv.Ints(array)...)
 }
 
@@ -553,104 +329,52 @@ func (a *SortedIntArray) Merge(array any) *SortedIntArray {
 // the size of each array is determined by `size`.
 // The last chunk may contain less than size elements.
 func (a *SortedIntArray) Chunk(size int) [][]int {
-	if size < 1 {
-		return nil
-	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	length := len(a.array)
-	chunks := int(math.Ceil(float64(length) / float64(size)))
-	var n [][]int
-	for i, end := 0, 0; chunks > 0; chunks-- {
-		end = (i + 1) * size
-		if end > length {
-			end = length
-		}
-		n = append(n, a.array[i*size:end])
-		i++
-	}
-	return n
+	a.lazyInit()
+	return a.SortedTArray.Chunk(size)
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *SortedIntArray) Rand() (value int, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return 0, false
-	}
-	return a.array[grand.Intn(len(a.array))], true
+	a.lazyInit()
+	return a.SortedTArray.Rand()
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *SortedIntArray) Rands(size int) []int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	array := make([]int, size)
-	for i := 0; i < size; i++ {
-		array[i] = a.array[grand.Intn(len(a.array))]
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Rands(size)
 }
 
 // Join joins array elements with a string `glue`.
 func (a *SortedIntArray) Join(glue string) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return ""
-	}
-	buffer := bytes.NewBuffer(nil)
-	for k, v := range a.array {
-		buffer.WriteString(gconv.String(v))
-		if k != len(a.array)-1 {
-			buffer.WriteString(glue)
-		}
-	}
-	return buffer.String()
+	a.lazyInit()
+	return a.SortedTArray.Join(glue)
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *SortedIntArray) CountValues() map[int]int {
-	m := make(map[int]int)
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		m[v]++
-	}
-	return m
+	a.lazyInit()
+	return a.SortedTArray.CountValues()
 }
 
 // Iterator is alias of IteratorAsc.
 func (a *SortedIntArray) Iterator(f func(k int, v int) bool) {
-	a.IteratorAsc(f)
+	a.lazyInit()
+	a.SortedTArray.Iterator(f)
 }
 
 // IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *SortedIntArray) IteratorAsc(f func(k int, v int) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for k, v := range a.array {
-		if !f(k, v) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the array readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *SortedIntArray) IteratorDesc(f func(k int, v int) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for i := len(a.array) - 1; i >= 0; i-- {
-		if !f(i, a.array[i]) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.IteratorDesc(f)
 }
 
 // String returns current array as a string, which implements like json.Marshal does.
@@ -658,73 +382,64 @@ func (a *SortedIntArray) String() string {
 	if a == nil {
 		return ""
 	}
+	a.lazyInit()
 	return "[" + a.Join(",") + "]"
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (a SortedIntArray) MarshalJSON() ([]byte, error) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return json.Marshal(a.array)
+	a.lazyInit()
+	return a.SortedTArray.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *SortedIntArray) UnmarshalJSON(b []byte) error {
-	if a.comparator == nil {
-		a.array = make([]int, 0)
+	a.lazyInit()
+	if a.comparator == nil || a.sorter == nil {
 		a.comparator = defaultComparatorInt
+		a.sorter = quickSortInt
+		a.array = make([]int, 0)
 	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
-		return err
-	}
-	if a.array != nil {
-		sort.Ints(a.array)
-	}
-	return nil
+
+	return a.SortedTArray.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
 func (a *SortedIntArray) UnmarshalValue(value any) (err error) {
-	if a.comparator == nil {
+	a.lazyInit()
+	if a.comparator == nil || a.sorter == nil {
 		a.comparator = defaultComparatorInt
+		a.sorter = quickSortInt
 	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	switch value.(type) {
-	case string, []byte:
-		err = json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
-	default:
-		a.array = gconv.SliceInt(value)
-	}
-	if a.array != nil {
-		sort.Ints(a.array)
-	}
-	return err
+
+	return a.SortedTArray.UnmarshalValue(value)
 }
 
 // Filter iterates array and filters elements using custom callback function.
 // It removes the element from array if callback function `filter` returns true,
 // it or else does nothing and continues iterating.
 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++
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.Filter(filter)
 	return a
 }
 
 // FilterEmpty removes all zero value of the array.
 func (a *SortedIntArray) FilterEmpty() *SortedIntArray {
+	a.lazyInit()
 	a.mu.Lock()
 	defer a.mu.Unlock()
+
+	if len(a.array) == 0 {
+		return a
+	}
+
+	if a.array[0] != 0 && a.array[len(a.array)-1] != 0 {
+		a.SortedTArray.FilterEmpty()
+		return a
+	}
+
 	for i := 0; i < len(a.array); {
 		if a.array[i] == 0 {
 			a.array = append(a.array[:i], a.array[i+1:]...)
@@ -735,6 +450,7 @@ func (a *SortedIntArray) FilterEmpty() *SortedIntArray {
 	for i := len(a.array) - 1; i >= 0; {
 		if a.array[i] == 0 {
 			a.array = append(a.array[:i], a.array[i+1:]...)
+			i--
 		} else {
 			break
 		}
@@ -744,40 +460,21 @@ func (a *SortedIntArray) FilterEmpty() *SortedIntArray {
 
 // Walk applies a user supplied function `f` to every item of array.
 func (a *SortedIntArray) Walk(f func(value int) int) *SortedIntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-
-	// Keep the array always sorted.
-	defer quickSortInt(a.array, a.getComparator())
-
-	for i, v := range a.array {
-		a.array[i] = f(v)
-	}
+	a.lazyInit()
+	a.SortedTArray.Walk(f)
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *SortedIntArray) IsEmpty() bool {
-	return a.Len() == 0
-}
-
-// getComparator returns the comparator if it's previously set,
-// or else it returns a default comparator.
-func (a *SortedIntArray) getComparator() func(a, b int) int {
-	if a.comparator == nil {
-		return defaultComparatorInt
-	}
-	return a.comparator
+	a.lazyInit()
+	return a.SortedTArray.IsEmpty()
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *SortedIntArray) DeepCopy() any {
-	if a == nil {
-		return nil
+	a.lazyInit()
+	return &SortedIntArray{
+		SortedTArray: a.SortedTArray.DeepCopy().(*SortedTArray[int]),
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	newSlice := make([]int, len(a.array))
-	copy(newSlice, a.array)
-	return NewSortedIntArrayFrom(newSlice, a.mu.IsSafe())
 }
diff --git a/container/garray/garray_sorted_str.go b/container/garray/garray_sorted_str.go
index 6a50ae24c..e4d57188e 100644
--- a/container/garray/garray_sorted_str.go
+++ b/container/garray/garray_sorted_str.go
@@ -8,15 +8,11 @@ package garray
 
 import (
 	"bytes"
-	"math"
-	"sort"
 	"strings"
+	"sync"
 
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/grand"
 )
 
 // SortedStrArray is a golang sorted string array with rich features.
@@ -25,10 +21,18 @@ import (
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type SortedStrArray struct {
-	mu         rwmutex.RWMutex
-	array      []string
-	unique     bool                  // Whether enable unique feature(false)
-	comparator func(a, b string) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b)
+	*SortedTArray[string]
+	once sync.Once
+}
+
+// lazyInit lazily initializes the array.
+func (a *SortedStrArray) lazyInit() {
+	a.once.Do(func() {
+		if a.SortedTArray == nil {
+			a.SortedTArray = NewSortedTArraySize(0, defaultComparatorStr, false)
+			a.SetSorter(quickSortStr)
+		}
+	})
 }
 
 // NewSortedStrArray creates and returns an empty sorted array.
@@ -50,10 +54,10 @@ func NewSortedStrArrayComparator(comparator func(a, b string) int, safe ...bool)
 // The parameter `safe` is used to specify whether using array in concurrent-safety,
 // which is false in default.
 func NewSortedStrArraySize(cap int, safe ...bool) *SortedStrArray {
+	a := NewSortedTArraySize(cap, defaultComparatorStr, safe...)
+	a.SetSorter(quickSortStr)
 	return &SortedStrArray{
-		mu:         rwmutex.Create(safe...),
-		array:      make([]string, 0, cap),
-		comparator: defaultComparatorStr,
+		SortedTArray: a,
 	}
 }
 
@@ -78,218 +82,112 @@ func NewSortedStrArrayFromCopy(array []string, safe ...bool) *SortedStrArray {
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *SortedStrArray) SetArray(array []string) *SortedStrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array = array
-	quickSortStr(a.array, a.getComparator())
+	a.lazyInit()
+	a.SortedTArray.SetArray(array)
 	return a
 }
 
 // At returns the value by the specified index.
 // If the given `index` is out of range of the array, it returns an empty string.
 func (a *SortedStrArray) At(index int) (value string) {
-	value, _ = a.Get(index)
-	return
+	a.lazyInit()
+	return a.SortedTArray.At(index)
 }
 
 // Sort sorts the array in increasing order.
 // The parameter `reverse` controls whether sort
 // in increasing order(default) or decreasing order.
 func (a *SortedStrArray) Sort() *SortedStrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	quickSortStr(a.array, a.getComparator())
+	a.lazyInit()
+	a.SortedTArray.Sort()
 	return a
 }
 
 // Add adds one or multiple values to sorted array, the array always keeps sorted.
 // It's alias of function Append, see Append.
 func (a *SortedStrArray) Add(values ...string) *SortedStrArray {
-	return a.Append(values...)
+	a.lazyInit()
+	a.SortedTArray.Add(values...)
+	return a
 }
 
 // Append adds one or multiple values to sorted array, the array always keeps sorted.
 func (a *SortedStrArray) Append(values ...string) *SortedStrArray {
-	if len(values) == 0 {
-		return a
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		index, cmp := a.binSearch(value, false)
-		if a.unique && cmp == 0 {
-			continue
-		}
-		if index < 0 {
-			a.array = append(a.array, value)
-			continue
-		}
-		if cmp > 0 {
-			index++
-		}
-		rear := append([]string{}, a.array[index:]...)
-		a.array = append(a.array[0:index], value)
-		a.array = append(a.array, rear...)
-	}
+	a.lazyInit()
+	a.SortedTArray.Append(values...)
 	return a
 }
 
 // Get returns the value by the specified index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *SortedStrArray) Get(index int) (value string, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if index < 0 || index >= len(a.array) {
-		return "", false
-	}
-	return a.array[index], true
+	a.lazyInit()
+	return a.SortedTArray.Get(index)
 }
 
 // Remove removes an item by index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *SortedStrArray) Remove(index int) (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(index)
-}
-
-// doRemoveWithoutLock removes an item by index without lock.
-func (a *SortedStrArray) doRemoveWithoutLock(index int) (value string, found bool) {
-	if index < 0 || index >= len(a.array) {
-		return "", false
-	}
-	// Determine array boundaries when deleting to improve deletion efficiency.
-	if index == 0 {
-		value := a.array[0]
-		a.array = a.array[1:]
-		return value, true
-	} else if index == len(a.array)-1 {
-		value := a.array[index]
-		a.array = a.array[:index]
-		return value, true
-	}
-	// If it is a non-boundary delete,
-	// it will involve the creation of an array,
-	// then the deletion is less efficient.
-	value = a.array[index]
-	a.array = append(a.array[:index], a.array[index+1:]...)
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.Remove(index)
 }
 
 // RemoveValue removes an item by value.
 // It returns true if value is found in the array, or else false if not found.
 func (a *SortedStrArray) RemoveValue(value string) bool {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if i, r := a.binSearch(value, false); r == 0 {
-		_, res := a.doRemoveWithoutLock(i)
-		return res
-	}
-	return false
+	a.lazyInit()
+	return a.SortedTArray.RemoveValue(value)
 }
 
 // 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)
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.RemoveValues(values...)
 }
 
 // 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) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return "", false
-	}
-	value = a.array[0]
-	a.array = a.array[1:]
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.PopLeft()
 }
 
 // PopRight pops and returns an item from the end of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedStrArray) PopRight() (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	index := len(a.array) - 1
-	if index < 0 {
-		return "", false
-	}
-	value = a.array[index]
-	a.array = a.array[:index]
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.PopRight()
 }
 
 // PopRand randomly pops and return an item out of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedStrArray) PopRand() (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	a.lazyInit()
+	return a.SortedTArray.PopRand()
 }
 
 // PopRands randomly pops and returns `size` items out of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *SortedStrArray) PopRands(size int) []string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		size = len(a.array)
-	}
-	array := make([]string, size)
-	for i := 0; i < size; i++ {
-		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.PopRands(size)
 }
 
 // PopLefts pops and returns `size` items from the beginning of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *SortedStrArray) PopLefts(size int) []string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[0:size]
-	a.array = a.array[size:]
-	return value
+	a.lazyInit()
+	return a.SortedTArray.PopLefts(size)
 }
 
 // PopRights pops and returns `size` items from the end of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *SortedStrArray) PopRights(size int) []string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	index := len(a.array) - size
-	if index <= 0 {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[index:]
-	a.array = a.array[:index]
-	return value
+	a.lazyInit()
+	return a.SortedTArray.PopRights(size)
 }
 
 // Range picks and returns items by range, like array[start:end].
@@ -300,26 +198,8 @@ func (a *SortedStrArray) PopRights(size int) []string {
 // If `end` is omitted, then the sequence will have everything from start up
 // until the end of the array.
 func (a *SortedStrArray) Range(start int, end ...int) []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	offsetEnd := len(a.array)
-	if len(end) > 0 && end[0] < offsetEnd {
-		offsetEnd = end[0]
-	}
-	if start > offsetEnd {
-		return nil
-	}
-	if start < 0 {
-		start = 0
-	}
-	array := ([]string)(nil)
-	if a.mu.IsSafe() {
-		array = make([]string, offsetEnd-start)
-		copy(array, a.array[start:offsetEnd])
-	} else {
-		array = a.array[start:offsetEnd]
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Range(start, end...)
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -336,95 +216,46 @@ func (a *SortedStrArray) Range(start int, end ...int) []string {
 //
 // Any possibility crossing the left border of array, it will fail.
 func (a *SortedStrArray) SubSlice(offset int, length ...int) []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	size := len(a.array)
-	if len(length) > 0 {
-		size = length[0]
-	}
-	if offset > len(a.array) {
-		return nil
-	}
-	if offset < 0 {
-		offset = len(a.array) + offset
-		if offset < 0 {
-			return nil
-		}
-	}
-	if size < 0 {
-		offset += size
-		size = -size
-		if offset < 0 {
-			return nil
-		}
-	}
-	end := offset + size
-	if end > len(a.array) {
-		end = len(a.array)
-		size = len(a.array) - offset
-	}
-	if a.mu.IsSafe() {
-		s := make([]string, size)
-		copy(s, a.array[offset:])
-		return s
-	} else {
-		return a.array[offset:end]
-	}
+	a.lazyInit()
+	return a.SortedTArray.SubSlice(offset, length...)
 }
 
 // Sum returns the sum of values in an array.
 func (a *SortedStrArray) Sum() (sum int) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		sum += gconv.Int(v)
-	}
-	return
+	a.lazyInit()
+	return a.SortedTArray.Sum()
 }
 
 // Len returns the length of array.
 func (a *SortedStrArray) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
+	a.lazyInit()
+	return a.SortedTArray.Len()
 }
 
 // Slice returns the underlying data of array.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (a *SortedStrArray) Slice() []string {
-	array := ([]string)(nil)
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-		array = make([]string, len(a.array))
-		copy(array, a.array)
-	} else {
-		array = a.array
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Slice()
 }
 
 // Interfaces returns current array as []any.
 func (a *SortedStrArray) Interfaces() []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	array := make([]any, len(a.array))
-	for k, v := range a.array {
-		array[k] = v
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Interfaces()
 }
 
 // Contains checks whether a value exists in the array.
 func (a *SortedStrArray) Contains(value string) bool {
-	return a.Search(value) != -1
+	a.lazyInit()
+	return a.SortedTArray.Contains(value)
 }
 
 // ContainsI checks whether a value exists in the array with case-insensitively.
 // Note that it internally iterates the whole array to do the comparison with case-insensitively.
 func (a *SortedStrArray) ContainsI(value string) bool {
+	a.lazyInit()
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	if len(a.array) == 0 {
@@ -441,105 +272,52 @@ func (a *SortedStrArray) ContainsI(value string) bool {
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 func (a *SortedStrArray) Search(value string) (index int) {
-	if i, r := a.binSearch(value, true); r == 0 {
-		return i
-	}
-	return -1
-}
-
-// Binary search.
-// It returns the last compared index and the result.
-// If `result` equals to 0, it means the value at `index` is equals to `value`.
-// If `result` lesser than 0, it means the value at `index` is lesser than `value`.
-// If `result` greater than 0, it means the value at `index` is greater than `value`.
-func (a *SortedStrArray) binSearch(value string, lock bool) (index int, result int) {
-	if lock {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-	}
-	if len(a.array) == 0 {
-		return -1, -2
-	}
-	min := 0
-	max := len(a.array) - 1
-	mid := 0
-	cmp := -2
-	for min <= max {
-		mid = min + int((max-min)/2)
-		cmp = a.getComparator()(value, a.array[mid])
-		switch {
-		case cmp < 0:
-			max = mid - 1
-		case cmp > 0:
-			min = mid + 1
-		default:
-			return mid, cmp
-		}
-	}
-	return mid, cmp
+	a.lazyInit()
+	return a.SortedTArray.Search(value)
 }
 
 // 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.
 func (a *SortedStrArray) SetUnique(unique bool) *SortedStrArray {
-	oldUnique := a.unique
-	a.unique = unique
-	if unique && oldUnique != unique {
-		a.Unique()
-	}
+	a.lazyInit()
+	a.SortedTArray.SetUnique(unique)
 	return a
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *SortedStrArray) Unique() *SortedStrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return a
-	}
-	for i := 0; i < len(a.array)-1; {
-		if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
-			a.array = append(a.array[:i+1], a.array[i+2:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.Unique()
 	return a
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *SortedStrArray) Clone() (newArray *SortedStrArray) {
-	a.mu.RLock()
-	array := make([]string, len(a.array))
-	copy(array, a.array)
-	a.mu.RUnlock()
-	return NewSortedStrArrayFrom(array, a.mu.IsSafe())
+	a.lazyInit()
+	return &SortedStrArray{
+		SortedTArray: a.SortedTArray.Clone(),
+	}
 }
 
 // Clear deletes all items of current array.
 func (a *SortedStrArray) Clear() *SortedStrArray {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		a.array = make([]string, 0)
-	}
-	a.mu.Unlock()
+	a.lazyInit()
+	a.SortedTArray.Clear()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *SortedStrArray) LockFunc(f func(array []string)) *SortedStrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	f(a.array)
+	a.lazyInit()
+	a.SortedTArray.LockFunc(f)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *SortedStrArray) RLockFunc(f func(array []string)) *SortedStrArray {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	f(a.array)
+	a.lazyInit()
+	a.SortedTArray.RLockFunc(f)
 	return a
 }
 
@@ -548,6 +326,7 @@ func (a *SortedStrArray) RLockFunc(f func(array []string)) *SortedStrArray {
 // The difference between Merge and Append is Append supports only specified slice type,
 // but Merge supports more parameter types.
 func (a *SortedStrArray) Merge(array any) *SortedStrArray {
+	a.lazyInit()
 	return a.Add(gconv.Strings(array)...)
 }
 
@@ -555,104 +334,52 @@ func (a *SortedStrArray) Merge(array any) *SortedStrArray {
 // the size of each array is determined by `size`.
 // The last chunk may contain less than size elements.
 func (a *SortedStrArray) Chunk(size int) [][]string {
-	if size < 1 {
-		return nil
-	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	length := len(a.array)
-	chunks := int(math.Ceil(float64(length) / float64(size)))
-	var n [][]string
-	for i, end := 0, 0; chunks > 0; chunks-- {
-		end = (i + 1) * size
-		if end > length {
-			end = length
-		}
-		n = append(n, a.array[i*size:end])
-		i++
-	}
-	return n
+	a.lazyInit()
+	return a.SortedTArray.Chunk(size)
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *SortedStrArray) Rand() (value string, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return "", false
-	}
-	return a.array[grand.Intn(len(a.array))], true
+	a.lazyInit()
+	return a.SortedTArray.Rand()
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *SortedStrArray) Rands(size int) []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	array := make([]string, size)
-	for i := 0; i < size; i++ {
-		array[i] = a.array[grand.Intn(len(a.array))]
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Rands(size)
 }
 
 // Join joins array elements with a string `glue`.
 func (a *SortedStrArray) Join(glue string) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return ""
-	}
-	buffer := bytes.NewBuffer(nil)
-	for k, v := range a.array {
-		buffer.WriteString(v)
-		if k != len(a.array)-1 {
-			buffer.WriteString(glue)
-		}
-	}
-	return buffer.String()
+	a.lazyInit()
+	return a.SortedTArray.Join(glue)
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *SortedStrArray) CountValues() map[string]int {
-	m := make(map[string]int)
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		m[v]++
-	}
-	return m
+	a.lazyInit()
+	return a.SortedTArray.CountValues()
 }
 
 // Iterator is alias of IteratorAsc.
 func (a *SortedStrArray) Iterator(f func(k int, v string) bool) {
-	a.IteratorAsc(f)
+	a.lazyInit()
+	a.SortedTArray.Iterator(f)
 }
 
 // IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *SortedStrArray) IteratorAsc(f func(k int, v string) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for k, v := range a.array {
-		if !f(k, v) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the array readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *SortedStrArray) IteratorDesc(f func(k int, v string) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for i := len(a.array) - 1; i >= 0; i-- {
-		if !f(i, a.array[i]) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.IteratorDesc(f)
 }
 
 // String returns current array as a string, which implements like json.Marshal does.
@@ -660,6 +387,7 @@ func (a *SortedStrArray) String() string {
 	if a == nil {
 		return ""
 	}
+	a.lazyInit()
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)
@@ -677,67 +405,56 @@ func (a *SortedStrArray) String() string {
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (a SortedStrArray) MarshalJSON() ([]byte, error) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return json.Marshal(a.array)
+	a.lazyInit()
+	return a.SortedTArray.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *SortedStrArray) UnmarshalJSON(b []byte) error {
-	if a.comparator == nil {
-		a.array = make([]string, 0)
+	a.lazyInit()
+	if a.comparator == nil || a.sorter == nil {
 		a.comparator = defaultComparatorStr
+		a.sorter = quickSortStr
+		a.array = make([]string, 0)
 	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
-		return err
-	}
-	if a.array != nil {
-		sort.Strings(a.array)
-	}
-	return nil
+	return a.SortedTArray.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
 func (a *SortedStrArray) UnmarshalValue(value any) (err error) {
-	if a.comparator == nil {
+	a.lazyInit()
+	if a.comparator == nil || a.sorter == nil {
 		a.comparator = defaultComparatorStr
+		a.sorter = quickSortStr
 	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	switch value.(type) {
-	case string, []byte:
-		err = json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
-	default:
-		a.array = gconv.SliceStr(value)
-	}
-	if a.array != nil {
-		sort.Strings(a.array)
-	}
-	return err
+
+	return a.SortedTArray.UnmarshalValue(value)
 }
 
 // Filter iterates array and filters elements using custom callback function.
 // It removes the element from array if callback function `filter` returns true,
 // it or else does nothing and continues iterating.
 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++
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.Filter(filter)
 	return a
 }
 
 // FilterEmpty removes all empty string value of the array.
 func (a *SortedStrArray) FilterEmpty() *SortedStrArray {
+	a.lazyInit()
 	a.mu.Lock()
 	defer a.mu.Unlock()
+
+	if len(a.array) == 0 {
+		return a
+	}
+
+	if a.array[0] != "" && a.array[len(a.array)-1] != "" {
+		a.SortedTArray.FilterEmpty()
+		return a
+	}
+
 	for i := 0; i < len(a.array); {
 		if a.array[i] == "" {
 			a.array = append(a.array[:i], a.array[i+1:]...)
@@ -748,6 +465,7 @@ func (a *SortedStrArray) FilterEmpty() *SortedStrArray {
 	for i := len(a.array) - 1; i >= 0; {
 		if a.array[i] == "" {
 			a.array = append(a.array[:i], a.array[i+1:]...)
+			i--
 		} else {
 			break
 		}
@@ -757,40 +475,21 @@ func (a *SortedStrArray) FilterEmpty() *SortedStrArray {
 
 // Walk applies a user supplied function `f` to every item of array.
 func (a *SortedStrArray) Walk(f func(value string) string) *SortedStrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-
-	// Keep the array always sorted.
-	defer quickSortStr(a.array, a.getComparator())
-
-	for i, v := range a.array {
-		a.array[i] = f(v)
-	}
+	a.lazyInit()
+	a.SortedTArray.Walk(f)
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *SortedStrArray) IsEmpty() bool {
-	return a.Len() == 0
-}
-
-// getComparator returns the comparator if it's previously set,
-// or else it returns a default comparator.
-func (a *SortedStrArray) getComparator() func(a, b string) int {
-	if a.comparator == nil {
-		return defaultComparatorStr
-	}
-	return a.comparator
+	a.lazyInit()
+	return a.SortedTArray.IsEmpty()
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *SortedStrArray) DeepCopy() any {
-	if a == nil {
-		return nil
+	a.lazyInit()
+	return &SortedStrArray{
+		SortedTArray: a.SortedTArray.DeepCopy().(*SortedTArray[string]),
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	newSlice := make([]string, len(a.array))
-	copy(newSlice, a.array)
-	return NewSortedStrArrayFrom(newSlice, a.mu.IsSafe())
 }
diff --git a/container/garray/garray_sorted_t.go b/container/garray/garray_sorted_t.go
new file mode 100644
index 000000000..981785f9b
--- /dev/null
+++ b/container/garray/garray_sorted_t.go
@@ -0,0 +1,854 @@
+// 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 garray
+
+import (
+	"bytes"
+	"math"
+
+	"github.com/gogf/gf/v2/internal/deepcopy"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/grand"
+	"github.com/gogf/gf/v2/util/gutil"
+)
+
+// SortedTArray is a golang sorted array with rich features.
+// It is using increasing order in default, which can be changed by
+// setting it a custom comparator.
+// It contains a concurrent-safe/unsafe switch, which should be set
+// when its initialization and cannot be changed then.
+type SortedTArray[T comparable] struct {
+	mu         rwmutex.RWMutex
+	array      []T
+	unique     bool             // Whether enable unique feature(false)
+	comparator func(a, b T) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b)
+	sorter     func(values []T, comparator func(a, b T) int)
+}
+
+// NewSortedTArray creates and returns an empty sorted array.
+// The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.
+// The parameter `comparator` used to compare values to sort in array,
+// if it returns value < 0, means `a` < `b`; the `a` will be inserted before `b`;
+// if it returns value = 0, means `a` = `b`; the `a` will be replaced by     `b`;
+// if it returns value > 0, means `a` > `b`; the `a` will be inserted after  `b`;
+func NewSortedTArray[T comparable](comparator func(a, b T) int, safe ...bool) *SortedTArray[T] {
+	if comparator == nil {
+		comparator = gutil.ComparatorTStr
+	}
+	return NewSortedTArraySize(0, comparator, safe...)
+}
+
+// NewSortedTArraySize create and returns a sorted array with given size and cap.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewSortedTArraySize[T comparable](cap int, comparator func(a, b T) int, safe ...bool) *SortedTArray[T] {
+	if comparator == nil {
+		comparator = gutil.ComparatorTStr
+	}
+	return &SortedTArray[T]{
+		mu:         rwmutex.Create(safe...),
+		array:      make([]T, 0, cap),
+		comparator: comparator,
+		sorter:     nil,
+	}
+}
+
+// NewSortedTArrayFrom creates and returns an sorted array with given slice `array`.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewSortedTArrayFrom[T comparable](array []T, comparator func(a, b T) int, safe ...bool) *SortedTArray[T] {
+	if comparator == nil {
+		comparator = gutil.ComparatorTStr
+	}
+	a := NewSortedTArraySize(0, comparator, safe...)
+	a.array = array
+	a.getSorter()(a.array, a.getComparator())
+	return a
+}
+
+// NewSortedTArrayFromCopy creates and returns an sorted array from a copy of given slice `array`.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewSortedTArrayFromCopy[T comparable](array []T, comparator func(a, b T) int, safe ...bool) *SortedTArray[T] {
+	if comparator == nil {
+		comparator = gutil.ComparatorTStr
+	}
+	newArray := make([]T, len(array))
+	copy(newArray, array)
+	return NewSortedTArrayFrom(newArray, comparator, safe...)
+}
+
+func (a *SortedTArray[T]) getSorter() func(values []T, comparator func(a, b T) int) {
+	if a.sorter == nil {
+		return defaultSorter
+	} else {
+		return a.sorter
+	}
+}
+
+// At returns the value by the specified index.
+// If the given `index` is out of range of the array, it returns the zero value of type `T`
+func (a *SortedTArray[T]) At(index int) (value T) {
+	value, _ = a.Get(index)
+	return
+}
+
+// SetArray sets the underlying slice array with the given `array`.
+func (a *SortedTArray[T]) SetArray(array []T) *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.array = array
+	a.getSorter()(a.array, a.getComparator())
+
+	return a
+}
+
+// SetSorter sets/changes the sorter for sorting.
+func (a *SortedTArray[T]) SetSorter(sorter func(values []T, comparator func(a, b T) int)) {
+	if sorter == nil {
+		a.sorter = defaultSorter
+	} else {
+		a.sorter = sorter
+	}
+	a.sorter(a.array, a.getComparator())
+}
+
+// SetComparator sets/changes the comparator for sorting.
+// It resorts the array as the comparator is changed.
+func (a *SortedTArray[T]) SetComparator(comparator func(a, b T) int) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if comparator == nil {
+		comparator = gutil.ComparatorTStr
+	}
+	a.comparator = comparator
+	a.getSorter()(a.array, comparator)
+}
+
+// Sort sorts the array in increasing order.
+// The parameter `reverse` controls whether sort
+// in increasing order(default) or decreasing order
+func (a *SortedTArray[T]) Sort() *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+
+	a.getSorter()(a.array, a.getComparator())
+
+	return a
+}
+
+// Add adds one or multiple values to sorted array, the array always keeps sorted.
+// It's alias of function Append, see Append.
+func (a *SortedTArray[T]) Add(values ...T) *SortedTArray[T] {
+	return a.Append(values...)
+}
+
+// Append adds one or multiple values to sorted array, the array always keeps sorted.
+func (a *SortedTArray[T]) Append(values ...T) *SortedTArray[T] {
+	if len(values) == 0 {
+		return a
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for _, value := range values {
+		index, cmp := a.binSearch(value, false)
+		if a.unique && cmp == 0 {
+			continue
+		}
+		if index < 0 {
+			a.array = append(a.array, value)
+			continue
+		}
+		if cmp > 0 {
+			index++
+		}
+		a.array = append(a.array[:index], append([]T{value}, a.array[index:]...)...)
+	}
+	return a
+}
+
+// Get returns the value by the specified index.
+// If the given `index` is out of range of the array, the `found` is false.
+func (a *SortedTArray[T]) Get(index int) (value T, found bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if index < 0 || index >= len(a.array) {
+		found = false
+		return
+	}
+	return a.array[index], true
+}
+
+// Remove removes an item by index.
+// If the given `index` is out of range of the array, the `found` is false.
+func (a *SortedTArray[T]) Remove(index int) (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.doRemoveWithoutLock(index)
+}
+
+// doRemoveWithoutLock removes an item by index without lock.
+func (a *SortedTArray[T]) doRemoveWithoutLock(index int) (value T, found bool) {
+	if index < 0 || index >= len(a.array) {
+		found = false
+		return
+	}
+	// Determine array boundaries when deleting to improve deletion efficiency.
+	if index == 0 {
+		value := a.array[0]
+		a.array = a.array[1:]
+		return value, true
+	} else if index == len(a.array)-1 {
+		value := a.array[index]
+		a.array = a.array[:index]
+		return value, true
+	}
+	// If it is a non-boundary delete,
+	// it will involve the creation of an array,
+	// then the deletion is less efficient.
+	value = a.array[index]
+	a.array = append(a.array[:index], a.array[index+1:]...)
+	return value, true
+}
+
+// RemoveValue removes an item by value.
+// It returns true if value is found in the array, or else false if not found.
+func (a *SortedTArray[T]) RemoveValue(value T) bool {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if i, r := a.binSearch(value, false); r == 0 {
+		_, res := a.doRemoveWithoutLock(i)
+		return res
+	}
+	return false
+}
+
+// RemoveValues removes an item by `values`.
+func (a *SortedTArray[T]) RemoveValues(values ...T) {
+	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 *SortedTArray[T]) PopLeft() (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		found = false
+		return
+	}
+	value = a.array[0]
+	a.array = a.array[1:]
+	return value, true
+}
+
+// PopRight pops and returns an item from the end of array.
+// Note that if the array is empty, the `found` is false.
+func (a *SortedTArray[T]) PopRight() (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - 1
+	if index < 0 {
+		found = false
+		return
+	}
+	value = a.array[index]
+	a.array = a.array[:index]
+	return value, true
+}
+
+// PopRand randomly pops and return an item out of array.
+// Note that if the array is empty, the `found` is false.
+func (a *SortedTArray[T]) PopRand() (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+}
+
+// PopRands randomly pops and returns `size` items out of array.
+func (a *SortedTArray[T]) PopRands(size int) []T {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	if size >= len(a.array) {
+		size = len(a.array)
+	}
+	array := make([]T, size)
+	for i := 0; i < size; i++ {
+		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	}
+	return array
+}
+
+// PopLefts pops and returns `size` items from the beginning of array.
+func (a *SortedTArray[T]) PopLefts(size int) []T {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	if size >= len(a.array) {
+		array := a.array
+		a.array = a.array[:0]
+		return array
+	}
+	value := a.array[0:size]
+	a.array = a.array[size:]
+	return value
+}
+
+// PopRights pops and returns `size` items from the end of array.
+func (a *SortedTArray[T]) PopRights(size int) []T {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	index := len(a.array) - size
+	if index <= 0 {
+		array := a.array
+		a.array = a.array[:0]
+		return array
+	}
+	value := a.array[index:]
+	a.array = a.array[:index]
+	return value
+}
+
+// Range picks and returns items by range, like array[start:end].
+// Notice, if in concurrent-safe usage, it returns a copy of slice;
+// else a pointer to the underlying data.
+//
+// If `end` is negative, then the offset will start from the end of array.
+// If `end` is omitted, then the sequence will have everything from start up
+// until the end of the array.
+func (a *SortedTArray[T]) Range(start int, end ...int) []T {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	offsetEnd := len(a.array)
+	if len(end) > 0 && end[0] < offsetEnd {
+		offsetEnd = end[0]
+	}
+	if start > offsetEnd {
+		return nil
+	}
+	if start < 0 {
+		start = 0
+	}
+	array := ([]T)(nil)
+	if a.mu.IsSafe() {
+		array = make([]T, offsetEnd-start)
+		copy(array, a.array[start:offsetEnd])
+	} else {
+		array = a.array[start:offsetEnd]
+	}
+	return array
+}
+
+// SubSlice returns a slice of elements from the array as specified
+// by the `offset` and `size` parameters.
+// If in concurrent safe usage, it returns a copy of the slice; else a pointer.
+//
+// If offset is non-negative, the sequence will start at that offset in the array.
+// If offset is negative, the sequence will start that far from the end of the array.
+//
+// If length is given and is positive, then the sequence will have up to that many elements in it.
+// If the array is shorter than the length, then only the available array elements will be present.
+// If length is given and is negative then the sequence will stop that many elements from the end of the array.
+// If it is omitted, then the sequence will have everything from offset up until the end of the array.
+//
+// Any possibility crossing the left border of array, it will fail.
+func (a *SortedTArray[T]) SubSlice(offset int, length ...int) []T {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	size := len(a.array)
+	if len(length) > 0 {
+		size = length[0]
+	}
+	if offset > len(a.array) {
+		return nil
+	}
+	if offset < 0 {
+		offset = len(a.array) + offset
+		if offset < 0 {
+			return nil
+		}
+	}
+	if size < 0 {
+		offset += size
+		size = -size
+		if offset < 0 {
+			return nil
+		}
+	}
+	end := offset + size
+	if end > len(a.array) {
+		end = len(a.array)
+		size = len(a.array) - offset
+	}
+	if a.mu.IsSafe() {
+		s := make([]T, size)
+		copy(s, a.array[offset:])
+		return s
+	} else {
+		return a.array[offset:end]
+	}
+}
+
+// Sum returns the sum of values in an array.
+func (a *SortedTArray[T]) Sum() (sum int) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		sum += gconv.Int(v)
+	}
+	return
+}
+
+// Len returns the length of array.
+func (a *SortedTArray[T]) Len() int {
+	a.mu.RLock()
+	length := len(a.array)
+	a.mu.RUnlock()
+	return length
+}
+
+// Slice returns the underlying data of array.
+// Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
+// or else a pointer to the underlying data.
+func (a *SortedTArray[T]) Slice() []T {
+	var array []T
+	if a.mu.IsSafe() {
+		a.mu.RLock()
+		defer a.mu.RUnlock()
+		array = make([]T, len(a.array))
+		copy(array, a.array)
+	} else {
+		array = a.array
+	}
+	return array
+}
+
+// Interfaces returns current array as []any.
+func (a *SortedTArray[T]) Interfaces() []any {
+	return tToAnySlice(a.Slice())
+}
+
+// Contains checks whether a value exists in the array.
+func (a *SortedTArray[T]) Contains(value T) bool {
+	return a.Search(value) != -1
+}
+
+// Search searches array by `value`, returns the index of `value`,
+// or returns -1 if not exists.
+func (a *SortedTArray[T]) Search(value T) (index int) {
+	if i, r := a.binSearch(value, true); r == 0 {
+		return i
+	}
+	return -1
+}
+
+// Binary search.
+// It returns the last compared index and the result.
+// If `result` equals to 0, it means the value at `index` is equals to `value`.
+// If `result` lesser than 0, it means the value at `index` is lesser than `value`.
+// If `result` greater than 0, it means the value at `index` is greater than `value`.
+func (a *SortedTArray[T]) binSearch(value T, lock bool) (index int, result int) {
+	if lock {
+		a.mu.RLock()
+		defer a.mu.RUnlock()
+	}
+	if len(a.array) == 0 {
+		return -1, -2
+	}
+	min := 0
+	max := len(a.array) - 1
+	mid := 0
+	cmp := -2
+	for min <= max {
+		mid = min + (max-min)/2
+		cmp = a.getComparator()(value, a.array[mid])
+		switch {
+		case cmp < 0:
+			max = mid - 1
+		case cmp > 0:
+			min = mid + 1
+		default:
+			return mid, cmp
+		}
+	}
+	return mid, cmp
+}
+
+// SetUnique sets unique mark to the array,
+// which means it does not contain any repeated items.
+// It also does unique check, remove all repeated items.
+func (a *SortedTArray[T]) SetUnique(unique bool) *SortedTArray[T] {
+	oldUnique := a.unique
+	a.unique = unique
+	if unique && oldUnique != unique {
+		a.Unique()
+	}
+	return a
+}
+
+// Unique uniques the array, clear repeated items.
+func (a *SortedTArray[T]) Unique() *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
+	}
+	for i := 0; i < len(a.array)-1; {
+		if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
+			a.array = append(a.array[:i+1], a.array[i+2:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
+// Clone returns a new array, which is a copy of current array.
+func (a *SortedTArray[T]) Clone() (newArray *SortedTArray[T]) {
+	a.mu.RLock()
+	array := make([]T, len(a.array))
+	copy(array, a.array)
+	a.mu.RUnlock()
+	return NewSortedTArrayFrom[T](array, a.comparator, a.mu.IsSafe())
+}
+
+// Clear deletes all items of current array.
+func (a *SortedTArray[T]) Clear() *SortedTArray[T] {
+	a.mu.Lock()
+	if len(a.array) > 0 {
+		a.array = make([]T, 0)
+	}
+	a.mu.Unlock()
+	return a
+}
+
+// LockFunc locks writing by callback function `f`.
+func (a *SortedTArray[T]) LockFunc(f func(array []T)) *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+
+	// Keep the array always sorted.
+	defer a.getSorter()(a.array, a.getComparator())
+
+	f(a.array)
+	return a
+}
+
+// RLockFunc locks reading by callback function `f`.
+func (a *SortedTArray[T]) RLockFunc(f func(array []T)) *SortedTArray[T] {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
+	return a
+}
+
+// Merge merges `array` into current array.
+// The parameter `array` can be any garray or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more parameter types.
+func (a *SortedTArray[T]) Merge(array any) *SortedTArray[T] {
+	var vals []T
+	switch v := array.(type) {
+	case *SortedTArray[T]:
+		vals = v.Slice()
+	case *TArray[T]:
+		vals = v.Slice()
+	case []T:
+		vals = v
+	default:
+		interfaces := gconv.Interfaces(v)
+		if err := gconv.Scan(interfaces, &vals); err != nil {
+			panic(err)
+		}
+	}
+
+	return a.Add(vals...)
+}
+
+// Chunk splits an array into multiple arrays,
+// the size of each array is determined by `size`.
+// The last chunk may contain less than size elements.
+func (a *SortedTArray[T]) Chunk(size int) [][]T {
+	if size < 1 {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	length := len(a.array)
+	chunks := int(math.Ceil(float64(length) / float64(size)))
+	var n [][]T
+	for i, end := 0, 0; chunks > 0; chunks-- {
+		end = (i + 1) * size
+		if end > length {
+			end = length
+		}
+		n = append(n, a.array[i*size:end])
+		i++
+	}
+	return n
+}
+
+// Rand randomly returns one item from array(no deleting).
+func (a *SortedTArray[T]) Rand() (value T, found bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		found = false
+		return
+	}
+	return a.array[grand.Intn(len(a.array))], true
+}
+
+// Rands randomly returns `size` items from array(no deleting).
+func (a *SortedTArray[T]) Rands(size int) []T {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	array := make([]T, size)
+	for i := 0; i < size; i++ {
+		array[i] = a.array[grand.Intn(len(a.array))]
+	}
+	return array
+}
+
+// Join joins array elements with a string `glue`.
+func (a *SortedTArray[T]) Join(glue string) string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		return ""
+	}
+	buffer := bytes.NewBuffer(nil)
+	for k, v := range a.array {
+		buffer.WriteString(gconv.String(v))
+		if k != len(a.array)-1 {
+			buffer.WriteString(glue)
+		}
+	}
+	return buffer.String()
+}
+
+// CountValues counts the number of occurrences of all values in the array.
+func (a *SortedTArray[T]) CountValues() map[T]int {
+	m := make(map[T]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
+}
+
+// Iterator is alias of IteratorAsc.
+func (a *SortedTArray[T]) Iterator(f func(k int, v T) bool) {
+	a.IteratorAsc(f)
+}
+
+// IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (a *SortedTArray[T]) IteratorAsc(f func(k int, v T) bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for k, v := range a.array {
+		if !f(k, v) {
+			break
+		}
+	}
+}
+
+// IteratorDesc iterates the array readonly in descending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (a *SortedTArray[T]) IteratorDesc(f func(k int, v T) bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for i := len(a.array) - 1; i >= 0; i-- {
+		if !f(i, a.array[i]) {
+			break
+		}
+	}
+}
+
+// String returns current array as a string, which implements like json.Marshal does.
+func (a *SortedTArray[T]) String() string {
+	if a == nil {
+		return ""
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	buffer := bytes.NewBuffer(nil)
+	buffer.WriteByte('[')
+	s := ""
+	for k, v := range a.array {
+		s = gconv.String(v)
+		if gstr.IsNumeric(s) {
+			buffer.WriteString(s)
+		} else {
+			buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
+		}
+		if k != len(a.array)-1 {
+			buffer.WriteByte(',')
+		}
+	}
+	buffer.WriteByte(']')
+	return buffer.String()
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+// DO NOT change this receiver to pointer type, as the TArray can be used as a var defined variable, like:
+// var a SortedTArray[int]
+// Please refer to corresponding tests for more details.
+func (a SortedTArray[T]) MarshalJSON() ([]byte, error) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
+}
+
+// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
+// Note that the comparator is set as string comparator in default.
+func (a *SortedTArray[T]) UnmarshalJSON(b []byte) error {
+	if a.comparator == nil {
+		a.array = make([]T, 0)
+		a.comparator = gutil.ComparatorTStr
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
+		return err
+	}
+	if a.comparator != nil && a.array != nil {
+		a.getSorter()(a.array, a.comparator)
+	}
+	return nil
+}
+
+// UnmarshalValue is an interface implement which sets any type of value for array.
+// Note that the comparator is set as string comparator in default.
+func (a *SortedTArray[T]) UnmarshalValue(value any) (err error) {
+	if a.comparator == nil {
+		a.comparator = gutil.ComparatorTStr
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		err = json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
+	default:
+		if err = gconv.Scan(value, &a.array); err != nil {
+			return
+		}
+	}
+	if a.comparator != nil && a.array != nil {
+		a.getSorter()(a.array, a.comparator)
+	}
+	return err
+}
+
+// FilterNil removes all nil value of the array.
+func (a *SortedTArray[T]) FilterNil() *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if empty.IsNil(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
+// Filter iterates array and filters elements using custom callback function.
+// It removes the element from array if callback function `filter` returns true,
+// it or else does nothing and continues iterating.
+func (a *SortedTArray[T]) Filter(filter func(index int, value T) bool) *SortedTArray[T] {
+	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 *SortedTArray[T]) FilterEmpty() *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if empty.IsEmpty(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
+// Walk applies a user supplied function `f` to every item of array.
+func (a *SortedTArray[T]) Walk(f func(value T) T) *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	// Keep the array always sorted.
+	defer a.getSorter()(a.array, a.getComparator())
+
+	for i, v := range a.array {
+		a.array[i] = f(v)
+	}
+	return a
+}
+
+// IsEmpty checks whether the array is empty.
+func (a *SortedTArray[T]) IsEmpty() bool {
+	return a.Len() == 0
+}
+
+// getComparator returns the comparator if it's previously set,
+// or else it panics.
+func (a *SortedTArray[T]) getComparator() func(a, b T) int {
+	if a.comparator == nil {
+		a.comparator = gutil.ComparatorTStr
+	}
+	return a.comparator
+}
+
+// DeepCopy implements interface for deep copy of current type.
+func (a *SortedTArray[T]) DeepCopy() any {
+	if a == nil {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]T, len(a.array))
+	for i, v := range a.array {
+		newSlice[i], _ = deepcopy.Copy(v).(T)
+	}
+	return NewSortedTArrayFrom[T](newSlice, a.comparator, a.mu.IsSafe())
+}
diff --git a/container/garray/garray_z_example_normal_t_test.go b/container/garray/garray_z_example_normal_t_test.go
new file mode 100644
index 000000000..152935fe0
--- /dev/null
+++ b/container/garray/garray_z_example_normal_t_test.go
@@ -0,0 +1,1281 @@
+// 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 garray_test
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+func ExampleTArray_Walk() {
+	{
+		var intArray garray.TArray[int]
+		intTables := g.SliceInt{10, 20}
+		intPrefix := 99
+		intArray.Append(intTables...)
+		// Add prefix for given table names.
+		intArray.Walk(func(value int) int {
+			return intPrefix + value
+		})
+		fmt.Println(intArray.Slice())
+	}
+
+	{
+		var strArray garray.TArray[string]
+		strTables := g.SliceStr{"user", "user_detail"}
+		strPrefix := "gf_"
+		strArray.Append(strTables...)
+		// Add prefix for given table names.
+		strArray.Walk(func(value string) string {
+			return strPrefix + value
+		})
+		fmt.Println(strArray.Slice())
+	}
+
+	// Output:
+	// [109 119]
+	// [gf_user gf_user_detail]
+}
+
+func ExampleNewTArray() {
+	{
+		intArr := garray.NewTArray[int]()
+		intArr.Append(10)
+		intArr.Append(20)
+		intArr.Append(15)
+		intArr.Append(30)
+		fmt.Println(intArr.Slice())
+	}
+
+	{
+		strArr := garray.NewTArray[string]()
+		strArr.Append("We")
+		strArr.Append("are")
+		strArr.Append("GF")
+		strArr.Append("fans")
+		fmt.Println(strArr.Slice())
+	}
+
+	// Output:
+	// [10 20 15 30]
+	// [We are GF fans]
+}
+
+func ExampleNewTArraySize() {
+	{
+		intArr := garray.NewTArraySize[int](3, 5)
+		intArr.Set(0, 10)
+		intArr.Set(1, 20)
+		intArr.Set(2, 15)
+		intArr.Set(3, 30)
+		fmt.Println(intArr.Slice(), intArr.Len(), cap(intArr.Slice()))
+	}
+
+	{
+		strArr := garray.NewTArraySize[string](3, 5)
+		strArr.Set(0, "We")
+		strArr.Set(1, "are")
+		strArr.Set(2, "GF")
+		strArr.Set(3, "fans")
+		fmt.Println(strArr.Slice(), strArr.Len(), cap(strArr.Slice()))
+	}
+
+	// Output:
+	// [10 20 15] 3 5
+	// [We are GF] 3 5
+}
+
+func ExampleNewTArrayFrom() {
+	{
+		intArr := garray.NewTArrayFrom[int](g.SliceInt{10, 20, 15, 30})
+		fmt.Println(intArr.Slice(), intArr.Len(), cap(intArr.Slice()))
+	}
+
+	{
+		strArr := garray.NewTArrayFrom[string](g.SliceStr{"We", "are", "GF", "fans", "!"})
+		fmt.Println(strArr.Slice(), strArr.Len(), cap(strArr.Slice()))
+	}
+
+	// Output:
+	// [10 20 15 30] 4 4
+	// [We are GF fans !] 5 5
+}
+
+func ExampleNewTArrayFromCopy() {
+	{
+		intArr := garray.NewTArrayFromCopy(g.SliceInt{10, 20, 15, 30})
+		fmt.Println(intArr.Slice(), intArr.Len(), cap(intArr.Slice()))
+	}
+
+	{
+		strArr := garray.NewTArrayFromCopy(g.SliceStr{"a", "b", "c", "d", "e"})
+		fmt.Println(strArr.Slice(), strArr.Len(), cap(strArr.Slice()))
+	}
+
+	// Output:
+	// [10 20 15 30] 4 4
+	// [a b c d e] 5 5
+}
+
+func ExampleTArray_At() {
+	{
+		intArr := garray.NewTArrayFrom[int](g.SliceInt{10, 20, 15, 30})
+		isAt := intArr.At(2)
+		fmt.Println(isAt)
+	}
+
+	{
+		strArr := garray.NewTArrayFrom[string](g.SliceStr{"We", "are", "GF", "fans", "!"})
+		ssAt := strArr.At(2)
+		fmt.Println(ssAt)
+	}
+
+	// Output:
+	// 15
+	// GF
+}
+
+func ExampleTArray_Get() {
+	{
+		s := garray.NewTArrayFrom[int](g.SliceInt{10, 20, 15, 30})
+		sGet, sBool := s.Get(3)
+		fmt.Println(sGet, sBool)
+		sGet, sBool = s.Get(99)
+		fmt.Println(sGet, sBool)
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"We", "are", "GF", "fans", "!"})
+		sGet, sBool := s.Get(3)
+		fmt.Println(sGet, sBool)
+	}
+
+	// Output:
+	// 30 true
+	// 0 false
+	// fans true
+}
+
+func ExampleTArray_Set() {
+	{
+		s := garray.NewTArraySize[int](3, 5)
+		s.Set(0, 10)
+		s.Set(1, 20)
+		s.Set(2, 15)
+		s.Set(3, 30)
+		fmt.Println(s.Slice())
+	}
+	{
+		s := garray.NewTArraySize[string](3, 5)
+		s.Set(0, "We")
+		s.Set(1, "are")
+		s.Set(2, "GF")
+		s.Set(3, "fans")
+		fmt.Println(s.Slice())
+	}
+
+	// Output:
+	// [10 20 15]
+	// [We are GF]
+}
+
+func ExampleTArray_SetArray() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30})
+		fmt.Println(s.Slice())
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"We", "are", "GF", "fans", "!"})
+		fmt.Println(s.Slice())
+	}
+
+	// Output:
+	// [10 20 15 30]
+	// [We are GF fans !]
+}
+
+func ExampleTArray_Replace() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30})
+		fmt.Println(s.Slice())
+		s.Replace(g.SliceInt{12, 13})
+		fmt.Println(s.Slice())
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"We", "are", "GF", "fans", "!"})
+		fmt.Println(s.Slice())
+		s.Replace(g.SliceStr{"Happy", "coding"})
+		fmt.Println(s.Slice())
+	}
+
+	// Output:
+	// [10 20 15 30]
+	// [12 13 15 30]
+	// [We are GF fans !]
+	// [Happy coding GF fans !]
+}
+
+func ExampleTArray_Sum() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30})
+		a := s.Sum()
+		fmt.Println(a)
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"3", "5", "10"})
+		a := s.Sum()
+		fmt.Println(a)
+	}
+	// Output:
+	// 75
+	// 18
+}
+
+func ExampleTArray_SortFunc() {
+	{
+		s := garray.NewTArrayFrom[int](g.SliceInt{10, 20, 15, 30})
+		fmt.Println(s)
+		s.SortFunc(func(v1, v2 int) bool {
+			// fmt.Println(v1,v2)
+			return v1 > v2
+		})
+		fmt.Println(s)
+		s.SortFunc(func(v1, v2 int) bool {
+			return v1 < v2
+		})
+		fmt.Println(s)
+	}
+
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"b", "c", "a"})
+		fmt.Println(s)
+		s.SortFunc(func(v1, v2 string) bool {
+			return gstr.Compare(v1, v2) > 0
+		})
+		fmt.Println(s)
+		s.SortFunc(func(v1, v2 string) bool {
+			return gstr.Compare(v1, v2) < 0
+		})
+		fmt.Println(s)
+	}
+
+	// Output:
+	// [10,20,15,30]
+	// [30,20,15,10]
+	// [10,15,20,30]
+	// ["b","c","a"]
+	// ["c","b","a"]
+	// ["a","b","c"]
+}
+
+func ExampleTArray_InsertBefore() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30})
+		s.InsertBefore(1, 99)
+		fmt.Println(s.Slice())
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d"})
+		s.InsertBefore(1, "here")
+		fmt.Println(s.Slice())
+	}
+
+	// Output:
+	// [10 99 20 15 30]
+	// [a here b c d]
+}
+
+func ExampleTArray_InsertAfter() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30})
+		s.InsertAfter(1, 99)
+		fmt.Println(s.Slice())
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d"})
+		s.InsertAfter(1, "here")
+		fmt.Println(s.Slice())
+	}
+	// Output:
+	// [10 20 99 15 30]
+	// [a b here c d]
+}
+
+func ExampleTArray_Remove() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30})
+		fmt.Println(s)
+		s.Remove(1)
+		fmt.Println(s.Slice())
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d"})
+		s.Remove(1)
+		fmt.Println(s.Slice())
+	}
+	// Output:
+	// [10,20,15,30]
+	// [10 15 30]
+	// [a c d]
+}
+
+func ExampleTArray_RemoveValue() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30})
+		fmt.Println(s)
+		s.RemoveValue(20)
+		fmt.Println(s.Slice())
+	}
+
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d"})
+		s.RemoveValue("b")
+		fmt.Println(s.Slice())
+	}
+
+	// Output:
+	// [10,20,15,30]
+	// [10 15 30]
+	// [a c d]
+}
+
+func ExampleTArray_PushLeft() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30})
+		fmt.Println(s)
+		s.PushLeft(96, 97, 98, 99)
+		fmt.Println(s.Slice())
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d"})
+		s.PushLeft("We", "are", "GF", "fans")
+		fmt.Println(s.Slice())
+	}
+
+	// Output:
+	// [10,20,15,30]
+	// [96 97 98 99 10 20 15 30]
+	// [We are GF fans a b c d]
+}
+
+func ExampleTArray_PushRight() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30})
+		fmt.Println(s)
+		s.PushRight(96, 97, 98, 99)
+		fmt.Println(s.Slice())
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d"})
+		s.PushRight("We", "are", "GF", "fans")
+		fmt.Println(s.Slice())
+	}
+	// Output:
+	// [10,20,15,30]
+	// [10 20 15 30 96 97 98 99]
+	// [a b c d We are GF fans]
+}
+
+func ExampleTArray_PopLeft() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30})
+		fmt.Println(s)
+		s.PopLeft()
+		fmt.Println(s.Slice())
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d"})
+		s.PopLeft()
+		fmt.Println(s.Slice())
+	}
+	// Output:
+	// [10,20,15,30]
+	// [20 15 30]
+	// [b c d]
+}
+
+func ExampleTArray_PopRight() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30})
+		fmt.Println(s)
+		s.PopRight()
+		fmt.Println(s.Slice())
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d"})
+		s.PopRight()
+		fmt.Println(s.Slice())
+	}
+	// Output:
+	// [10,20,15,30]
+	// [10 20 15]
+	// [a b c]
+}
+
+func ExampleTArray_PopRand() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60, 70})
+		fmt.Println(s)
+		r, _ := s.PopRand()
+		fmt.Println(s)
+		fmt.Println(r)
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		r, _ := s.PopRand()
+		fmt.Println(r)
+	}
+
+	// May Output:
+	// [10,20,15,30,40,50,60,70]
+	// [10,20,15,30,40,60,70]
+	// 50
+	// e
+}
+
+func ExampleTArray_PopRands() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		r := s.PopRands(2)
+		fmt.Println(s)
+		fmt.Println(r)
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		r := s.PopRands(2)
+		fmt.Println(r)
+	}
+	// May Output:
+	// [10,20,15,30,40,50,60]
+	// [10,20,15,30,40]
+	// [50 60]
+	// [e c]
+}
+
+func ExampleTArray_PopLefts() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		r := s.PopLefts(2)
+		fmt.Println(s)
+		fmt.Println(r)
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		r := s.PopLefts(2)
+		fmt.Println(r)
+		fmt.Println(s)
+	}
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// [15,30,40,50,60]
+	// [10 20]
+	// [a b]
+	// ["c","d","e","f","g","h"]
+}
+
+func ExampleTArray_PopRights() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		r := s.PopRights(2)
+		fmt.Println(s)
+		fmt.Println(r)
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		r := s.PopRights(2)
+		fmt.Println(r)
+		fmt.Println(s)
+	}
+
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// [10,20,15,30,40]
+	// [50 60]
+	// [g h]
+	// ["a","b","c","d","e","f"]
+}
+
+func ExampleTArray_Range() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		r := s.Range(2, 5)
+		fmt.Println(r)
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		r := s.Range(2, 5)
+		fmt.Println(r)
+	}
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// [15 30 40]
+	// [c d e]
+}
+
+func ExampleTArray_SubSlice() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		r := s.SubSlice(3, 4)
+		fmt.Println(r)
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		r := s.SubSlice(3, 4)
+		fmt.Println(r)
+	}
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// [30 40 50 60]
+	// [d e f g]
+}
+
+func ExampleTArray_Append() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		s.Append(96, 97, 98)
+		fmt.Println(s)
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"We", "are", "GF", "fans"})
+		s.Append("a", "b", "c")
+		fmt.Println(s)
+	}
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// [10,20,15,30,40,50,60,96,97,98]
+	// ["We","are","GF","fans","a","b","c"]
+}
+
+func ExampleTArray_Len() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		fmt.Println(s.Len())
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		fmt.Println(s.Len())
+	}
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// 7
+	// 8
+}
+
+func ExampleTArray_Slice() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s.Slice())
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		fmt.Println(s.Slice())
+	}
+	// Output:
+	// [10 20 15 30 40 50 60]
+	// [a b c d e f g h]
+}
+
+func ExampleTArray_Interfaces() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		r := s.Interfaces()
+		fmt.Println(r)
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		r := s.Interfaces()
+		fmt.Println(r)
+	}
+	// Output:
+	// [10 20 15 30 40 50 60]
+	// [a b c d e f g h]
+}
+
+func ExampleTArray_Clone() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		r := s.Clone()
+		fmt.Println(r)
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		r := s.Clone()
+		fmt.Println(r)
+		fmt.Println(s)
+	}
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// [10,20,15,30,40,50,60]
+	// ["a","b","c","d","e","f","g","h"]
+	// ["a","b","c","d","e","f","g","h"]
+}
+
+func ExampleTArray_Clear() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		fmt.Println(s.Clear())
+		fmt.Println(s)
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		fmt.Println(s)
+		fmt.Println(s.Clear())
+		fmt.Println(s)
+	}
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// []
+	// []
+	// ["a","b","c","d","e","f","g","h"]
+	// []
+	// []
+}
+
+func ExampleTArray_Contains() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s.Contains(20))
+		fmt.Println(s.Contains(21))
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		fmt.Println(s.Contains("e"))
+		fmt.Println(s.Contains("z"))
+	}
+	// Output:
+	// true
+	// false
+	// true
+	// false
+}
+
+func ExampleTArray_Search() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s.Search(20))
+		fmt.Println(s.Search(21))
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		fmt.Println(s.Search("e"))
+		fmt.Println(s.Search("z"))
+	}
+	// Output:
+	// 1
+	// -1
+	// 4
+	// -1
+}
+
+func ExampleTArray_Unique() {
+	{
+		s := garray.NewTArray[int]()
+		s.SetArray(g.SliceInt{10, 20, 15, 15, 20, 50, 60})
+		fmt.Println(s)
+		fmt.Println(s.Unique())
+	}
+	{
+		s := garray.NewTArray[string]()
+		s.SetArray(g.SliceStr{"a", "b", "c", "c", "c", "d", "d"})
+		fmt.Println(s.Unique())
+	}
+	// Output:
+	// [10,20,15,15,20,50,60]
+	// [10,20,15,50,60]
+	// ["a","b","c","d"]
+}
+
+func ExampleTArray_LockFunc() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		s.LockFunc(func(array []int) {
+			for i := 0; i < len(array)-1; i++ {
+				fmt.Println(array[i])
+			}
+		})
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c"})
+		s.LockFunc(func(array []string) {
+			array[len(array)-1] = "GF fans"
+		})
+		fmt.Println(s)
+	}
+	// Output:
+	// 10
+	// 20
+	// 15
+	// 30
+	// 40
+	// 50
+	// ["a","b","GF fans"]
+}
+
+func ExampleTArray_RLockFunc() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		s.RLockFunc(func(array []int) {
+			for i := 0; i < len(array); i++ {
+				fmt.Println(array[i])
+			}
+		})
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c", "d", "e"})
+		s.RLockFunc(func(array []string) {
+			for i := 0; i < len(array); i++ {
+				fmt.Println(array[i])
+			}
+		})
+	}
+	// Output:
+	// 10
+	// 20
+	// 15
+	// 30
+	// 40
+	// 50
+	// 60
+	// a
+	// b
+	// c
+	// d
+	// e
+}
+
+func ExampleTArray_Merge() {
+	{
+		s1 := garray.NewTArray[int]()
+		s2 := garray.NewTArray[int]()
+		s1.SetArray(g.SliceInt{10, 20, 15})
+		s2.SetArray(g.SliceInt{40, 50, 60})
+		fmt.Println(s1)
+		fmt.Println(s2)
+		s1.Merge(s2)
+		fmt.Println(s1)
+	}
+	{
+		s1 := garray.NewTArray[string]()
+		s2 := garray.NewTArray[string]()
+		s1.SetArray(g.SliceStr{"a", "b", "c"})
+		s2.SetArray(g.SliceStr{"d", "e", "f"})
+		s1.Merge(s2)
+		fmt.Println(s1)
+	}
+	// Output:
+	// [10,20,15]
+	// [40,50,60]
+	// [10,20,15,40,50,60]
+	// ["a","b","c","d","e","f"]
+}
+
+func ExampleTArray_Fill() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		s.Fill(2, 3, 99)
+		fmt.Println(s)
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		s.Fill(2, 3, "here")
+		fmt.Println(s)
+	}
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// [10,20,99,99,99,50,60]
+	// ["a","b","here","here","here","f","g","h"]
+}
+
+func ExampleTArray_Chunk() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		r := s.Chunk(3)
+		fmt.Println(r)
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		r := s.Chunk(3)
+		fmt.Println(r)
+	}
+
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// [[10 20 15] [30 40 50] [60]]
+	// [[a b c] [d e f] [g h]]
+}
+
+func ExampleTArray_Pad() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		s.Pad(8, 99)
+		fmt.Println(s)
+		s.Pad(-10, 89)
+		fmt.Println(s)
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c"})
+		s.Pad(7, "here")
+		fmt.Println(s)
+		s.Pad(-10, "there")
+		fmt.Println(s)
+	}
+
+	// Output:
+	// [10,20,15,30,40,50,60,99]
+	// [89,89,10,20,15,30,40,50,60,99]
+	// ["a","b","c","here","here","here","here"]
+	// ["there","there","there","a","b","c","here","here","here","here"]
+}
+
+func ExampleTArray_Rand() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		fmt.Println(s.Rand())
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		fmt.Println(s.Rand())
+	}
+
+	// May Output:
+	// [10,20,15,30,40,50,60]
+	// 10 true
+	// c true
+}
+
+func ExampleTArray_Rands() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		fmt.Println(s.Rands(3))
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		fmt.Println(s.Rands(3))
+	}
+
+	// May Output:
+	// [10,20,15,30,40,50,60]
+	// [20 50 20]
+	// [e h e]
+}
+
+func ExampleTArray_Shuffle() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		fmt.Println(s.Shuffle())
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		fmt.Println(s.Shuffle())
+	}
+
+	// May Output:
+	// [10,20,15,30,40,50,60]
+	// [10,40,15,50,20,60,30]
+	// ["a","c","e","d","b","g","f","h"]
+}
+
+func ExampleTArray_Reverse() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		fmt.Println(s.Reverse())
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c", "d", "e", "f", "g", "h"})
+		fmt.Println(s.Reverse())
+	}
+
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// [60,50,40,30,15,20,10]
+	// ["h","g","f","e","d","c","b","a"]
+}
+
+func ExampleTArray_Join() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		fmt.Println(s.Join(","))
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c"})
+		fmt.Println(s.Join(","))
+	}
+
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// 10,20,15,30,40,50,60
+	// a,b,c
+}
+
+func ExampleTArray_CountValues() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 15, 40, 40, 40})
+		fmt.Println(s.CountValues())
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c", "c", "c", "d", "d"})
+		fmt.Println(s.CountValues())
+	}
+
+	// Output:
+	// map[10:1 15:2 20:1 40:3]
+	// map[a:1 b:1 c:3 d:2]
+}
+
+func ExampleTArray_Iterator() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		s.Iterator(func(k int, v int) bool {
+			fmt.Println(k, v)
+			return true
+		})
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c"})
+		s.Iterator(func(k int, v string) bool {
+			fmt.Println(k, v)
+			return true
+		})
+	}
+
+	// Output:
+	// 0 10
+	// 1 20
+	// 2 15
+	// 3 30
+	// 4 40
+	// 5 50
+	// 6 60
+	// 0 a
+	// 1 b
+	// 2 c
+}
+
+func ExampleTArray_IteratorAsc() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		s.IteratorAsc(func(k int, v int) bool {
+			fmt.Println(k, v)
+			return true
+		})
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c"})
+		s.IteratorAsc(func(k int, v string) bool {
+			fmt.Println(k, v)
+			return true
+		})
+	}
+
+	// Output:
+	// 0 10
+	// 1 20
+	// 2 15
+	// 3 30
+	// 4 40
+	// 5 50
+	// 6 60
+	// 0 a
+	// 1 b
+	// 2 c
+}
+
+func ExampleTArray_IteratorDesc() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		s.IteratorDesc(func(k int, v int) bool {
+			fmt.Println(k, v)
+			return true
+		})
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c"})
+		s.IteratorDesc(func(k int, v string) bool {
+			fmt.Println(k, v)
+			return true
+		})
+	}
+
+	// Output:
+	// 6 60
+	// 5 50
+	// 4 40
+	// 3 30
+	// 2 15
+	// 1 20
+	// 0 10
+	// 2 c
+	// 1 b
+	// 0 a
+}
+
+func ExampleTArray_String() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s)
+		fmt.Println(s.String())
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "c"})
+		fmt.Println(s.String())
+	}
+
+	// Output:
+	// [10,20,15,30,40,50,60]
+	// [10,20,15,30,40,50,60]
+	// ["a","b","c"]
+}
+
+func ExampleTArray_MarshalJSON() {
+	{
+		type Student struct {
+			Id     int
+			Name   string
+			Scores garray.TArray[int]
+		}
+		var array garray.TArray[int]
+		array.SetArray(g.SliceInt{98, 97, 96})
+		s := Student{
+			Id:     1,
+			Name:   "john",
+			Scores: array,
+		}
+		b, _ := json.Marshal(s)
+		fmt.Println(string(b))
+	}
+	{
+		type Student struct {
+			Id      int
+			Name    string
+			Lessons []string
+		}
+		s := Student{
+			Id:      1,
+			Name:    "john",
+			Lessons: []string{"Math", "English", "Music"},
+		}
+		b, _ := json.Marshal(s)
+		fmt.Println(string(b))
+	}
+
+	// Output:
+	// {"Id":1,"Name":"john","Scores":[98,97,96]}
+	// {"Id":1,"Name":"john","Lessons":["Math","English","Music"]}
+}
+
+func ExampleTArray_UnmarshalJSON() {
+	{
+		b := []byte(`{"Id":1,"Name":"john","Scores":[98,96,97]}`)
+		type Student struct {
+			Id     int
+			Name   string
+			Scores *garray.TArray[int]
+		}
+		s := Student{}
+		json.Unmarshal(b, &s)
+		fmt.Println(s)
+	}
+	{
+		b := []byte(`{"Id":1,"Name":"john","Lessons":["Math","English","Sport"]}`)
+		type Student struct {
+			Id      int
+			Name    string
+			Lessons *garray.TArray[string]
+		}
+		s := Student{}
+		json.Unmarshal(b, &s)
+		fmt.Println(s)
+	}
+
+	// Output:
+	// {1 john [98,96,97]}
+	// {1 john ["Math","English","Sport"]}
+}
+
+func ExampleTArray_UnmarshalValue() {
+	{
+		type Student struct {
+			Name   string
+			Scores *garray.TArray[int]
+		}
+
+		var s *Student
+		gconv.Struct(g.Map{
+			"name":   "john",
+			"scores": g.SliceInt{96, 98, 97},
+		}, &s)
+		fmt.Println(s)
+	}
+	{
+		type Student struct {
+			Name    string
+			Lessons *garray.TArray[string]
+		}
+		var s *Student
+		gconv.Struct(g.Map{
+			"name":    "john",
+			"lessons": []byte(`["Math","English","Sport"]`),
+		}, &s)
+		fmt.Println(s)
+
+		var s1 *Student
+		gconv.Struct(g.Map{
+			"name":    "john",
+			"lessons": g.SliceStr{"Math", "English", "Sport"},
+		}, &s1)
+		fmt.Println(s1)
+	}
+
+	// Output:
+	// &{john [96,98,97]}
+	// &{john ["Math","English","Sport"]}
+	// &{john ["Math","English","Sport"]}
+}
+
+func ExampleTArray_Filter() {
+	{
+		array1 := garray.NewTArrayFrom(g.SliceInt{10, 40, 50, 0, 0, 0, 60})
+		array2 := garray.NewTArrayFrom(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
+		}))
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"Math", "English", "Sport"})
+		s1 := garray.NewTArrayFrom[string](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:
+	// [10,40,50,60]
+	// [51,5,45]
+	// []
+	// ["a","b","c","d"]
+	// ["Sport"]
+}
+
+func ExampleTArray_FilterEmpty() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 40, 50, 0, 0, 0, 60})
+		fmt.Println(s)
+		fmt.Println(s.FilterEmpty())
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "", "c", "", "", "d"})
+		fmt.Println(s.FilterEmpty())
+	}
+
+	// Output:
+	// [10,40,50,0,0,0,60]
+	// [10,40,50,60]
+	// ["a","b","c","d"]
+}
+
+func ExampleTArray_IsEmpty() {
+	{
+		s := garray.NewTArrayFrom(g.SliceInt{10, 20, 15, 30, 40, 50, 60})
+		fmt.Println(s.IsEmpty())
+		s1 := garray.NewTArray[int]()
+		fmt.Println(s1.IsEmpty())
+	}
+	{
+		s := garray.NewTArrayFrom[string](g.SliceStr{"a", "b", "", "c", "", "", "d"})
+		fmt.Println(s.IsEmpty())
+		s1 := garray.NewTArray[string]()
+		fmt.Println(s1.IsEmpty())
+	}
+
+	// Output:
+	// false
+	// true
+	// false
+	// true
+}
diff --git a/container/garray/garray_z_example_sorted_str_test.go b/container/garray/garray_z_example_sorted_str_test.go
index bbd3a1aee..bc9424afd 100644
--- a/container/garray/garray_z_example_sorted_str_test.go
+++ b/container/garray/garray_z_example_sorted_str_test.go
@@ -381,7 +381,7 @@ func ExampleSortedStrArray_LockFunc() {
 	fmt.Println(s)
 
 	// Output:
-	// ["a","b","GF fans"]
+	// ["GF fans","a","b"]
 }
 
 func ExampleSortedStrArray_RLockFunc() {
diff --git a/container/garray/garray_z_example_sorted_t_test.go b/container/garray/garray_z_example_sorted_t_test.go
new file mode 100644
index 000000000..86bb694e4
--- /dev/null
+++ b/container/garray/garray_z_example_sorted_t_test.go
@@ -0,0 +1,576 @@
+// 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 garray_test
+
+import (
+	"fmt"
+
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gutil"
+)
+
+func ExampleSortedTArray_Walk() {
+	var array garray.SortedTArray[string]
+	array.SetComparator(gutil.ComparatorT)
+	tables := g.SliceStr{"user", "user_detail"}
+	prefix := "gf_"
+	array.Append(tables...)
+	// Add prefix for given table names.
+	array.Walk(func(value string) string {
+		return prefix + value
+	})
+	fmt.Println(array.Slice())
+
+	// Output:
+	// [gf_user gf_user_detail]
+}
+
+func ExampleNewSortedTArray() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.Append("b")
+	s.Append("d")
+	s.Append("c")
+	s.Append("a")
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d]
+}
+
+func ExampleNewSortedTArraySize() {
+	s := garray.NewSortedTArraySize[string](3, gutil.ComparatorT)
+	s.SetArray([]string{"b", "d", "a", "c"})
+	fmt.Println(s.Slice(), s.Len(), cap(s.Slice()))
+
+	// Output:
+	// [a b c d] 4 4
+}
+
+func ExampleNewSortedTArrayFromCopy() {
+	s := garray.NewSortedTArrayFromCopy(g.SliceStr{"b", "d", "c", "a"}, gutil.ComparatorT)
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d]
+}
+
+func ExampleSortedTArray_At() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "d", "c", "a"}, gutil.ComparatorT)
+	sAt := s.At(2)
+	fmt.Println(s)
+	fmt.Println(sAt)
+
+	// Output:
+	// ["a","b","c","d"]
+	// c
+
+}
+
+func ExampleSortedTArray_Get() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "d", "c", "a", "e"}, gutil.ComparatorT)
+	sGet, sBool := s.Get(3)
+	fmt.Println(s)
+	fmt.Println(sGet, sBool)
+
+	// Output:
+	// ["a","b","c","d","e"]
+	// d true
+}
+
+func ExampleSortedTArray_SetArray() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray([]string{"b", "d", "a", "c"})
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d]
+}
+
+func ExampleSortedTArray_SetUnique() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray([]string{"b", "d", "a", "c", "c", "a"})
+	fmt.Println(s.SetUnique(true))
+
+	// Output:
+	// ["a","b","c","d"]
+}
+
+func ExampleSortedTArray_Sum() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray([]string{"5", "3", "2"})
+	fmt.Println(s)
+	a := s.Sum()
+	fmt.Println(a)
+
+	// Output:
+	// [2,3,5]
+	// 10
+}
+
+func ExampleSortedTArray_Sort() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"b", "d", "a", "c"})
+	fmt.Println(s)
+	a := s.Sort()
+	fmt.Println(a)
+
+	// Output:
+	// ["a","b","c","d"]
+	// ["a","b","c","d"]
+}
+
+func ExampleSortedTArray_Remove() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"b", "d", "c", "a"})
+	fmt.Println(s.Slice())
+	s.Remove(1)
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d]
+	// [a c d]
+}
+
+func ExampleSortedTArray_RemoveValue() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"b", "d", "c", "a"})
+	fmt.Println(s.Slice())
+	s.RemoveValue("b")
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d]
+	// [a c d]
+}
+
+func ExampleSortedTArray_PopLeft() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"b", "d", "c", "a"})
+	r, _ := s.PopLeft()
+	fmt.Println(r)
+	fmt.Println(s.Slice())
+
+	// Output:
+	// a
+	// [b c d]
+}
+
+func ExampleSortedTArray_PopRight() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"b", "d", "c", "a"})
+	fmt.Println(s.Slice())
+	r, _ := s.PopRight()
+	fmt.Println(r)
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d]
+	// d
+	// [a b c]
+}
+
+func ExampleSortedTArray_PopRights() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.PopRights(2)
+	fmt.Println(r)
+	fmt.Println(s)
+
+	// Output:
+	// [g h]
+	// ["a","b","c","d","e","f"]
+}
+
+func ExampleSortedTArray_Rand() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r, _ := s.PopRand()
+	fmt.Println(r)
+	fmt.Println(s)
+
+	// May Output:
+	// b
+	// ["a","c","d","e","f","g","h"]
+}
+
+func ExampleSortedTArray_PopRands() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.PopRands(2)
+	fmt.Println(r)
+	fmt.Println(s)
+
+	// May Output:
+	// [d a]
+	// ["b","c","e","f","g","h"]
+}
+
+func ExampleSortedTArray_PopLefts() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.PopLefts(2)
+	fmt.Println(r)
+	fmt.Println(s)
+
+	// Output:
+	// [a b]
+	// ["c","d","e","f","g","h"]
+}
+
+func ExampleSortedTArray_Range() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.Range(2, 5)
+	fmt.Println(r)
+
+	// Output:
+	// [c d e]
+}
+
+func ExampleSortedTArray_SubSlice() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.SubSlice(3, 4)
+	fmt.Println(s.Slice())
+	fmt.Println(r)
+
+	// Output:
+	// [a b c d e f g h]
+	// [d e f g]
+}
+
+func ExampleSortedTArray_Add() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.Add("b", "d", "c", "a")
+	fmt.Println(s)
+
+	// Output:
+	// ["a","b","c","d"]
+}
+
+func ExampleSortedTArray_Append() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"b", "d", "c", "a"})
+	fmt.Println(s)
+	s.Append("f", "e", "g")
+	fmt.Println(s)
+
+	// Output:
+	// ["a","b","c","d"]
+	// ["a","b","c","d","e","f","g"]
+}
+
+func ExampleSortedTArray_Len() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	fmt.Println(s)
+	fmt.Println(s.Len())
+
+	// Output:
+	// ["a","b","c","d","e","f","g","h"]
+	// 8
+}
+
+func ExampleSortedTArray_Slice() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d e f g h]
+}
+
+func ExampleSortedTArray_Interfaces() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.Interfaces()
+	fmt.Println(r)
+
+	// Output:
+	// [a b c d e f g h]
+}
+
+func ExampleSortedTArray_Clone() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.Clone()
+	fmt.Println(r)
+	fmt.Println(s)
+
+	// Output:
+	// ["a","b","c","d","e","f","g","h"]
+	// ["a","b","c","d","e","f","g","h"]
+}
+
+func ExampleSortedTArray_Clear() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	fmt.Println(s)
+	fmt.Println(s.Clear())
+	fmt.Println(s)
+
+	// Output:
+	// ["a","b","c","d","e","f","g","h"]
+	// []
+	// []
+}
+
+func ExampleSortedTArray_Contains() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	fmt.Println(s.Contains("e"))
+	fmt.Println(s.Contains("E"))
+	fmt.Println(s.Contains("z"))
+
+	// Output:
+	// true
+	// false
+	// false
+}
+
+func ExampleSortedTArray_Search() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	fmt.Println(s)
+	fmt.Println(s.Search("e"))
+	fmt.Println(s.Search("E"))
+	fmt.Println(s.Search("z"))
+
+	// Output:
+	// ["a","b","c","d","e","f","g","h"]
+	// 4
+	// -1
+	// -1
+}
+
+func ExampleSortedTArray_Unique() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"a", "b", "c", "c", "c", "d", "d"})
+	fmt.Println(s)
+	fmt.Println(s.Unique())
+
+	// Output:
+	// ["a","b","c","c","c","d","d"]
+	// ["a","b","c","d"]
+}
+
+func ExampleSortedTArray_LockFunc() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	s.LockFunc(func(array []string) {
+		array[len(array)-1] = "GF fans"
+	})
+	fmt.Println(s)
+
+	// Output:
+	// ["GF fans","a","b"]
+}
+
+func ExampleSortedTArray_RLockFunc() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	s.RLockFunc(func(array []string) {
+		array[len(array)-1] = "GF fans"
+		fmt.Println(array[len(array)-1])
+	})
+	fmt.Println(s)
+
+	// Output:
+	// GF fans
+	// ["a","b","GF fans"]
+}
+
+func ExampleSortedTArray_Merge() {
+	s1 := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s2 := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s1.SetArray(g.SliceStr{"b", "c", "a"})
+	s2.SetArray(g.SliceStr{"e", "d", "f"})
+	fmt.Println(s1)
+	fmt.Println(s2)
+	s1.Merge(s2)
+	fmt.Println(s1)
+
+	// Output:
+	// ["a","b","c"]
+	// ["d","e","f"]
+	// ["a","b","c","d","e","f"]
+}
+
+func ExampleSortedTArray_Chunk() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"}, gutil.ComparatorT)
+	r := s.Chunk(3)
+	fmt.Println(r)
+
+	// Output:
+	// [[a b c] [d e f] [g h]]
+}
+
+func ExampleSortedTArray_Rands() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"}, gutil.ComparatorT)
+	fmt.Println(s)
+	fmt.Println(s.Rands(3))
+
+	// May Output:
+	// ["a","b","c","d","e","f","g","h"]
+	// [h g c]
+}
+
+func ExampleSortedTArray_Join() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"}, gutil.ComparatorT)
+	fmt.Println(s.Join(","))
+
+	// Output:
+	// a,b,c,d,e,f,g,h
+}
+
+func ExampleSortedTArray_CountValues() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"a", "b", "c", "c", "c", "d", "d"}, gutil.ComparatorT)
+	fmt.Println(s.CountValues())
+
+	// Output:
+	// map[a:1 b:1 c:3 d:2]
+}
+
+func ExampleSortedTArray_Iterator() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	s.Iterator(func(k int, v string) bool {
+		fmt.Println(k, v)
+		return true
+	})
+
+	// Output:
+	// 0 a
+	// 1 b
+	// 2 c
+}
+
+func ExampleSortedTArray_IteratorAsc() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	s.IteratorAsc(func(k int, v string) bool {
+		fmt.Println(k, v)
+		return true
+	})
+
+	// Output:
+	// 0 a
+	// 1 b
+	// 2 c
+}
+
+func ExampleSortedTArray_IteratorDesc() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	s.IteratorDesc(func(k int, v string) bool {
+		fmt.Println(k, v)
+		return true
+	})
+
+	// Output:
+	// 2 c
+	// 1 b
+	// 0 a
+}
+
+func ExampleSortedTArray_String() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	fmt.Println(s.String())
+
+	// Output:
+	// ["a","b","c"]
+}
+
+func ExampleSortedTArray_MarshalJSON() {
+	type Student struct {
+		ID     int
+		Name   string
+		Levels garray.SortedTArray[string]
+	}
+	r := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	s := Student{
+		ID:     1,
+		Name:   "john",
+		Levels: *r,
+	}
+	b, _ := json.Marshal(s)
+	fmt.Println(string(b))
+
+	// Output:
+	// {"ID":1,"Name":"john","Levels":["a","b","c"]}
+}
+
+func ExampleSortedTArray_UnmarshalJSON() {
+	b := []byte(`{"Id":1,"Name":"john","Lessons":["Math","English","Sport"]}`)
+	type Student struct {
+		Id      int
+		Name    string
+		Lessons *garray.StrArray
+	}
+	s := Student{}
+	json.Unmarshal(b, &s)
+	fmt.Println(s)
+
+	// Output:
+	// {1 john ["Math","English","Sport"]}
+}
+
+func ExampleSortedTArray_UnmarshalValue() {
+	type Student struct {
+		Name    string
+		Lessons *garray.StrArray
+	}
+	var s *Student
+	gconv.Struct(g.Map{
+		"name":    "john",
+		"lessons": []byte(`["Math","English","Sport"]`),
+	}, &s)
+	fmt.Println(s)
+
+	var s1 *Student
+	gconv.Struct(g.Map{
+		"name":    "john",
+		"lessons": g.SliceStr{"Math", "English", "Sport"},
+	}, &s1)
+	fmt.Println(s1)
+
+	// Output:
+	// &{john ["Math","English","Sport"]}
+	// &{john ["Math","English","Sport"]}
+}
+
+func ExampleSortedTArray_Filter() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "a", "", "c", "", "", "d"}, gutil.ComparatorT)
+	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 ExampleSortedTArray_FilterEmpty() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "a", "", "c", "", "", "d"}, gutil.ComparatorT)
+	fmt.Println(s)
+	fmt.Println(s.FilterEmpty())
+
+	// Output:
+	// ["","","","a","b","c","d"]
+	// ["a","b","c","d"]
+}
+
+func ExampleSortedTArray_IsEmpty() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "a", "", "c", "", "", "d"}, gutil.ComparatorT)
+	fmt.Println(s.IsEmpty())
+	s1 := garray.NewSortedTArray[string](gutil.ComparatorT)
+	fmt.Println(s1.IsEmpty())
+
+	// Output:
+	// false
+	// true
+}
diff --git a/container/garray/garray_z_unit_normal_t_test.go b/container/garray/garray_z_unit_normal_t_test.go
new file mode 100644
index 000000000..4b2032dfb
--- /dev/null
+++ b/container/garray/garray_z_unit_normal_t_test.go
@@ -0,0 +1,856 @@
+// 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.
+
+// go test *.go
+
+package garray_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+func Test_TArray_Basic(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		expect := []int{0, 1, 2, 3}
+		array := garray.NewTArrayFrom(expect)
+		array2 := garray.NewTArrayFrom(expect)
+		array3 := garray.NewTArrayFrom([]int{})
+
+		t.Assert(array.Slice(), expect)
+		t.Assert(array.Interfaces(), expect)
+		err := array.Set(0, 100) // 100, 1, 2, 3
+		t.AssertNil(err)
+
+		err = array.Set(100, 100)
+		t.AssertNE(err, nil)
+
+		t.Assert(array.IsEmpty(), false)
+
+		copyArray := array.DeepCopy()
+		ca := copyArray.(*garray.TArray[int])
+		ca.Set(0, 1)
+		cval, _ := ca.Get(0)
+		val, _ := array.Get(0)
+		t.AssertNE(cval, val)
+
+		v, ok := array.Get(0)
+		t.Assert(v, 100)
+		t.Assert(ok, true)
+
+		v, ok = array.Get(1)
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+
+		v, ok = array.Get(4)
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+
+		t.Assert(array.Search(100), 0)
+		t.Assert(array3.Search(100), -1)
+		t.Assert(array.Contains(100), true)
+
+		v, ok = array.Remove(0) // 1, 2, 3
+		t.Assert(v, 100)
+		t.Assert(ok, true)
+		t.Assert(array.Slice(), []int{1, 2, 3})
+
+		v, ok = array.Remove(-1)
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+		t.Assert(array.Slice(), []int{1, 2, 3})
+
+		v, ok = array.Remove(100000)
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+		t.Assert(array.Slice(), []int{1, 2, 3})
+
+		v, ok = array2.Remove(3) // 0 1 2
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+
+		v, ok = array2.Remove(1) // 0 2
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+
+		t.Assert(array.Contains(100), false)
+		array.Append(4) // 2, 2, 3, 4
+		t.Assert(array.Slice(), []int{2, 2, 3, 4})
+		t.Assert(array.Len(), 4)
+		array.InsertBefore(0, 100) // 100, 2, 2, 3, 4
+		t.Assert(array.Slice(), []int{100, 2, 2, 3, 4})
+		array.InsertAfter(0, 200) // 100, 200, 2, 2, 3, 4
+		t.Assert(array.Slice(), []int{100, 200, 2, 2, 3, 4})
+		array.InsertBefore(5, 300)
+		array.InsertAfter(6, 400)
+		t.Assert(array.Slice(), []int{100, 200, 2, 2, 3, 300, 4, 400})
+		t.Assert(array.Clear().Len(), 0)
+		err = array.InsertBefore(99, 9900)
+		t.AssertNE(err, nil)
+		err = array.InsertAfter(99, 9900)
+		t.AssertNE(err, nil)
+
+		t.Assert(array.String(), "[]")
+	})
+}
+
+func TestTArray_Sort(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		expect1 := []any{0, 1, 2, 3}
+		expect2 := []any{3, 2, 1, 0}
+		array := garray.NewTArray[int]()
+		for i := 3; i >= 0; i-- {
+			array.Append(i)
+		}
+		array.SortFunc(func(v1, v2 int) bool {
+			return v1 < v2
+		})
+		t.Assert(array.Slice(), expect1)
+		array.SortFunc(func(v1, v2 int) bool {
+			return v1 > v2
+		})
+		t.Assert(array.Slice(), expect2)
+	})
+}
+
+func TestTArray_Unique(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		expect := []int{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
+		array := garray.NewTArrayFrom(expect)
+		t.Assert(array.Unique().Slice(), []int{1, 2, 3, 4, 5})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		expect := []int{}
+		array := garray.NewTArrayFrom(expect)
+		t.Assert(array.Unique().Slice(), []int{})
+	})
+}
+
+func TestTArray_PushAndPop(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		expect := []any{0, 1, 2, 3}
+		array := garray.NewTArrayFrom(expect)
+		t.Assert(array.Slice(), expect)
+
+		v, ok := array.PopLeft()
+		t.Assert(v, 0)
+		t.Assert(ok, true)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+
+		v, ok = array.PopRand()
+		t.AssertIN(v, []any{1, 2})
+		t.Assert(ok, true)
+
+		v, ok = array.PopRand()
+		t.AssertIN(v, []any{1, 2})
+		t.Assert(ok, true)
+
+		t.Assert(array.Len(), 0)
+		array.PushLeft(1).PushRight(2)
+		t.Assert(array.Slice(), []any{1, 2})
+	})
+}
+
+func TestTArray_PopRands(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{100, 200, 300, 400, 500, 600}
+		array := garray.NewFromCopy(a1)
+		t.AssertIN(array.PopRands(2), []any{100, 200, 300, 400, 500, 600})
+	})
+}
+
+func TestTArray_PopLeft(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewFrom(g.Slice{1, 2, 3})
+		v, ok := array.PopLeft()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+		v, ok = array.PopLeft()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+		v, ok = array.PopLeft()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestTArray_PopRight(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewFrom(g.Slice{1, 2, 3})
+
+		v, ok := array.PopRight()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestTArray_PopLefts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewFrom(g.Slice{1, 2, 3})
+		t.Assert(array.PopLefts(2), g.Slice{1, 2})
+		t.Assert(array.Len(), 1)
+		t.Assert(array.PopLefts(2), g.Slice{3})
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestTArray_PopRights(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewFrom(g.Slice{1, 2, 3})
+		t.Assert(array.PopRights(2), g.Slice{2, 3})
+		t.Assert(array.Len(), 1)
+		t.Assert(array.PopLefts(2), g.Slice{1})
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestTArray_PopLeftsAndPopRights(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.New()
+		v, ok := array.PopLeft()
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+		t.Assert(array.PopLefts(10), nil)
+
+		v, ok = array.PopRight()
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+		t.Assert(array.PopRights(10), nil)
+
+		v, ok = array.PopRand()
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+		t.Assert(array.PopRands(10), nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		value1 := []any{0, 1, 2, 3, 4, 5, 6}
+		value2 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(value1)
+		array2 := garray.NewTArrayFrom(value2)
+		t.Assert(array1.PopLefts(2), []any{0, 1})
+		t.Assert(array1.Slice(), []any{2, 3, 4, 5, 6})
+		t.Assert(array1.PopRights(2), []any{5, 6})
+		t.Assert(array1.Slice(), []any{2, 3, 4})
+		t.Assert(array1.PopRights(20), []any{2, 3, 4})
+		t.Assert(array1.Slice(), []any{})
+		t.Assert(array2.PopLefts(20), []any{0, 1, 2, 3, 4, 5, 6})
+		t.Assert(array2.Slice(), []any{})
+	})
+}
+
+func TestTArray_Range(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		value1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(value1)
+		array2 := garray.NewTArrayFrom(value1, true)
+		t.Assert(array1.Range(0, 1), []any{0})
+		t.Assert(array1.Range(1, 2), []any{1})
+		t.Assert(array1.Range(0, 2), []any{0, 1})
+		t.Assert(array1.Range(-1, 10), value1)
+		t.Assert(array1.Range(10, 2), nil)
+		t.Assert(array2.Range(1, 3), []any{1, 2})
+	})
+}
+
+func TestTArray_Merge(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		func1 := func(v1, v2 any) int {
+			if gconv.Int(v1) < gconv.Int(v2) {
+				return 0
+			}
+			return 1
+		}
+
+		i1 := []any{0, 1, 2, 3}
+		i2 := []any{4, 5, 6, 7}
+		array1 := garray.NewTArrayFrom(i1)
+		array2 := garray.NewTArrayFrom(i2)
+		t.Assert(array1.Merge(array2).Slice(), []any{0, 1, 2, 3, 4, 5, 6, 7})
+
+		// s1 := []string{"a", "b", "c", "d"}
+		s2 := []string{"e", "f"}
+		i3 := garray.NewIntArrayFrom([]int{1, 2, 3})
+		i4 := garray.NewTArrayFrom([]any{3})
+		s3 := garray.NewStrArrayFrom([]string{"g", "h"})
+		s4 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
+		s5 := garray.NewSortedStrArrayFrom(s2)
+		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
+		a1 := garray.NewTArrayFrom(i1)
+
+		t.Assert(a1.Merge(s2).Len(), 6)
+		t.Assert(a1.Merge(i3).Len(), 9)
+		t.Assert(a1.Merge(i4).Len(), 10)
+		t.Assert(a1.Merge(s3).Len(), 12)
+		t.Assert(a1.Merge(s4).Len(), 14)
+		t.Assert(a1.Merge(s5).Len(), 16)
+		t.Assert(a1.Merge(s6).Len(), 19)
+	})
+}
+
+func TestTArray_Fill(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0}
+		a2 := []any{0}
+		array1 := garray.NewTArrayFrom(a1)
+		array2 := garray.NewTArrayFrom(a2, true)
+
+		t.Assert(array1.Fill(1, 2, 100), nil)
+		t.Assert(array1.Slice(), []any{0, 100, 100})
+
+		t.Assert(array2.Fill(0, 2, 100), nil)
+		t.Assert(array2.Slice(), []any{100, 100})
+
+		t.AssertNE(array2.Fill(-1, 2, 100), nil)
+		t.Assert(array2.Slice(), []any{100, 100})
+	})
+}
+
+func TestTArray_Chunk(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{1, 2, 3, 4, 5}
+		array1 := garray.NewTArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		t.Assert(len(chunks), 3)
+		t.Assert(chunks[0], []any{1, 2})
+		t.Assert(chunks[1], []any{3, 4})
+		t.Assert(chunks[2], []any{5})
+		t.Assert(array1.Chunk(0), nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{1, 2, 3, 4, 5}
+		array1 := garray.NewTArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		t.Assert(len(chunks), 2)
+		t.Assert(chunks[0], []any{1, 2, 3})
+		t.Assert(chunks[1], []any{4, 5})
+		t.Assert(array1.Chunk(0), nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		t.Assert(len(chunks), 3)
+		t.Assert(chunks[0], []any{1, 2})
+		t.Assert(chunks[1], []any{3, 4})
+		t.Assert(chunks[2], []any{5, 6})
+		t.Assert(array1.Chunk(0), nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		t.Assert(len(chunks), 2)
+		t.Assert(chunks[0], []any{1, 2, 3})
+		t.Assert(chunks[1], []any{4, 5, 6})
+		t.Assert(array1.Chunk(0), nil)
+	})
+}
+
+func TestTArray_Pad(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(array1.Pad(3, 1).Slice(), []any{0, 1, 1})
+		t.Assert(array1.Pad(-4, 1).Slice(), []any{1, 0, 1, 1})
+		t.Assert(array1.Pad(3, 1).Slice(), []any{1, 0, 1, 1})
+	})
+}
+
+func TestTArray_SubSlice(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		array2 := garray.NewTArrayFrom(a1, true)
+		t.Assert(array1.SubSlice(0, 2), []any{0, 1})
+		t.Assert(array1.SubSlice(2, 2), []any{2, 3})
+		t.Assert(array1.SubSlice(5, 8), []any{5, 6})
+		t.Assert(array1.SubSlice(9, 1), nil)
+		t.Assert(array1.SubSlice(-2, 2), []any{5, 6})
+		t.Assert(array1.SubSlice(-9, 2), nil)
+		t.Assert(array1.SubSlice(1, -2), nil)
+		t.Assert(array2.SubSlice(0, 2), []any{0, 1})
+	})
+}
+
+func TestTArray_Rand(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(len(array1.Rands(2)), 2)
+		t.Assert(len(array1.Rands(10)), 10)
+		t.AssertIN(array1.Rands(1)[0], a1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []any{"a", "b", "c", "d"}
+		a1 := garray.NewTArrayFrom(s1)
+		i1, ok := a1.Rand()
+		t.Assert(ok, true)
+		t.Assert(a1.Contains(i1), true)
+		t.Assert(a1.Len(), 4)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{}
+		array1 := garray.NewTArrayFrom(a1)
+		rand, found := array1.Rand()
+		t.AssertNil(rand)
+		t.Assert(found, false)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{}
+		array1 := garray.NewTArrayFrom(a1)
+		rand := array1.Rands(1)
+		t.AssertNil(rand)
+	})
+}
+
+func TestTArray_Shuffle(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(array1.Shuffle().Len(), 7)
+	})
+}
+
+func TestTArray_Reverse(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(array1.Reverse().Slice(), []any{6, 5, 4, 3, 2, 1, 0})
+	})
+}
+
+func TestTArray_Join(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(array1.Join("."), `0.1.2.3.4.5.6`)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, `"a"`, `\a`}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(array1.Join("."), `0.1."a".\a`)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(len(array1.Join(".")), 0)
+	})
+}
+
+func TestTArray_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(array1.String(), `[0,1,2,3,4,5,6]`)
+		array1 = nil
+		t.Assert(array1.String(), "")
+	})
+}
+
+func TestTArray_Replace(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		a2 := []any{"a", "b", "c"}
+		a3 := []any{"m", "n", "p", "z", "x", "y", "d", "u"}
+		array1 := garray.NewTArrayFrom(a1)
+		array2 := array1.Replace(a2)
+		t.Assert(array2.Len(), 7)
+		t.Assert(array2.Contains("b"), true)
+		t.Assert(array2.Contains(4), true)
+		t.Assert(array2.Contains("v"), false)
+		array3 := array1.Replace(a3)
+		t.Assert(array3.Len(), 7)
+		t.Assert(array3.Contains(4), false)
+		t.Assert(array3.Contains("p"), true)
+		t.Assert(array3.Contains("u"), false)
+	})
+}
+
+func TestTArray_SetArray(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		a2 := []any{"a", "b", "c"}
+
+		array1 := garray.NewTArrayFrom(a1)
+		array1 = array1.SetArray(a2)
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1.Contains("b"), true)
+		t.Assert(array1.Contains("5"), false)
+	})
+}
+
+func TestTArray_Sum(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3}
+		a2 := []any{"a", "b", "c"}
+		a3 := []any{"a", "1", "2"}
+
+		array1 := garray.NewTArrayFrom(a1)
+		array2 := garray.NewTArrayFrom(a2)
+		array3 := garray.NewTArrayFrom(a3)
+
+		t.Assert(array1.Sum(), 6)
+		t.Assert(array2.Sum(), 0)
+		t.Assert(array3.Sum(), 3)
+
+	})
+}
+
+func TestTArray_Clone(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3}
+		array1 := garray.NewTArrayFrom(a1)
+		array2 := array1.Clone()
+
+		t.Assert(array1.Len(), 4)
+		t.Assert(array2.Sum(), 6)
+		t.AssertEQ(array1, array2)
+
+	})
+}
+
+func TestTArray_CountValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{"a", "b", "c", "d", "e", "d"}
+		array1 := garray.NewTArrayFrom(a1)
+		array2 := array1.CountValues()
+		t.Assert(len(array2), 5)
+		t.Assert(array2["b"], 1)
+		t.Assert(array2["d"], 2)
+	})
+}
+
+func TestTArray_LockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []any{"a", "b", "c", "d"}
+		a1 := garray.NewTArrayFrom(s1, true)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 3)
+		// go1
+		go a1.LockFunc(func(n1 []any) { // 读写锁
+			time.Sleep(2 * time.Second) // 暂停2秒
+			n1[2] = "g"
+			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		})
+
+		// go2
+		go func() {
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		<-ch2 // 等待go1完成
+
+		// 防止ci抖动,以豪秒为单位
+		t.AssertGT(t2-t1, 20) // go1加的读写互斥锁，所go2读的时候被阻塞。
+		t.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestTArray_RLockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []any{"a", "b", "c", "d"}
+		a1 := garray.NewTArrayFrom(s1, true)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 1)
+		// go1
+		go a1.RLockFunc(func(n1 []any) { // read lock
+			time.Sleep(2 * time.Second) // sleep 2 s
+			n1[2] = "g"
+			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		})
+
+		// go2
+		go func() {
+			time.Sleep(100 * time.Millisecond) // wait go1 do line lock for 0.01s. Then do.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		<-ch2 // wait for go1 done.
+
+		//  Prevent CI jitter, in milliseconds.
+		t.AssertLT(t2-t1, 20) // Go1 acquired a read lock, so when Go2 reads, it is not blocked.
+		t.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestTArray_Json(t *testing.T) {
+	// pointer
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []any{"a", "b", "d", "c"}
+		a1 := garray.NewTArrayFrom(s1)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
+
+		a2 := garray.New()
+		err2 = json.UnmarshalUseNumber(b2, &a2)
+		t.Assert(err2, nil)
+		t.Assert(a2.Slice(), s1)
+
+		var a3 garray.Array
+		err := json.UnmarshalUseNumber(b2, &a3)
+		t.AssertNil(err)
+		t.Assert(a3.Slice(), s1)
+	})
+	// value.
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []any{"a", "b", "d", "c"}
+		a1 := *garray.NewTArrayFrom(s1)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
+
+		a2 := garray.New()
+		err2 = json.UnmarshalUseNumber(b2, &a2)
+		t.Assert(err2, nil)
+		t.Assert(a2.Slice(), s1)
+
+		var a3 garray.Array
+		err := json.UnmarshalUseNumber(b2, &a3)
+		t.AssertNil(err)
+		t.Assert(a3.Slice(), s1)
+	})
+	// pointer
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores *garray.Array
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []int{99, 100, 98},
+		}
+		b, err := json.Marshal(data)
+		t.AssertNil(err)
+
+		user := new(User)
+		err = json.UnmarshalUseNumber(b, user)
+		t.AssertNil(err)
+		t.Assert(user.Name, data["Name"])
+		t.Assert(user.Scores, data["Scores"])
+	})
+	// value
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores garray.Array
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []int{99, 100, 98},
+		}
+		b, err := json.Marshal(data)
+		t.AssertNil(err)
+
+		user := new(User)
+		err = json.UnmarshalUseNumber(b, user)
+		t.AssertNil(err)
+		t.Assert(user.Name, data["Name"])
+		t.Assert(user.Scores, data["Scores"])
+	})
+}
+
+func TestTArray_Iterator(t *testing.T) {
+	slice := g.Slice{"a", "b", "d", "c"}
+	array := garray.NewTArrayFrom(slice)
+	gtest.C(t, func(t *gtest.T) {
+		array.Iterator(func(k int, v any) bool {
+			t.Assert(v, slice[k])
+			return true
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array.IteratorAsc(func(k int, v any) bool {
+			t.Assert(v, slice[k])
+			return true
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array.IteratorDesc(func(k int, v any) bool {
+			t.Assert(v, slice[k])
+			return true
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		index := 0
+		array.Iterator(func(k int, v any) bool {
+			index++
+			return false
+		})
+		t.Assert(index, 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		index := 0
+		array.IteratorAsc(func(k int, v any) bool {
+			index++
+			return false
+		})
+		t.Assert(index, 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		index := 0
+		array.IteratorDesc(func(k int, v any) bool {
+			index++
+			return false
+		})
+		t.Assert(index, 1)
+	})
+}
+
+func TestTArray_RemoveValue(t *testing.T) {
+	slice := g.Slice{"a", "b", "d", "c"}
+	array := garray.NewTArrayFrom(slice)
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(array.RemoveValue("e"), false)
+		t.Assert(array.RemoveValue("b"), true)
+		t.Assert(array.RemoveValue("a"), true)
+		t.Assert(array.RemoveValue("c"), true)
+		t.Assert(array.RemoveValue("f"), false)
+	})
+}
+
+func TestTArray_RemoveValues(t *testing.T) {
+	slice := g.SliceStr{"a", "b", "d", "c"}
+	array := garray.NewTArrayFrom(slice)
+	gtest.C(t, func(t *gtest.T) {
+		array.RemoveValues("a", "b", "c")
+		t.Assert(array.Slice(), g.Slice{"d"})
+	})
+}
+
+func TestTArray_UnmarshalValue(t *testing.T) {
+	type V struct {
+		Name  string
+		Array *garray.Array
+	}
+	// JSON
+	gtest.C(t, func(t *gtest.T) {
+		var v *V
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": []byte(`[1,2,3]`),
+		}, &v)
+		t.AssertNil(err)
+		t.Assert(v.Name, "john")
+		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
+	})
+	// Map
+	gtest.C(t, func(t *gtest.T) {
+		var v *V
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": g.Slice{1, 2, 3},
+		}, &v)
+		t.AssertNil(err)
+		t.Assert(v.Name, "john")
+		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
+	})
+}
+
+func TestTArray_FilterNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
+		array := garray.NewTArrayFromCopy(values)
+		t.Assert(array.FilterNil().Slice(), values)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFromCopy(g.Slice{nil, 1, 2, 3, 4, nil})
+		t.Assert(array.FilterNil(), g.Slice{1, 2, 3, 4})
+	})
+}
+
+func TestTArray_Filter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
+		array := garray.NewTArrayFromCopy(values)
+		t.Assert(array.Filter(func(index int, value any) bool {
+			return empty.IsNil(value)
+		}).Slice(), values)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFromCopy(g.Slice{nil, 1, 2, 3, 4, nil})
+		t.Assert(array.Filter(func(index int, value any) bool {
+			return empty.IsNil(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}})
+
+		t.Assert(array.Filter(func(index int, value any) bool {
+			return empty.IsEmpty(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFrom(g.Slice{1, 2, 3, 4})
+
+		t.Assert(array.Filter(func(index int, value any) bool {
+			return empty.IsEmpty(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+}
+
+func TestTArray_FilterEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}})
+		t.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFrom(g.Slice{1, 2, 3, 4})
+		t.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+	})
+}
+
+func TestTArray_Walk(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFrom(g.Slice{"1", "2"})
+		t.Assert(array.Walk(func(value any) any {
+			return "key-" + gconv.String(value)
+		}), g.Slice{"key-1", "key-2"})
+	})
+}
diff --git a/container/garray/garray_z_unit_sorted_any_test.go b/container/garray/garray_z_unit_sorted_any_test.go
index 9d6a80e24..28e7413b4 100644
--- a/container/garray/garray_z_unit_sorted_any_test.go
+++ b/container/garray/garray_z_unit_sorted_any_test.go
@@ -939,25 +939,30 @@ func TestSortedArray_Filter(t *testing.T) {
 
 func TestSortedArray_FilterNil(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
+		values := g.Slice{0, 1, 2, 3, 4, "", nil, g.Slice{}}
 		array := garray.NewSortedArrayFromCopy(values, gutil.ComparatorInt)
 		t.Assert(array.FilterNil().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)
+		array := garray.NewSortedArrayFromCopy(g.Slice{nil, 1, 2, nil, 3, 4, nil}, gutil.ComparatorInt)
 		t.Assert(array.FilterNil(), g.Slice{1, 2, 3, 4})
 	})
 }
 
 func TestSortedArray_FilterEmpty(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		array := garray.NewSortedArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}, gutil.ComparatorInt)
-		t.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+		array := garray.NewSortedArrayFrom(g.Slice{0, 1, 2, 0, -1, 3, 4, "", g.Slice{}}, gutil.ComparatorInt)
+		t.Assert(array.FilterEmpty(), g.Slice{-1, 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.FilterEmpty(), g.Slice{1, 2, 3, 4})
 	})
+	gtest.C(t, func(t *gtest.T) {
+		values := g.Slice{0, 1, 2, 3, 4, -1, -2, nil, []any{}, ""}
+		array := garray.NewSortedArrayFrom(values, gutil.ComparatorString)
+		t.Assert(array.FilterEmpty().Slice(), g.Slice{-1, -2, 1, 2, 3, 4})
+	})
 }
 
 func TestSortedArray_Walk(t *testing.T) {
diff --git a/container/garray/garray_z_unit_sorted_int_test.go b/container/garray/garray_z_unit_sorted_int_test.go
index b218ada96..f599e2924 100644
--- a/container/garray/garray_z_unit_sorted_int_test.go
+++ b/container/garray/garray_z_unit_sorted_int_test.go
@@ -794,8 +794,22 @@ func TestSortedIntArray_Filter(t *testing.T) {
 
 func TestSortedIntArray_FilterEmpty(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		array := garray.NewSortedIntArrayFrom(g.SliceInt{0, 1, 2, 3, 4, 0})
-		t.Assert(array.FilterEmpty(), g.SliceInt{1, 2, 3, 4})
+		array := garray.NewSortedIntArrayFrom(g.SliceInt{0, 1, -1, 2, 3, 4, 0})
+		t.Assert(array.FilterEmpty(), g.SliceInt{-1, 1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedIntArrayFrom(g.SliceInt{0, 0, 0, 0, 0, 0, 1})
+		array.SetComparator(func(a, b int) int {
+			if a == b {
+				return 0
+			}
+			if a < b {
+				return 1
+			} else {
+				return -1
+			}
+		})
+		t.Assert(array.FilterEmpty(), g.SliceInt{1})
 	})
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewSortedIntArrayFrom(g.SliceInt{1, 2, 3, 4})
diff --git a/container/garray/garray_z_unit_sorted_str_test.go b/container/garray/garray_z_unit_sorted_str_test.go
index b67d2fe90..0a0cfafd5 100644
--- a/container/garray/garray_z_unit_sorted_str_test.go
+++ b/container/garray/garray_z_unit_sorted_str_test.go
@@ -806,9 +806,23 @@ func TestSortedStrArray_Filter(t *testing.T) {
 
 func TestSortedStrArray_FilterEmpty(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		array := garray.NewSortedStrArrayFrom(g.SliceStr{"", "1", "2", "0"})
+		array := garray.NewSortedStrArrayFrom(g.SliceStr{"", "1", "", "2", "0", ""})
 		t.Assert(array.FilterEmpty(), g.SliceStr{"0", "1", "2"})
 	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedStrArrayFrom(g.SliceStr{"", "", "", "2", "0", "a", "b"})
+		array.SetComparator(func(a, b string) int {
+			if a == b {
+				return 0
+			}
+			if a < b {
+				return 1
+			} else {
+				return -1
+			}
+		})
+		t.Assert(array.FilterEmpty(), g.SliceStr{"b", "a", "2", "0"})
+	})
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewSortedStrArrayFrom(g.SliceStr{"1", "2"})
 		t.Assert(array.FilterEmpty(), g.SliceStr{"1", "2"})
diff --git a/container/garray/garray_z_unit_sorted_t_test.go b/container/garray/garray_z_unit_sorted_t_test.go
new file mode 100644
index 000000000..a366ba77d
--- /dev/null
+++ b/container/garray/garray_z_unit_sorted_t_test.go
@@ -0,0 +1,924 @@
+// 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.
+
+// go test *.go
+
+package garray_test
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gutil"
+)
+
+func TestSortedTArray_NewSortedTArrayFrom(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "f", "c"}
+		a2 := []string{"h", "j", "i", "k"}
+		func1 := func(v1, v2 string) int {
+			return strings.Compare(v1, v2)
+		}
+		func2 := func(v1, v2 string) int {
+			return -1
+		}
+		array1 := garray.NewSortedTArrayFrom(a1, func1)
+		array2 := garray.NewSortedTArrayFrom(a2, func2)
+
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1, []string{"a", "c", "f"})
+
+		t.Assert(array2.Len(), 4)
+		t.Assert(array2, []string{"k", "i", "j", "h"})
+	})
+}
+
+func TestNewSortedTArrayFromCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "f", "c"}
+
+		func1 := func(v1, v2 string) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		func2 := func(v1, v2 string) int {
+			return -1
+		}
+		array1 := garray.NewSortedTArrayFromCopy(a1, func1)
+		array2 := garray.NewSortedTArrayFromCopy(a1, func2)
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1, []string{"a", "c", "f"})
+		t.Assert(array1.Len(), 3)
+		t.Assert(array2, []string{"c", "f", "a"})
+	})
+}
+
+func TestSortedTArray_SetArray(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "f", "c"}
+		a2 := []string{"e", "h", "g", "k"}
+
+		func1 := func(v1, v2 string) int {
+			return strings.Compare(v1, v2)
+		}
+
+		array1 := garray.NewSortedTArrayFrom(a1, func1)
+		array1.SetArray(a2)
+		t.Assert(array1.Len(), 4)
+		t.Assert(array1, []string{"e", "g", "h", "k"})
+	})
+
+}
+
+func TestSortedTArray_Sort(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "f", "c"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		array1.Sort()
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1, []string{"a", "c", "f"})
+	})
+
+}
+
+func TestSortedTArray_Get(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "f", "c"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		v, ok := array1.Get(2)
+		t.Assert(v, "f")
+		t.Assert(ok, true)
+
+		v, ok = array1.Get(1)
+		t.Assert(v, "c")
+		t.Assert(ok, true)
+
+		v, ok = array1.Get(99)
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+	})
+
+}
+
+func TestSortedTArray_At(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "f", "c"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		v := array1.At(2)
+		t.Assert(v, "f")
+	})
+}
+
+func TestSortedTArray_Remove(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		i1, ok := array1.Remove(1)
+		t.Assert(ok, true)
+		t.Assert(gconv.String(i1), "b")
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1.Contains("b"), false)
+
+		v, ok := array1.Remove(-1)
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+
+		v, ok = array1.Remove(100000)
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+
+		i2, ok := array1.Remove(0)
+		t.Assert(ok, true)
+		t.Assert(gconv.String(i2), "a")
+		t.Assert(array1.Len(), 2)
+		t.Assert(array1.Contains("a"), false)
+
+		i3, ok := array1.Remove(1)
+		t.Assert(ok, true)
+		t.Assert(gconv.String(i3), "d")
+		t.Assert(array1.Len(), 1)
+		t.Assert(array1.Contains("d"), false)
+	})
+
+}
+
+func TestSortedTArray_PopLeft(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array1 := garray.NewSortedTArrayFrom(
+			[]string{"a", "d", "c", "b"},
+			gutil.ComparatorT,
+		)
+		i1, ok := array1.PopLeft()
+		t.Assert(ok, true)
+		t.Assert(gconv.String(i1), "a")
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1, []any{"b", "c", "d"})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceInt{1, 2, 3}, gutil.ComparatorT)
+		v, ok := array.PopLeft()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+		v, ok = array.PopLeft()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+		v, ok = array.PopLeft()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestSortedTArray_PopRight(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array1 := garray.NewSortedTArrayFrom(
+			[]string{"a", "d", "c", "b"},
+			gutil.ComparatorT,
+		)
+		i1, ok := array1.PopRight()
+		t.Assert(ok, true)
+		t.Assert(gconv.String(i1), "d")
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1, []any{"a", "b", "c"})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceInt{1, 2, 3}, gutil.ComparatorT)
+		v, ok := array.PopRight()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestSortedTArray_PopRand(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		i1, ok := array1.PopRand()
+		t.Assert(ok, true)
+		t.AssertIN(i1, []string{"a", "d", "c", "b"})
+		t.Assert(array1.Len(), 3)
+
+	})
+}
+
+func TestSortedTArray_PopRands(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		i1 := array1.PopRands(2)
+		t.Assert(len(i1), 2)
+		t.AssertIN(i1, []string{"a", "d", "c", "b"})
+		t.Assert(array1.Len(), 2)
+
+		i2 := array1.PopRands(3)
+		t.Assert(len(i2), 2)
+		t.AssertIN(i2, []string{"a", "d", "c", "b"})
+		t.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedTArray_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArray[int](gutil.ComparatorT)
+		v, ok := array.PopLeft()
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+		t.Assert(array.PopLefts(10), nil)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+		t.Assert(array.PopRights(10), nil)
+
+		v, ok = array.PopRand()
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+		t.Assert(array.PopRands(10), nil)
+	})
+}
+
+func TestSortedTArray_PopLefts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e", "f"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		i1 := array1.PopLefts(2)
+		t.Assert(len(i1), 2)
+		t.AssertIN(i1, []string{"a", "d", "c", "b", "e", "f"})
+		t.Assert(array1.Len(), 4)
+
+		i2 := array1.PopLefts(5)
+		t.Assert(len(i2), 4)
+		t.AssertIN(i2, []string{"a", "d", "c", "b", "e", "f"})
+		t.Assert(array1.Len(), 0)
+	})
+}
+
+func TestSortedTArray_PopRights(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e", "f"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		i1 := array1.PopRights(2)
+		t.Assert(len(i1), 2)
+		t.Assert(i1, []string{"e", "f"})
+		t.Assert(array1.Len(), 4)
+
+		i2 := array1.PopRights(10)
+		t.Assert(len(i2), 4)
+		t.Assert(array1.Len(), 0)
+	})
+}
+
+func TestSortedTArray_Range(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e", "f"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		array2 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT, true)
+		i1 := array1.Range(2, 5)
+		t.Assert(i1, []string{"c", "d", "e"})
+		t.Assert(array1.Len(), 6)
+
+		i2 := array1.Range(7, 5)
+		t.Assert(len(i2), 0)
+		i2 = array1.Range(-1, 2)
+		t.Assert(i2, []string{"a", "b"})
+
+		i2 = array1.Range(4, 10)
+		t.Assert(len(i2), 2)
+		t.Assert(i2, []string{"e", "f"})
+
+		t.Assert(array2.Range(1, 3), []string{"b", "c"})
+
+	})
+}
+
+func TestSortedTArray_Sum(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e", "f"}
+		a2 := []string{"1", "2", "3", "b", "e", "f"}
+		a3 := []string{"4", "5", "6"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		array2 := garray.NewSortedTArrayFrom(a2, gutil.ComparatorT)
+		array3 := garray.NewSortedTArrayFrom(a3, gutil.ComparatorT)
+		t.Assert(array1.Sum(), 0)
+		t.Assert(array2.Sum(), 6)
+		t.Assert(array3.Sum(), 15)
+
+	})
+}
+
+func TestSortedTArray_Clone(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e", "f"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		array2 := array1.Clone()
+		t.Assert(array1, array2)
+		array1.Remove(1)
+		t.AssertNE(array1, array2)
+
+	})
+}
+
+func TestSortedTArray_Clear(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e", "f"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		t.Assert(array1.Len(), 6)
+		array1.Clear()
+		t.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedTArray_Chunk(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		i1 := array1.Chunk(2)
+		t.Assert(len(i1), 3)
+		t.Assert(i1[0], []any{"a", "b"})
+		t.Assert(i1[2], []any{"e"})
+
+		i1 = array1.Chunk(0)
+		t.Assert(len(i1), 0)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int32{1, 2, 3, 4, 5}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		chunks := array1.Chunk(3)
+		t.Assert(len(chunks), 2)
+		t.Assert(chunks[0], []int32{1, 2, 3})
+		t.Assert(chunks[1], []int32{4, 5})
+		t.Assert(array1.Chunk(0), nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		chunks := array1.Chunk(2)
+		t.Assert(len(chunks), 3)
+		t.Assert(chunks[0], []int{1, 2})
+		t.Assert(chunks[1], []int{3, 4})
+		t.Assert(chunks[2], []int{5, 6})
+		t.Assert(array1.Chunk(0), nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		chunks := array1.Chunk(3)
+		t.Assert(len(chunks), 2)
+		t.Assert(chunks[0], []int{1, 2, 3})
+		t.Assert(chunks[1], []int{4, 5, 6})
+		t.Assert(array1.Chunk(0), nil)
+	})
+}
+
+func TestSortedTArray_SubSlice(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		array2 := garray.NewSortedTArrayFrom(a1, nil, true)
+		i1 := array1.SubSlice(2, 3)
+		t.Assert(len(i1), 3)
+		t.Assert(i1, []string{"c", "d", "e"})
+
+		i1 = array1.SubSlice(2, 6)
+		t.Assert(len(i1), 3)
+		t.Assert(i1, []string{"c", "d", "e"})
+
+		i1 = array1.SubSlice(7, 2)
+		t.Assert(len(i1), 0)
+
+		s1 := array1.SubSlice(1, -2)
+		t.Assert(s1, nil)
+
+		s1 = array1.SubSlice(-9, 2)
+		t.Assert(s1, nil)
+		t.Assert(array2.SubSlice(1, 3), []string{"b", "c", "d"})
+
+	})
+}
+
+func TestSortedTArray_Rand(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		i1, ok := array1.Rand()
+		t.Assert(ok, true)
+		t.AssertIN(i1, []string{"a", "d", "c"})
+		t.Assert(array1.Len(), 3)
+
+		array2 := garray.NewSortedTArrayFrom([]string{}, nil)
+		v, ok := array2.Rand()
+		t.Assert(ok, false)
+		t.Assert(v, nil)
+	})
+}
+
+func TestSortedTArray_Rands(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		i1 := array1.Rands(2)
+		t.AssertIN(i1, []string{"a", "d", "c"})
+		t.Assert(len(i1), 2)
+		t.Assert(array1.Len(), 3)
+
+		i1 = array1.Rands(4)
+		t.Assert(len(i1), 4)
+
+		array2 := garray.NewSortedTArrayFrom([]string{}, nil)
+		v := array2.Rands(1)
+		t.Assert(v, nil)
+	})
+}
+
+func TestSortedTArray_Join(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c"}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		t.Assert(array1.Join(","), `a,c,d`)
+		t.Assert(array1.Join("."), `a.c.d`)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"0", "1", `"a"`, `\a`}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		t.Assert(array1.Join("."), `"a".0.1.\a`)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		t.Assert(array1.Join("."), "")
+	})
+}
+
+func TestSortedTArray_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"0", "1", "a", "b"}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		t.Assert(array1.String(), `[0,1,"a","b"]`)
+
+		array1 = nil
+		t.Assert(array1.String(), "")
+	})
+}
+
+func TestSortedTArray_CountValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "c"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		m1 := array1.CountValues()
+		t.Assert(len(m1), 3)
+		t.Assert(m1["c"], 2)
+		t.Assert(m1["a"], 1)
+
+	})
+}
+
+func TestSortedTArray_SetUnique(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		array1.SetUnique(true)
+		t.Assert(array1.Len(), 5)
+		t.Assert(array1, []int{1, 2, 3, 4, 5})
+	})
+}
+
+func TestSortedTArray_Unique(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		array1.Unique()
+		t.Assert(array1.Len(), 5)
+		t.Assert(array1, []int{1, 2, 3, 4, 5})
+
+		array2 := garray.NewSortedTArrayFrom([]int{}, nil)
+		array2.Unique()
+		t.Assert(array2.Len(), 0)
+		t.Assert(array2, []int{})
+	})
+}
+
+func TestSortedTArray_LockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewSortedTArrayFrom(s1, nil, true)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 3)
+		// go1
+		go a1.LockFunc(func(n1 []string) { // 读写锁
+			time.Sleep(2 * time.Second) // 暂停2秒
+			n1[2] = "g"
+			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		})
+
+		// go2
+		go func() {
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		<-ch2 // 等待go1完成
+
+		// 防止ci抖动,以豪秒为单位
+		t.AssertGT(t2-t1, 20) // go1加的读写互斥锁，所go2读的时候被阻塞。
+		t.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestSortedTArray_RLockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewSortedTArrayFrom(s1, nil, true)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 3)
+		// go1
+		go a1.RLockFunc(func(n1 []string) { // 读写锁
+			time.Sleep(2 * time.Second) // 暂停2秒
+			n1[2] = "g"
+			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		})
+
+		// go2
+		go func() {
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		<-ch2 // 等待go1完成
+
+		// 防止ci抖动,以豪秒为单位
+		t.AssertLT(t2-t1, 20) // go1加的读锁，所go2读的时候不会被阻塞。
+		t.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestSortedTArray_Merge(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+
+		s1 := []string{"a", "b", "c", "d"}
+		s2 := []string{"e", "f"}
+		i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
+		i2 := garray.NewArrayFrom([]any{3})
+		s3 := garray.NewStrArrayFrom([]string{"g", "h"})
+		s4 := garray.NewSortedTArrayFrom([]int{4, 5}, nil)
+		s5 := garray.NewSortedStrArrayFrom(s2)
+		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
+
+		a1 := garray.NewSortedTArrayFrom(s1, nil)
+
+		t.Assert(a1.Merge(s2).Len(), 6)
+		t.Assert(a1.Merge(i1).Len(), 9)
+		t.Assert(a1.Merge(i2).Len(), 10)
+		t.Assert(a1.Merge(s3).Len(), 12)
+		t.Assert(a1.Merge(s4).Len(), 14)
+		t.Assert(a1.Merge(s5).Len(), 16)
+		t.Assert(a1.Merge(s6).Len(), 19)
+	})
+}
+
+func TestSortedTArray_Json(t *testing.T) {
+	// array pointer
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []string{"a", "b", "d", "c"}
+		s2 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewSortedTArrayFrom(s1, nil)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
+
+		a2 := garray.NewSortedTArray[string](nil)
+		err1 = json.UnmarshalUseNumber(b2, &a2)
+		t.AssertNil(err1)
+		t.Assert(a2.Slice(), s2)
+
+		var a3 garray.SortedTArray[string]
+		a3.SetComparator(nil)
+		err := json.UnmarshalUseNumber(b2, &a3)
+		t.AssertNil(err)
+		t.Assert(a3.Slice(), s1)
+		t.Assert(a3.Interfaces(), s1)
+	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []string{"a", "b", "d", "c"}
+		s2 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewSortedTArrayFrom(s1, nil)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
+
+		a2 := garray.NewSortedTArray[string](nil)
+		err1 = json.UnmarshalUseNumber(b2, &a2)
+		t.AssertNil(err1)
+		t.Assert(a2.Slice(), s2)
+
+		var a3 garray.SortedTArray[string]
+		a3.SetComparator(nil)
+		err := json.UnmarshalUseNumber(b2, &a3)
+		t.AssertNil(err)
+		t.Assert(a3.Slice(), s1)
+		t.Assert(a3.Interfaces(), s1)
+	})
+	// array pointer
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores *garray.SortedTArray[int]
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []int{99, 100, 98},
+		}
+		b, err := json.Marshal(data)
+		t.AssertNil(err)
+
+		user := new(User)
+		err = json.UnmarshalUseNumber(b, user)
+		t.AssertNil(err)
+		t.Assert(user.Name, data["Name"])
+		t.AssertNE(user.Scores, nil)
+		t.Assert(user.Scores.Len(), 3)
+
+		v, ok := user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores *garray.SortedTArray[int]
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []int{99, 100, 98},
+		}
+		b, err := json.Marshal(data)
+		t.AssertNil(err)
+
+		user := new(User)
+		err = json.UnmarshalUseNumber(b, user)
+		t.AssertNil(err)
+		t.Assert(user.Name, data["Name"])
+		t.AssertNE(user.Scores, nil)
+		t.Assert(user.Scores.Len(), 3)
+
+		v, ok := user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+	})
+}
+
+func TestSortedTArray_Iterator(t *testing.T) {
+	slice := g.SliceStr{"a", "b", "d", "c"}
+	array := garray.NewSortedTArrayFrom(slice, nil)
+	gtest.C(t, func(t *gtest.T) {
+		array.Iterator(func(k int, v string) bool {
+			t.Assert(v, slice[k])
+			return true
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array.IteratorAsc(func(k int, v string) bool {
+			t.Assert(v, slice[k])
+			return true
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array.IteratorDesc(func(k int, v string) bool {
+			t.Assert(v, slice[k])
+			return true
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		index := 0
+		array.Iterator(func(k int, v string) bool {
+			index++
+			return false
+		})
+		t.Assert(index, 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		index := 0
+		array.IteratorAsc(func(k int, v string) bool {
+			index++
+			return false
+		})
+		t.Assert(index, 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		index := 0
+		array.IteratorDesc(func(k int, v string) bool {
+			index++
+			return false
+		})
+		t.Assert(index, 1)
+	})
+}
+
+func TestSortedTArray_RemoveValue(t *testing.T) {
+	slice := g.SliceStr{"a", "b", "d", "c"}
+	array := garray.NewSortedTArrayFrom(slice, nil)
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(array.RemoveValue("e"), false)
+		t.Assert(array.RemoveValue("b"), true)
+		t.Assert(array.RemoveValue("a"), true)
+		t.Assert(array.RemoveValue("c"), true)
+		t.Assert(array.RemoveValue("f"), false)
+	})
+}
+
+func TestSortedTArray_RemoveValues(t *testing.T) {
+	slice := g.SliceStr{"a", "b", "d", "c"}
+	array := garray.NewSortedTArrayFrom(slice, nil)
+	gtest.C(t, func(t *gtest.T) {
+		array.RemoveValues("a", "b", "c")
+		t.Assert(array.Slice(), g.SliceStr{"d"})
+	})
+}
+
+func TestSortedTArray_UnmarshalValue(t *testing.T) {
+	type V struct {
+		Name  string
+		Array *garray.SortedTArray[int]
+	}
+	// JSON
+	gtest.C(t, func(t *gtest.T) {
+		var v *V
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": []byte(`[2,3,1]`),
+		}, &v)
+		t.AssertNil(err)
+		t.Assert(v.Name, "john")
+		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
+	})
+	// Map
+	gtest.C(t, func(t *gtest.T) {
+		var v *V
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": g.SliceInt{2, 3, 1},
+		}, &v)
+		t.AssertNil(err)
+		t.Assert(v.Name, "john")
+		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
+	})
+}
+func TestSortedTArray_Filter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		values := g.SliceInt{0, 1, 2, 3, 4, -1, -2}
+		array := garray.NewSortedTArrayFromCopy(values, nil)
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return value < 0
+		}).Slice(), g.Slice{0, 1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFromCopy(g.SliceInt{-1, 1, 2, 3, 4, -2}, nil)
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return value < 0
+		}), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceInt{0, 1, 2, 3, 4, 0, 0}, nil)
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return empty.IsEmpty(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceInt{1, 2, 3, 4}, nil)
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return empty.IsEmpty(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+}
+
+func TestSortedTArray_FilterNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		values := g.SliceInt{0, 1, 2, 3, 4, -1, -2}
+		array := garray.NewSortedTArrayFromCopy(values, gutil.ComparatorT)
+		t.Assert(array.FilterNil().Slice(), g.SliceInt{-2, -1, 0, 1, 2, 3, 4})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		values := g.Slice{0, 1, 2, 3, 4, -1, -2, nil, []any{}, ""}
+		array := garray.NewSortedTArrayFromCopy(values, nil)
+		t.Assert(array.FilterNil().Slice(), g.Slice{"", -1, -2, 0, 1, 2, 3, 4, []any{}})
+	})
+}
+
+func TestSortedTArray_FilterEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceInt{0, 1, 2, 3, 4, 0, 0}, nil)
+		t.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceInt{1, 2, 3, 4}, nil)
+		t.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceStr{"a", "", "b", "c", ""}, nil)
+		t.Assert(array.FilterEmpty(), g.Slice{"a", "b", "c"})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		values := g.Slice{0, 1, 2, 3, 4, -1, -2, nil, []any{}, ""}
+		array := garray.NewSortedTArrayFromCopy(values, nil)
+		t.Assert(array.FilterEmpty().Slice(), g.Slice{-1, -2, 1, 2, 3, 4})
+	})
+}
+
+func TestSortedTArray_Walk(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceStr{"1", "2"}, nil)
+		t.Assert(array.Walk(func(value string) string {
+			return "key-" + value
+		}), g.Slice{"key-1", "key-2"})
+	})
+}
+
+func TestSortedTArray_IsEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom([]string{}, nil)
+		t.Assert(array.IsEmpty(), true)
+	})
+}
+
+func TestSortedTArray_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom([]int{1, 2, 3, 4, 5}, nil)
+		copyArray := array.DeepCopy().(*garray.SortedTArray[int])
+		array.Add(6)
+		copyArray.Add(7)
+		cval, _ := copyArray.Get(5)
+		val, _ := array.Get(5)
+		t.AssertNE(cval, val)
+	})
+}
diff --git a/container/glist/glist_t.go b/container/glist/glist_t.go
new file mode 100644
index 000000000..4f23d2b78
--- /dev/null
+++ b/container/glist/glist_t.go
@@ -0,0 +1,721 @@
+// 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 glist
+
+import (
+	"bytes"
+	"container/list"
+
+	"github.com/gogf/gf/v2/internal/deepcopy"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+// TElement is an element of a linked list.
+type TElement[T any] struct {
+	// Next and previous pointers in the doubly-linked list of elements.
+	// To simplify the implementation, internally a list l is implemented
+	// as a ring, such that &l.root is both the next element of the last
+	// list element (l.Back()) and the previous element of the first list
+	// element (l.Front()).
+	next, prev *TElement[T]
+
+	// The list to which this element belongs.
+	list *TList[T]
+
+	// The value stored with this element.
+	Value T
+}
+
+// Next returns the next list element or nil.
+func (e *TElement[T]) Next() *TElement[T] {
+	if p := e.next; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// Prev returns the previous list element or nil.
+func (e *TElement[T]) Prev() *TElement[T] {
+	if p := e.prev; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// TList is a doubly linked list containing a concurrent-safe/unsafe switch.
+// The switch should be set when its initialization and cannot be changed then.
+
+type TList[T any] struct {
+	mu   rwmutex.RWMutex
+	root TElement[T] // sentinel list element, only &root, root.prev, and root.next are used
+	len  int         // current list length excluding (this) sentinel element
+}
+
+// NewT creates and returns a new empty doubly linked list.
+func NewT[T any](safe ...bool) *TList[T] {
+	l := &TList[T]{
+		mu: rwmutex.Create(safe...),
+	}
+	return l.init()
+}
+
+// NewTFrom creates and returns a list from a copy of given slice `array`.
+// The parameter `safe` is used to specify whether using list in concurrent-safety,
+// which is false in default.
+func NewTFrom[T any](array []T, safe ...bool) *TList[T] {
+	l := NewT[T](safe...)
+	for _, v := range array {
+		l.insertValue(v, l.root.prev)
+	}
+	return l
+}
+
+// PushFront inserts a new element `e` with value `v` at the front of list `l` and returns `e`.
+func (l *TList[T]) PushFront(v T) (e *TElement[T]) {
+	l.mu.Lock()
+	l.lazyInit()
+	e = l.insertValue(v, &l.root)
+	l.mu.Unlock()
+	return
+}
+
+// PushBack inserts a new element `e` with value `v` at the back of list `l` and returns `e`.
+func (l *TList[T]) PushBack(v T) (e *TElement[T]) {
+	l.mu.Lock()
+	l.lazyInit()
+	e = l.insertValue(v, l.root.prev)
+	l.mu.Unlock()
+	return
+}
+
+// PushFronts inserts multiple new elements with values `values` at the front of list `l`.
+func (l *TList[T]) PushFronts(values []T) {
+	l.mu.Lock()
+	l.lazyInit()
+	for _, v := range values {
+		l.insertValue(v, &l.root)
+	}
+	l.mu.Unlock()
+}
+
+// PushBacks inserts multiple new elements with values `values` at the back of list `l`.
+func (l *TList[T]) PushBacks(values []T) {
+	l.mu.Lock()
+	l.lazyInit()
+	for _, v := range values {
+		l.insertValue(v, l.root.prev)
+	}
+	l.mu.Unlock()
+}
+
+// PopBack removes the element from back of `l` and returns the value of the element.
+func (l *TList[T]) PopBack() (value T) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+	if l.len == 0 {
+		return
+	}
+	return l.remove(l.root.prev)
+}
+
+// PopFront removes the element from front of `l` and returns the value of the element.
+func (l *TList[T]) PopFront() (value T) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+	if l.len == 0 {
+		return
+	}
+	return l.remove(l.root.next)
+}
+
+// PopBacks removes `max` elements from back of `l`
+// and returns values of the removed elements as slice.
+func (l *TList[T]) PopBacks(max int) (values []T) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+
+	length := l.len
+	if length > 0 {
+		if max > 0 && max < length {
+			length = max
+		}
+		values = make([]T, length)
+		for i := 0; i < length; i++ {
+			values[i] = l.remove(l.root.prev)
+		}
+	}
+	return
+}
+
+// PopFronts removes `max` elements from front of `l`
+// and returns values of the removed elements as slice.
+func (l *TList[T]) PopFronts(max int) (values []T) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+
+	length := l.len
+	if length > 0 {
+		if max > 0 && max < length {
+			length = max
+		}
+		values = make([]T, length)
+		for i := 0; i < length; i++ {
+			values[i] = l.remove(l.root.next)
+		}
+	}
+	return
+}
+
+// PopBackAll removes all elements from back of `l`
+// and returns values of the removed elements as slice.
+func (l *TList[T]) PopBackAll() []T {
+	return l.PopBacks(-1)
+}
+
+// PopFrontAll removes all elements from front of `l`
+// and returns values of the removed elements as slice.
+func (l *TList[T]) PopFrontAll() []T {
+	return l.PopFronts(-1)
+}
+
+// FrontAll copies and returns values of all elements from front of `l` as slice.
+func (l *TList[T]) FrontAll() (values []T) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+	length := l.len
+	if length > 0 {
+		values = make([]T, length)
+		for i, e := 0, l.front(); i < length; i, e = i+1, e.Next() {
+			values[i] = e.Value
+		}
+	}
+	return
+}
+
+// BackAll copies and returns values of all elements from back of `l` as slice.
+func (l *TList[T]) BackAll() (values []T) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+	length := l.len
+	if length > 0 {
+		values = make([]T, length)
+		for i, e := 0, l.back(); i < length; i, e = i+1, e.Prev() {
+			values[i] = e.Value
+		}
+	}
+	return
+}
+
+// FrontValue returns value of the first element of `l` or zero value of T if the list is empty.
+func (l *TList[T]) FrontValue() (value T) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+	if e := l.front(); e != nil {
+		value = e.Value
+	}
+	return
+}
+
+// BackValue returns value of the last element of `l` or zero value of T if the list is empty.
+func (l *TList[T]) BackValue() (value T) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+	if e := l.back(); e != nil {
+		value = e.Value
+	}
+	return
+}
+
+// Front returns the first element of list `l` or nil if the list is empty.
+func (l *TList[T]) Front() (e *TElement[T]) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	l.lazyInit()
+
+	e = l.front()
+	return
+}
+
+// Back returns the last element of list `l` or nil if the list is empty.
+func (l *TList[T]) Back() (e *TElement[T]) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+
+	e = l.back()
+	return
+}
+
+// Len returns the number of elements of list `l`.
+// The complexity is O(1).
+func (l *TList[T]) Len() (length int) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	l.lazyInit()
+
+	length = l.len
+	return
+}
+
+// Size is alias of Len.
+func (l *TList[T]) Size() int {
+	return l.Len()
+}
+
+// MoveBefore moves element `e` to its new position before `p`.
+// If `e` or `p` is not an element of `l`, or `e` == `p`, the list is not modified.
+// The element and `p` must not be nil.
+func (l *TList[T]) MoveBefore(e, p *TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.lazyInit()
+
+	if e.list != l || e == p || p.list != l {
+		return
+	}
+	l.move(e, p.prev)
+}
+
+// MoveAfter moves element `e` to its new position after `p`.
+// If `e` or `p` is not an element of `l`, or `e` == `p`, the list is not modified.
+// The element and `p` must not be nil.
+func (l *TList[T]) MoveAfter(e, p *TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+	if e.list != l || e == p || p.list != l {
+		return
+	}
+	l.move(e, p)
+}
+
+// MoveToFront moves element `e` to the front of list `l`.
+// If `e` is not an element of `l`, the list is not modified.
+// The element must not be nil.
+func (l *TList[T]) MoveToFront(e *TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+
+	if e.list != l || l.root.next == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.move(e, &l.root)
+}
+
+// MoveToBack moves element `e` to the back of list `l`.
+// If `e` is not an element of `l`, the list is not modified.
+// The element must not be nil.
+func (l *TList[T]) MoveToBack(e *TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+
+	if e.list != l || l.root.prev == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.move(e, l.root.prev)
+}
+
+// PushBackList inserts a copy of an other list at the back of list `l`.
+// The lists `l` and `other` may be the same, but they must not be nil.
+func (l *TList[T]) PushBackList(other *TList[T]) {
+	if l != other {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.lazyInit()
+
+	for i, e := other.len, other.front(); i > 0; i, e = i-1, e.Next() {
+		l.insertValue(e.Value, l.root.prev)
+	}
+}
+
+// PushFrontList inserts a copy of an other list at the front of list `l`.
+// The lists `l` and `other` may be the same, but they must not be nil.
+func (l *TList[T]) PushFrontList(other *TList[T]) {
+	if l != other {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.lazyInit()
+
+	for i, e := other.len, other.back(); i > 0; i, e = i-1, e.Prev() {
+		l.insertValue(e.Value, &l.root)
+	}
+}
+
+// InsertAfter inserts a new element `e` with value `v` immediately after `p` and returns `e`.
+// If `p` is not an element of `l`, the list is not modified.
+// The `p` must not be nil.
+func (l *TList[T]) InsertAfter(p *TElement[T], v T) (e *TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.lazyInit()
+	if p.list != l {
+		return nil
+	}
+	e = l.insertValue(v, p)
+	return
+}
+
+// InsertBefore inserts a new element `e` with value `v` immediately before `p` and returns `e`.
+// If `p` is not an element of `l`, the list is not modified.
+// The `p` must not be nil.
+func (l *TList[T]) InsertBefore(p *TElement[T], v T) (e *TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.lazyInit()
+	if p.list != l {
+		return nil
+	}
+	e = l.insertValue(v, p.prev)
+	return
+}
+
+// Remove removes `e` from `l` if `e` is an element of list `l`.
+// It returns the element value e.Value.
+// The element must not be nil.
+func (l *TList[T]) Remove(e *TElement[T]) (value T) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+	return l.remove(e)
+}
+
+// Removes removes multiple elements `es` from `l` if `es` are elements of list `l`.
+func (l *TList[T]) Removes(es []*TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+	for _, e := range es {
+		l.remove(e)
+	}
+}
+
+// RemoveAll removes all elements from list `l`.
+func (l *TList[T]) RemoveAll() {
+	l.mu.Lock()
+	l.init()
+	l.mu.Unlock()
+}
+
+// Clear is alias of RemoveAll.
+func (l *TList[T]) Clear() {
+	l.RemoveAll()
+}
+
+// ToList converts TList[T] to list.List
+func (l *TList[T]) ToList() *list.List {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	return l.toList()
+}
+
+// toList converts TList[T] to list.List
+func (l *TList[T]) toList() *list.List {
+	l.lazyInit()
+
+	nl := list.New()
+
+	for e := l.front(); e != nil; e = e.Next() {
+		nl.PushBack(e.Value)
+	}
+	return nl
+}
+
+// AppendList append list.List to the end
+func (l *TList[T]) AppendList(nl *list.List) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.appendList(nl)
+}
+
+// appendList append list.List to the end
+func (l *TList[T]) appendList(nl *list.List) {
+	if nl.Len() == 0 {
+		return
+	}
+
+	l.lazyInit()
+
+	for e := nl.Front(); e != nil; e = e.Next() {
+		if v, ok := e.Value.(T); ok {
+			l.insertValue(v, l.root.prev)
+		}
+	}
+}
+
+// AssignList assigns list.List to now TList[T].
+// It will clear TList[T] first, and append the list.List.
+// Note: Elements in nl that are not assignable to T are silently skipped.
+// Returns the number of skipped (incompatible) elements.
+func (l *TList[T]) AssignList(nl *list.List) int {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	return l.assignList(nl)
+}
+
+// assignList assigns list.List to now TList[T].
+// It will clear TList[T] first, and append the list.List.
+// Returns the number of skipped (incompatible) elements.
+func (l *TList[T]) assignList(nl *list.List) int {
+	l.init()
+	if nl.Len() == 0 {
+		return 0
+	}
+	skipped := 0
+	for e := nl.Front(); e != nil; e = e.Next() {
+		if v, ok := e.Value.(T); ok {
+			l.insertValue(v, l.root.prev)
+		} else {
+			skipped++
+		}
+	}
+	return skipped
+}
+
+// RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
+func (l *TList[T]) RLockFunc(f func(list *list.List)) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	f(l.toList())
+}
+
+// LockFunc locks writing with given callback function `f` within RWMutex.Lock.
+func (l *TList[T]) LockFunc(f func(list *list.List)) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	nl := l.toList()
+	f(nl)
+	l.assignList(nl)
+}
+
+// Iterator is alias of IteratorAsc.
+func (l *TList[T]) Iterator(f func(e *TElement[T]) bool) {
+	l.IteratorAsc(f)
+}
+
+// IteratorAsc iterates the list readonly in ascending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (l *TList[T]) IteratorAsc(f func(e *TElement[T]) bool) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+	length := l.len
+	if length > 0 {
+		for i, e := 0, l.front(); i < length; i, e = i+1, e.Next() {
+			if !f(e) {
+				break
+			}
+		}
+	}
+}
+
+// IteratorDesc iterates the list readonly in descending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (l *TList[T]) IteratorDesc(f func(e *TElement[T]) bool) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+	length := l.len
+	if length > 0 {
+		for i, e := 0, l.back(); i < length; i, e = i+1, e.Prev() {
+			if !f(e) {
+				break
+			}
+		}
+	}
+}
+
+// Join joins list elements with a string `glue`.
+func (l *TList[T]) Join(glue string) string {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+
+	buffer := bytes.NewBuffer(nil)
+	length := l.len
+	if length > 0 {
+		for i, e := 0, l.front(); i < length; i, e = i+1, e.Next() {
+			buffer.WriteString(gconv.String(e.Value))
+			if i != length-1 {
+				buffer.WriteString(glue)
+			}
+		}
+	}
+	return buffer.String()
+}
+
+// String returns current list as a string.
+func (l *TList[T]) String() string {
+	if l == nil {
+		return ""
+	}
+	return "[" + l.Join(",") + "]"
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (l TList[T]) MarshalJSON() ([]byte, error) {
+	return json.Marshal(l.FrontAll())
+}
+
+// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
+func (l *TList[T]) UnmarshalJSON(b []byte) error {
+	var array []T
+	if err := json.UnmarshalUseNumber(b, &array); err != nil {
+		return err
+	}
+	l.init()
+	l.PushBacks(array)
+	return nil
+}
+
+// UnmarshalValue is an interface implement which sets any type of value for list.
+func (l *TList[T]) UnmarshalValue(value any) (err error) {
+	var array []T
+	switch value.(type) {
+	case string, []byte:
+		err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
+	default:
+		anyArray := gconv.SliceAny(value)
+		if err = gconv.Scan(anyArray, &array); err != nil {
+			return
+		}
+	}
+	l.init()
+	l.PushBacks(array)
+	return err
+}
+
+// DeepCopy implements interface for deep copy of current type.
+func (l *TList[T]) DeepCopy() any {
+	if l == nil {
+		return nil
+	}
+
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	l.lazyInit()
+
+	var (
+		length  = l.len
+		valuesT = make([]T, length)
+	)
+	if length > 0 {
+		for i, e := 0, l.front(); i < length; i, e = i+1, e.Next() {
+			valuesT[i] = deepcopy.Copy(e.Value).(T)
+		}
+	}
+	return NewTFrom(valuesT, l.mu.IsSafe())
+}
+
+// Init initializes or clears list l.
+func (l *TList[T]) init() *TList[T] {
+	l.root.next = &l.root
+	l.root.prev = &l.root
+	l.len = 0
+	return l
+}
+
+// lazyInit lazily initializes a zero List value.
+func (l *TList[T]) lazyInit() {
+	if l.root.next == nil {
+		l.init()
+	}
+}
+
+// insert inserts e after at, increments l.len, and returns e.
+func (l *TList[T]) insert(e, at *TElement[T]) *TElement[T] {
+	e.prev = at
+	e.next = at.next
+	e.prev.next = e
+	e.next.prev = e
+	e.list = l
+	l.len++
+	return e
+}
+
+// insertValue is a convenience wrapper for insert(&Element{Value: v}, at).
+func (l *TList[T]) insertValue(v T, at *TElement[T]) *TElement[T] {
+	return l.insert(&TElement[T]{Value: v}, at)
+}
+
+// remove removes e from its list, decrements l.len
+func (l *TList[T]) remove(e *TElement[T]) (val T) {
+	if e.list != l {
+		return
+	}
+	e.prev.next = e.next
+	e.next.prev = e.prev
+	e.next = nil // avoid memory leaks
+	e.prev = nil // avoid memory leaks
+	e.list = nil
+	l.len--
+
+	return e.Value
+}
+
+// move moves e to next to at.
+func (l *TList[T]) move(e, at *TElement[T]) {
+	if e == at {
+		return
+	}
+	e.prev.next = e.next
+	e.next.prev = e.prev
+
+	e.prev = at
+	e.next = at.next
+	e.prev.next = e
+	e.next.prev = e
+}
+
+// front returns the first element of list l or nil if the list is empty.
+func (l *TList[T]) front() *TElement[T] {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.next
+}
+
+// back returns the last element of list l or nil if the list is empty.
+func (l *TList[T]) back() *TElement[T] {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.prev
+}
diff --git a/container/glist/glist_z_bench_t_test.go b/container/glist/glist_z_bench_t_test.go
new file mode 100644
index 000000000..736bd4a0c
--- /dev/null
+++ b/container/glist/glist_z_bench_t_test.go
@@ -0,0 +1,61 @@
+// 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.
+
+// go test *.go -bench=".*" -benchmem
+
+package glist
+
+import (
+	"testing"
+)
+
+var (
+	lt = NewT[any](true)
+)
+
+func Benchmark_T_PushBack(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			lt.PushBack(i)
+			i++
+		}
+	})
+}
+
+func Benchmark_T_PushFront(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			lt.PushFront(i)
+			i++
+		}
+	})
+}
+
+func Benchmark_T_Len(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			lt.Len()
+		}
+	})
+}
+
+func Benchmark_T_PopFront(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			lt.PopFront()
+		}
+	})
+}
+
+func Benchmark_T_PopBack(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			lt.PopBack()
+		}
+	})
+}
diff --git a/container/glist/glist_z_example_t_test.go b/container/glist/glist_z_example_t_test.go
new file mode 100644
index 000000000..178819fdb
--- /dev/null
+++ b/container/glist/glist_z_example_t_test.go
@@ -0,0 +1,689 @@
+// 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 glist_test
+
+import (
+	"container/list"
+	"fmt"
+
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/container/glist"
+	"github.com/gogf/gf/v2/frame/g"
+)
+
+func ExampleNewT() {
+	n := 10
+	l := glist.NewT[any]()
+	for i := 0; i < n; i++ {
+		l.PushBack(i)
+	}
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.FrontAll())
+	fmt.Println(l.BackAll())
+
+	for i := 0; i < n; i++ {
+		fmt.Print(l.PopFront())
+	}
+
+	fmt.Println()
+	fmt.Println(l.Len())
+
+	// Output:
+	// 10
+	// [0,1,2,3,4,5,6,7,8,9]
+	// [0 1 2 3 4 5 6 7 8 9]
+	// [9 8 7 6 5 4 3 2 1 0]
+	// 0123456789
+	// 0
+}
+
+func ExampleNewTFrom() {
+	n := 10
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 10, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.FrontAll())
+	fmt.Println(l.BackAll())
+
+	for i := 0; i < n; i++ {
+		fmt.Print(l.PopFront())
+	}
+
+	fmt.Println()
+	fmt.Println(l.Len())
+
+	// Output:
+	// 10
+	// [1,2,3,4,5,6,7,8,9,10]
+	// [1 2 3 4 5 6 7 8 9 10]
+	// [10 9 8 7 6 5 4 3 2 1]
+	// 12345678910
+	// 0
+}
+
+func ExampleTList_PushFront() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.PushFront(0)
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 6
+	// [0,1,2,3,4,5]
+}
+
+func ExampleTList_PushBack() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.PushBack(6)
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 6
+	// [1,2,3,4,5,6]
+}
+
+func ExampleTList_PushFronts() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.PushFronts(g.Slice{0, -1, -2, -3, -4})
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 10
+	// [-4,-3,-2,-1,0,1,2,3,4,5]
+}
+
+func ExampleTList_PushBacks() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.PushBacks(g.Slice{6, 7, 8, 9, 10})
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 10
+	// [1,2,3,4,5,6,7,8,9,10]
+}
+
+func ExampleTList_PopBack() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.PopBack())
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 5
+	// 4
+	// [1,2,3,4]
+}
+
+func ExampleTList_PopFront() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.PopFront())
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 1
+	// 4
+	// [2,3,4,5]
+}
+
+func ExampleTList_PopBacks() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.PopBacks(2))
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// [5 4]
+	// 3
+	// [1,2,3]
+}
+
+func ExampleTList_PopFronts() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.PopFronts(2))
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// [1 2]
+	// 3
+	// [3,4,5]
+}
+
+func ExampleTList_PopBackAll() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.PopBackAll())
+	fmt.Println(l.Len())
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// [5 4 3 2 1]
+	// 0
+}
+
+func ExampleTList_PopFrontAll() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.PopFrontAll())
+	fmt.Println(l.Len())
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// [1 2 3 4 5]
+	// 0
+}
+
+func ExampleTList_FrontAll() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l)
+	fmt.Println(l.FrontAll())
+
+	// Output:
+	// [1,2,3,4,5]
+	// [1 2 3 4 5]
+}
+
+func ExampleTList_BackAll() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l)
+	fmt.Println(l.BackAll())
+
+	// Output:
+	// [1,2,3,4,5]
+	// [5 4 3 2 1]
+}
+
+func ExampleTList_FrontValue() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l)
+	fmt.Println(l.FrontValue())
+
+	// Output:
+	// [1,2,3,4,5]
+	// 1
+}
+
+func ExampleTList_BackValue() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l)
+	fmt.Println(l.BackValue())
+
+	// Output:
+	// [1,2,3,4,5]
+	// 5
+}
+
+func ExampleTList_Front() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Front().Value)
+	fmt.Println(l)
+
+	e := l.Front()
+	l.InsertBefore(e, 0)
+	l.InsertAfter(e, "a")
+
+	fmt.Println(l)
+
+	// Output:
+	// 1
+	// [1,2,3,4,5]
+	// [0,1,a,2,3,4,5]
+}
+
+func ExampleTList_Back() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Back().Value)
+	fmt.Println(l)
+
+	e := l.Back()
+	l.InsertBefore(e, "a")
+	l.InsertAfter(e, 6)
+
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// [1,2,3,4,a,5,6]
+}
+
+func ExampleTList_Len() {
+	l := glist.NewTFrom[any](g.Slice{1, 2, 3, 4, 5})
+
+	fmt.Println(l.Len())
+
+	// Output:
+	// 5
+}
+
+func ExampleTList_Size() {
+	l := glist.NewTFrom[any](g.Slice{1, 2, 3, 4, 5})
+
+	fmt.Println(l.Size())
+
+	// Output:
+	// 5
+}
+
+func ExampleTList_MoveBefore() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// element of `l`
+	e := l.PushBack(6)
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	l.MoveBefore(e, l.Front())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// not element of `l`
+	e = &glist.TElement[any]{Value: 7}
+	l.MoveBefore(e, l.Front())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 6
+	// [1,2,3,4,5,6]
+	// 6
+	// [6,1,2,3,4,5]
+	// 6
+	// [6,1,2,3,4,5]
+}
+
+func ExampleTList_MoveAfter() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// element of `l`
+	e := l.PushFront(0)
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	l.MoveAfter(e, l.Back())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// not element of `l`
+	e = &glist.TElement[any]{Value: -1}
+	l.MoveAfter(e, l.Back())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 6
+	// [0,1,2,3,4,5]
+	// 6
+	// [1,2,3,4,5,0]
+	// 6
+	// [1,2,3,4,5,0]
+}
+
+func ExampleTList_MoveToFront() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// element of `l`
+	l.MoveToFront(l.Back())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// not element of `l`
+	e := &glist.TElement[any]{Value: 6}
+	l.MoveToFront(e)
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 5
+	// [5,1,2,3,4]
+	// 5
+	// [5,1,2,3,4]
+}
+
+func ExampleTList_MoveToBack() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// element of `l`
+	l.MoveToBack(l.Front())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// not element of `l`
+	e := &glist.TElement[any]{Value: 0}
+	l.MoveToBack(e)
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 5
+	// [2,3,4,5,1]
+	// 5
+	// [2,3,4,5,1]
+}
+
+func ExampleTList_PushBackList() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	other := glist.NewTFrom[any](g.Slice{6, 7, 8, 9, 10})
+
+	fmt.Println(other.Size())
+	fmt.Println(other)
+
+	l.PushBackList(other)
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 5
+	// [6,7,8,9,10]
+	// 10
+	// [1,2,3,4,5,6,7,8,9,10]
+}
+
+func ExampleTList_PushFrontList() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	other := glist.NewTFrom[any](g.Slice{-4, -3, -2, -1, 0})
+
+	fmt.Println(other.Size())
+	fmt.Println(other)
+
+	l.PushFrontList(other)
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 5
+	// [-4,-3,-2,-1,0]
+	// 10
+	// [-4,-3,-2,-1,0,1,2,3,4,5]
+}
+
+func ExampleTList_InsertAfter() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.InsertAfter(l.Front(), "a")
+	l.InsertAfter(l.Back(), "b")
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 7
+	// [1,a,2,3,4,5,b]
+}
+
+func ExampleTList_InsertBefore() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.InsertBefore(l.Front(), "a")
+	l.InsertBefore(l.Back(), "b")
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 7
+	// [a,1,2,3,4,b,5]
+}
+
+func ExampleTList_Remove() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	fmt.Println(l.Remove(l.Front()))
+	fmt.Println(l.Remove(l.Back()))
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 1
+	// 5
+	// 3
+	// [2,3,4]
+}
+
+func ExampleTList_Removes() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.Removes([]*glist.TElement[any]{l.Front(), l.Back()})
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 3
+	// [2,3,4]
+}
+
+func ExampleTList_RemoveAll() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.RemoveAll()
+
+	fmt.Println(l.Len())
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 0
+}
+
+func ExampleTList_RLockFunc() {
+	// concurrent-safe list.
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 10, 1).Slice(), true)
+	// iterate reading from head.
+	l.RLockFunc(func(list *list.List) {
+		length := list.Len()
+		if length > 0 {
+			for i, e := 0, list.Front(); i < length; i, e = i+1, e.Next() {
+				fmt.Print(e.Value)
+			}
+		}
+	})
+	fmt.Println()
+	// iterate reading from tail.
+	l.RLockFunc(func(list *list.List) {
+		length := list.Len()
+		if length > 0 {
+			for i, e := 0, list.Back(); i < length; i, e = i+1, e.Prev() {
+				fmt.Print(e.Value)
+			}
+		}
+	})
+
+	fmt.Println()
+	// Output:
+	// 12345678910
+	// 10987654321
+}
+
+func ExampleTList_IteratorAsc() {
+	// concurrent-safe list.
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 10, 1).Slice(), true)
+	// iterate reading from head using IteratorAsc.
+	l.IteratorAsc(func(e *glist.TElement[any]) bool {
+		fmt.Print(e.Value)
+		return true
+	})
+
+	// Output:
+	// 12345678910
+}
+
+func ExampleTList_IteratorDesc() {
+	// concurrent-safe list.
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 10, 1).Slice(), true)
+	// iterate reading from tail using IteratorDesc.
+	l.IteratorDesc(func(e *glist.TElement[any]) bool {
+		fmt.Print(e.Value)
+		return true
+	})
+	// Output:
+	// 10987654321
+}
+
+func ExampleTList_LockFunc() {
+	// concurrent-safe list.
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 10, 1).Slice(), true)
+	// iterate writing from head.
+	l.LockFunc(func(list *list.List) {
+		length := list.Len()
+		if length > 0 {
+			for i, e := 0, list.Front(); i < length; i, e = i+1, e.Next() {
+				if e.Value == 6 {
+					e.Value = "M"
+					break
+				}
+			}
+		}
+	})
+	fmt.Println(l)
+
+	// Output:
+	// [1,2,3,4,5,M,7,8,9,10]
+}
+
+func ExampleTList_Join() {
+	var l glist.TList[any]
+	l.PushBacks(g.Slice{"a", "b", "c", "d"})
+
+	fmt.Println(l.Join(","))
+
+	// Output:
+	// a,b,c,d
+}
diff --git a/container/glist/glist_z_unit_t_test.go b/container/glist/glist_z_unit_t_test.go
new file mode 100644
index 000000000..8a4310611
--- /dev/null
+++ b/container/glist/glist_z_unit_t_test.go
@@ -0,0 +1,933 @@
+// 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 glist
+
+import (
+	"container/list"
+	"testing"
+
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+func checkTListLen(t *gtest.T, l *TList[any], len int) bool {
+	if n := l.Len(); n != len {
+		t.Errorf("l.Len() = %d, want %d", n, len)
+		return false
+	}
+	return true
+}
+
+func checkTListPointers(t *gtest.T, l *TList[any], es []*TElement[any]) {
+	if !checkTListLen(t, l, len(es)) {
+		return
+	}
+
+	i := 0
+	l.Iterator(func(e *TElement[any]) bool {
+		if e.Prev() != es[i].Prev() {
+			t.Errorf("list[%d].Prev = %p, want %p", i, e.Prev(), es[i].Prev())
+			return false
+		}
+		if e.Next() != es[i].Next() {
+			t.Errorf("list[%d].Next = %p, want %p", i, e.Next(), es[i].Next())
+			return false
+		}
+		i++
+		return true
+	})
+}
+
+func TestTVar(t *testing.T) {
+	var l TList[any]
+	l.PushFront(1)
+	l.PushFront(2)
+	if v := l.PopBack(); v != 1 {
+		t.Errorf("EXPECT %v, GOT %v", 1, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopBack(); v != 2 {
+		t.Errorf("EXPECT %v, GOT %v", 2, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopBack(); v != nil {
+		t.Errorf("EXPECT %v, GOT %v", nil, v)
+	} else {
+		// fmt.Println(v)
+	}
+	l.PushBack(1)
+	l.PushBack(2)
+	if v := l.PopFront(); v != 1 {
+		t.Errorf("EXPECT %v, GOT %v", 1, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopFront(); v != 2 {
+		t.Errorf("EXPECT %v, GOT %v", 2, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopFront(); v != nil {
+		t.Errorf("EXPECT %v, GOT %v", nil, v)
+	} else {
+		// fmt.Println(v)
+	}
+}
+
+func TestTBasic(t *testing.T) {
+	l := NewT[any]()
+	l.PushFront(1)
+	l.PushFront(2)
+	if v := l.PopBack(); v != 1 {
+		t.Errorf("EXPECT %v, GOT %v", 1, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopBack(); v != 2 {
+		t.Errorf("EXPECT %v, GOT %v", 2, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopBack(); v != nil {
+		t.Errorf("EXPECT %v, GOT %v", nil, v)
+	} else {
+		// fmt.Println(v)
+	}
+	l.PushBack(1)
+	l.PushBack(2)
+	if v := l.PopFront(); v != 1 {
+		t.Errorf("EXPECT %v, GOT %v", 1, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopFront(); v != 2 {
+		t.Errorf("EXPECT %v, GOT %v", 2, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopFront(); v != nil {
+		t.Errorf("EXPECT %v, GOT %v", nil, v)
+	} else {
+		// fmt.Println(v)
+	}
+}
+
+func TestTList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		checkTListPointers(t, l, []*TElement[any]{})
+
+		// Single element list
+		e := l.PushFront("a")
+		checkTListPointers(t, l, []*TElement[any]{e})
+		l.MoveToFront(e)
+		checkTListPointers(t, l, []*TElement[any]{e})
+		l.MoveToBack(e)
+		checkTListPointers(t, l, []*TElement[any]{e})
+		l.Remove(e)
+		checkTListPointers(t, l, []*TElement[any]{})
+
+		// Bigger list
+		e2 := l.PushFront(2)
+		e1 := l.PushFront(1)
+		e3 := l.PushBack(3)
+		e4 := l.PushBack("banana")
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e3, e4})
+
+		l.Remove(e2)
+		checkTListPointers(t, l, []*TElement[any]{e1, e3, e4})
+
+		l.MoveToFront(e3) // move from middle
+		checkTListPointers(t, l, []*TElement[any]{e3, e1, e4})
+
+		l.MoveToFront(e1)
+		l.MoveToBack(e3) // move from middle
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e3})
+
+		l.MoveToFront(e3) // move from back
+		checkTListPointers(t, l, []*TElement[any]{e3, e1, e4})
+		l.MoveToFront(e3) // should be no-op
+		checkTListPointers(t, l, []*TElement[any]{e3, e1, e4})
+
+		l.MoveToBack(e3) // move from front
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e3})
+		l.MoveToBack(e3) // should be no-op
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e3})
+
+		e2 = l.InsertBefore(e1, 2) // insert before front
+		checkTListPointers(t, l, []*TElement[any]{e2, e1, e4, e3})
+		l.Remove(e2)
+		e2 = l.InsertBefore(e4, 2) // insert before middle
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e4, e3})
+		l.Remove(e2)
+		e2 = l.InsertBefore(e3, 2) // insert before back
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e2, e3})
+		l.Remove(e2)
+
+		e2 = l.InsertAfter(e1, 2) // insert after front
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e4, e3})
+		l.Remove(e2)
+		e2 = l.InsertAfter(e4, 2) // insert after middle
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e2, e3})
+		l.Remove(e2)
+		e2 = l.InsertAfter(e3, 2) // insert after back
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e3, e2})
+		l.Remove(e2)
+
+		// Check standard iteration.
+		sum := 0
+		for e := l.Front(); e != nil; e = e.Next() {
+			if i, ok := e.Value.(int); ok {
+				sum += i
+			}
+		}
+		if sum != 4 {
+			t.Errorf("sum over l = %d, want 4", sum)
+		}
+
+		// Clear all elements by iterating
+		var next *TElement[any]
+		for e := l.Front(); e != nil; e = next {
+			next = e.Next()
+			l.Remove(e)
+		}
+		checkTListPointers(t, l, []*TElement[any]{})
+	})
+}
+
+func checkTList(t *gtest.T, l *TList[any], es []any) {
+	if !checkTListLen(t, l, len(es)) {
+		return
+	}
+
+	i := 0
+	for e := l.Front(); e != nil; e = e.Next() {
+
+		switch e.Value.(type) {
+		case int:
+			if le := e.Value.(int); le != es[i] {
+				t.Errorf("elt[%d].Value() = %v, want %v", i, le, es[i])
+			}
+			// default string
+		default:
+			if le := e.Value.(string); le != es[i] {
+				t.Errorf("elt[%v].Value() = %v, want %v", i, le, es[i])
+			}
+		}
+
+		i++
+	}
+
+	// for e := l.Front(); e != nil; e = e.Next() {
+	//	le := e.Value.(int)
+	//	if le != es[i] {
+	//		t.Errorf("elt[%d].Value() = %v, want %v", i, le, es[i])
+	//	}
+	//	i++
+	// }
+}
+
+func TestTExtending(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l1 := NewT[any]()
+		l2 := NewT[any]()
+
+		l1.PushBack(1)
+		l1.PushBack(2)
+		l1.PushBack(3)
+
+		l2.PushBack(4)
+		l2.PushBack(5)
+
+		l3 := NewT[any]()
+		l3.PushBackList(l1)
+		checkTList(t, l3, []any{1, 2, 3})
+		l3.PushBackList(l2)
+		checkTList(t, l3, []any{1, 2, 3, 4, 5})
+
+		l3 = NewT[any]()
+		l3.PushFrontList(l2)
+		checkTList(t, l3, []any{4, 5})
+		l3.PushFrontList(l1)
+		checkTList(t, l3, []any{1, 2, 3, 4, 5})
+
+		checkTList(t, l1, []any{1, 2, 3})
+		checkTList(t, l2, []any{4, 5})
+
+		l3 = NewT[any]()
+		l3.PushBackList(l1)
+		checkTList(t, l3, []any{1, 2, 3})
+		l3.PushBackList(l3)
+		checkTList(t, l3, []any{1, 2, 3, 1, 2, 3})
+
+		l3 = NewT[any]()
+		l3.PushFrontList(l1)
+		checkTList(t, l3, []any{1, 2, 3})
+		l3.PushFrontList(l3)
+		checkTList(t, l3, []any{1, 2, 3, 1, 2, 3})
+
+		l3 = NewT[any]()
+		l1.PushBackList(l3)
+		checkTList(t, l1, []any{1, 2, 3})
+		l1.PushFrontList(l3)
+		checkTList(t, l1, []any{1, 2, 3})
+	})
+}
+
+func TestTRemove(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		e1 := l.PushBack(1)
+		e2 := l.PushBack(2)
+		checkTListPointers(t, l, []*TElement[any]{e1, e2})
+		// e := l.Front()
+		// l.Remove(e)
+		// checkTListPointers(t, l, []*TElement[any]{e2})
+		// l.Remove(e)
+		// checkTListPointers(t, l, []*TElement[any]{e2})
+	})
+}
+
+func Test_T_Issue4103(t *testing.T) {
+	l1 := NewT[any]()
+	l1.PushBack(1)
+	l1.PushBack(2)
+
+	l2 := NewT[any]()
+	l2.PushBack(3)
+	l2.PushBack(4)
+
+	e := l1.Front()
+	l2.Remove(e) // l2 should not change because e is not an element of l2
+	if n := l2.Len(); n != 2 {
+		t.Errorf("l2.Len() = %d, want 2", n)
+	}
+
+	l1.InsertBefore(e, 8)
+	if n := l1.Len(); n != 3 {
+		t.Errorf("l1.Len() = %d, want 3", n)
+	}
+}
+
+func Test_T_Issue6349(t *testing.T) {
+	l := NewT[any]()
+	l.PushBack(1)
+	l.PushBack(2)
+
+	e := l.Front()
+	l.Remove(e)
+	if e.Value != 1 {
+		t.Errorf("e.value = %d, want 1", e.Value)
+	}
+	// if e.Next() != nil {
+	//    t.Errorf("e.Next() != nil")
+	// }
+	// if e.Prev() != nil {
+	//    t.Errorf("e.Prev() != nil")
+	// }
+}
+
+func TestTMove(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		e1 := l.PushBack(1)
+		e2 := l.PushBack(2)
+		e3 := l.PushBack(3)
+		e4 := l.PushBack(4)
+
+		l.MoveAfter(e3, e3)
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e3, e4})
+		l.MoveBefore(e2, e2)
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e3, e4})
+
+		l.MoveAfter(e3, e2)
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e3, e4})
+		l.MoveBefore(e2, e3)
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e3, e4})
+
+		l.MoveBefore(e2, e4)
+		checkTListPointers(t, l, []*TElement[any]{e1, e3, e2, e4})
+		e2, e3 = e3, e2
+
+		l.MoveBefore(e4, e1)
+		checkTListPointers(t, l, []*TElement[any]{e4, e1, e2, e3})
+		e1, e2, e3, e4 = e4, e1, e2, e3
+
+		l.MoveAfter(e4, e1)
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e2, e3})
+		e2, e3, e4 = e4, e2, e3
+
+		l.MoveAfter(e2, e3)
+		checkTListPointers(t, l, []*TElement[any]{e1, e3, e2, e4})
+		e2, e3 = e3, e2
+	})
+}
+
+// Test PushFront, PushBack, PushFrontList, PushBackList with uninitialized List
+func TestTZeroList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var l1 = NewT[any]()
+		l1.PushFront(1)
+		checkTList(t, l1, []any{1})
+
+		var l2 = NewT[any]()
+		l2.PushBack(1)
+		checkTList(t, l2, []any{1})
+
+		var l3 = NewT[any]()
+		l3.PushFrontList(l1)
+		checkTList(t, l3, []any{1})
+
+		var l4 = NewT[any]()
+		l4.PushBackList(l2)
+		checkTList(t, l4, []any{1})
+	})
+}
+
+// Test that a list l is not modified when calling InsertBefore with a mark that is not an element of l.
+func TestTInsertBeforeUnknownMark(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		l.PushBack(1)
+		l.PushBack(2)
+		l.PushBack(3)
+		l.InsertBefore(new(TElement[any]), 1)
+		checkTList(t, l, []any{1, 2, 3})
+	})
+}
+
+// Test that a list l is not modified when calling InsertAfter with a mark that is not an element of l.
+func TestTInsertAfterUnknownMark(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		l.PushBack(1)
+		l.PushBack(2)
+		l.PushBack(3)
+		l.InsertAfter(new(TElement[any]), 1)
+		checkTList(t, l, []any{1, 2, 3})
+	})
+}
+
+// Test that a list l is not modified when calling MoveAfter or MoveBefore with a mark that is not an element of l.
+func TestTMoveUnknownMark(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l1 := NewT[any]()
+		e1 := l1.PushBack(1)
+
+		l2 := NewT[any]()
+		e2 := l2.PushBack(2)
+
+		l1.MoveAfter(e1, e2)
+		checkTList(t, l1, []any{1})
+		checkTList(t, l2, []any{2})
+
+		l1.MoveBefore(e1, e2)
+		checkTList(t, l1, []any{1})
+		checkTList(t, l2, []any{2})
+	})
+}
+
+func TestTList_RemoveAll(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		l.PushBack(1)
+		l.RemoveAll()
+		checkTList(t, l, []any{})
+		l.PushBack(2)
+		checkTList(t, l, []any{2})
+	})
+}
+
+func TestTList_PushFronts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2}
+		l.PushFronts(a1)
+		checkTList(t, l, []any{2, 1})
+		a1 = []any{3, 4, 5}
+		l.PushFronts(a1)
+		checkTList(t, l, []any{5, 4, 3, 2, 1})
+	})
+}
+
+func TestTList_PushBacks(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2}
+		l.PushBacks(a1)
+		checkTList(t, l, []any{1, 2})
+		a1 = []any{3, 4, 5}
+		l.PushBacks(a1)
+		checkTList(t, l, []any{1, 2, 3, 4, 5})
+	})
+}
+
+func TestTList_PopBacks(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		a2 := []any{"a", "c", "b", "e"}
+		l.PushFronts(a1)
+		i1 := l.PopBacks(2)
+		t.Assert(i1, []any{1, 2})
+
+		l.PushBacks(a2) // 4.3,a,c,b,e
+		i1 = l.PopBacks(3)
+		t.Assert(i1, []any{"e", "b", "c"})
+	})
+}
+
+func TestTList_PopFronts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.PopFronts(2)
+		t.Assert(i1, []any{4, 3})
+		t.Assert(l.Len(), 2)
+	})
+}
+
+func TestTList_PopBackAll(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.PopBackAll()
+		t.Assert(i1, []any{1, 2, 3, 4})
+		t.Assert(l.Len(), 0)
+	})
+}
+
+func TestTList_PopFrontAll(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.PopFrontAll()
+		t.Assert(i1, []any{4, 3, 2, 1})
+		t.Assert(l.Len(), 0)
+	})
+}
+
+func TestTList_FrontAll(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.FrontAll()
+		t.Assert(i1, []any{4, 3, 2, 1})
+		t.Assert(l.Len(), 4)
+	})
+}
+
+func TestTList_BackAll(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.BackAll()
+		t.Assert(i1, []any{1, 2, 3, 4})
+		t.Assert(l.Len(), 4)
+	})
+}
+
+func TestTList_FrontValue(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		l2 := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.FrontValue()
+		t.Assert(gconv.Int(i1), 4)
+		t.Assert(l.Len(), 4)
+
+		i1 = l2.FrontValue()
+		t.Assert(i1, nil)
+	})
+}
+
+func TestTList_BackValue(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		l2 := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.BackValue()
+		t.Assert(gconv.Int(i1), 1)
+		t.Assert(l.Len(), 4)
+
+		i1 = l2.FrontValue()
+		t.Assert(i1, nil)
+	})
+}
+
+func TestTList_Back(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		e1 := l.Back()
+		t.Assert(e1.Value, 1)
+		t.Assert(l.Len(), 4)
+	})
+}
+
+func TestTList_Size(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		t.Assert(l.Size(), 4)
+		l.PopFront()
+		t.Assert(l.Size(), 3)
+	})
+}
+
+func TestTList_Removes(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		e1 := l.Back()
+		l.Removes([]*TElement[any]{e1})
+		t.Assert(l.Len(), 3)
+
+		e2 := l.Back()
+		l.Removes([]*TElement[any]{e2})
+		t.Assert(l.Len(), 2)
+		checkTList(t, l, []any{4, 3})
+	})
+}
+
+func TestTList_Pop(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+		t.Assert(l.PopBack(), 9)
+		t.Assert(l.PopBacks(2), []any{8, 7})
+		t.Assert(l.PopFront(), 1)
+		t.Assert(l.PopFronts(2), []any{2, 3})
+	})
+}
+
+func TestTList_Clear(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		l.Clear()
+		t.Assert(l.Len(), 0)
+	})
+}
+
+func TestTList_IteratorAsc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 5, 6, 3, 4}
+		l.PushFronts(a1)
+		e1 := l.Back()
+		fun1 := func(e *TElement[any]) bool {
+			return gconv.Int(e1.Value) > 2
+		}
+		checkTList(t, l, []any{4, 3, 6, 5, 2, 1})
+		l.IteratorAsc(fun1)
+		checkTList(t, l, []any{4, 3, 6, 5, 2, 1})
+	})
+}
+
+func TestTList_IteratorDesc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		e1 := l.Back()
+		fun1 := func(e *TElement[any]) bool {
+			return gconv.Int(e1.Value) > 6
+		}
+		l.IteratorDesc(fun1)
+		t.Assert(l.Len(), 4)
+		checkTList(t, l, []any{4, 3, 2, 1})
+	})
+}
+
+func TestTList_Iterator(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{"a", "b", "c", "d", "e"}
+		l.PushFronts(a1)
+		e1 := l.Back()
+		fun1 := func(e *TElement[any]) bool {
+			return gconv.String(e1.Value) > "c"
+		}
+		checkTList(t, l, []any{"e", "d", "c", "b", "a"})
+		l.Iterator(fun1)
+		checkTList(t, l, []any{"e", "d", "c", "b", "a"})
+	})
+}
+
+func TestTList_Join(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, "a", `"b"`, `\c`})
+		t.Assert(l.Join(","), `1,2,a,"b",\c`)
+		t.Assert(l.Join("."), `1.2.a."b".\c`)
+	})
+}
+
+func TestTList_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, "a", `"b"`, `\c`})
+		t.Assert(l.String(), `[1,2,a,"b",\c]`)
+	})
+}
+
+func TestTList_Json(t *testing.T) {
+	// Marshal
+	gtest.C(t, func(t *gtest.T) {
+		a := []any{"a", "b", "c"}
+		l := NewT[any]()
+		l.PushBacks(a)
+		b1, err1 := json.Marshal(l)
+		b2, err2 := json.Marshal(a)
+		t.Assert(err1, err2)
+		t.Assert(b1, b2)
+	})
+	// Unmarshal
+	gtest.C(t, func(t *gtest.T) {
+		a := []any{"a", "b", "c"}
+		l := NewT[any]()
+		b, err := json.Marshal(a)
+		t.AssertNil(err)
+
+		err = json.UnmarshalUseNumber(b, l)
+		t.AssertNil(err)
+		t.Assert(l.FrontAll(), a)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		var l TList[any]
+		a := []any{"a", "b", "c"}
+		b, err := json.Marshal(a)
+		t.AssertNil(err)
+
+		err = json.UnmarshalUseNumber(b, &l)
+		t.AssertNil(err)
+		t.Assert(l.FrontAll(), a)
+	})
+}
+
+func TestTList_UnmarshalValue(t *testing.T) {
+	type list struct {
+		Name string
+		List *TList[any]
+	}
+	// JSON
+	gtest.C(t, func(t *gtest.T) {
+		var tlist *list
+		err := gconv.Struct(map[string]any{
+			"name": "john",
+			"list": []byte(`[1,2,3]`),
+		}, &tlist)
+		t.AssertNil(err)
+		t.Assert(tlist.Name, "john")
+		t.Assert(tlist.List.FrontAll(), []any{1, 2, 3})
+	})
+	// Map
+	gtest.C(t, func(t *gtest.T) {
+		var tlist *list
+		err := gconv.Struct(map[string]any{
+			"name": "john",
+			"list": []any{1, 2, 3},
+		}, &tlist)
+		t.AssertNil(err)
+		t.Assert(tlist.Name, "john")
+		t.Assert(tlist.List.FrontAll(), []any{1, 2, 3})
+	})
+}
+
+func TestTList_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, "a", `"b"`, `\c`})
+		copyList := l.DeepCopy()
+		cl := copyList.(*TList[any])
+		cl.PopBack()
+		t.AssertNE(l.Size(), cl.Size())
+	})
+	// Nil pointer deep copy
+	gtest.C(t, func(t *gtest.T) {
+		var l *TList[any]
+		copyList := l.DeepCopy()
+		t.AssertNil(copyList)
+	})
+}
+
+func TestTList_ToList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, 3, 4, 5})
+		nl := l.ToList()
+		t.Assert(nl.Len(), 5)
+
+		// Verify elements
+		i := 1
+		for e := nl.Front(); e != nil; e = e.Next() {
+			t.Assert(e.Value, i)
+			i++
+		}
+	})
+	// Empty list
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		nl := l.ToList()
+		t.Assert(nl.Len(), 0)
+	})
+}
+
+func TestTList_AppendList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, 3})
+		nl := list.New()
+		nl.PushBack(4)
+		nl.PushBack(5)
+
+		l.AppendList(nl)
+		t.Assert(l.Len(), 5)
+		t.Assert(l.FrontAll(), []any{1, 2, 3, 4, 5})
+	})
+	// Append empty list
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, 3})
+		nl := list.New()
+		l.AppendList(nl)
+		t.Assert(l.Len(), 3)
+		t.Assert(l.FrontAll(), []any{1, 2, 3})
+	})
+	// Append with type mismatch (should skip)
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[int]()
+		nl := list.New()
+		nl.PushBack(1)
+		nl.PushBack("string") // type mismatch
+		nl.PushBack(2)
+
+		l.AppendList(nl)
+		t.Assert(l.Len(), 2)
+		t.Assert(l.FrontAll(), []int{1, 2})
+	})
+}
+
+func TestTList_AssignList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, 3})
+		nl := list.New()
+		nl.PushBack(4)
+		nl.PushBack(5)
+		nl.PushBack(6)
+
+		skipped := l.AssignList(nl)
+		t.Assert(skipped, 0)
+		t.Assert(l.Len(), 3)
+		t.Assert(l.FrontAll(), []any{4, 5, 6})
+	})
+	// Assign empty list
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, 3})
+		nl := list.New()
+
+		skipped := l.AssignList(nl)
+		t.Assert(skipped, 0)
+		t.Assert(l.Len(), 0)
+	})
+	// Assign with type mismatch (should return skipped count)
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[int]()
+		nl := list.New()
+		nl.PushBack(1)
+		nl.PushBack("string") // type mismatch
+		nl.PushBack(2)
+		nl.PushBack("another") // type mismatch
+
+		skipped := l.AssignList(nl)
+		t.Assert(skipped, 2)
+		t.Assert(l.Len(), 2)
+		t.Assert(l.FrontAll(), []int{1, 2})
+	})
+}
+
+func TestTList_String_Nil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var l *TList[any]
+		t.Assert(l.String(), "")
+	})
+}
+
+func TestTList_UnmarshalJSON_Error(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		err := l.UnmarshalJSON([]byte("invalid json"))
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestTList_UnmarshalValue_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		err := l.UnmarshalValue(`[1,2,3]`)
+		t.AssertNil(err)
+		t.Assert(l.FrontAll(), []any{1, 2, 3})
+	})
+}
+
+func TestTList_UnmarshalValue_Bytes(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		err := l.UnmarshalValue([]byte(`[1,2,3]`))
+		t.AssertNil(err)
+		t.Assert(l.FrontAll(), []any{1, 2, 3})
+	})
+}
+
+func TestTList_DeepCopy_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		copyList := l.DeepCopy()
+		cl := copyList.(*TList[any])
+		t.Assert(cl.Len(), 0)
+	})
+}
+
+func TestTList_AppendList_WithTypeMismatch(t *testing.T) {
+	// Test appendList internal function through AppendList with mixed types
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[int]()
+		nl := list.New()
+		// Only add non-matching types
+		nl.PushBack("string1")
+		nl.PushBack("string2")
+
+		l.AppendList(nl)
+		t.Assert(l.Len(), 0)
+	})
+}
+
+func TestTList_UnmarshalValue_Error(t *testing.T) {
+	// Test UnmarshalValue with data through default case
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		// Pass a slice directly through default case
+		_ = l.UnmarshalValue([]any{1, 2, 3})
+		t.Assert(l.Len(), 3)
+		t.Assert(l.FrontAll(), []any{1, 2, 3})
+	})
+	// Test UnmarshalValue error in string case
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		err := l.UnmarshalValue("invalid json")
+		t.AssertNE(err, nil)
+	})
+}
diff --git a/container/gmap/gmap.go b/container/gmap/gmap.go
index 04efeb502..8afd76a4d 100644
--- a/container/gmap/gmap.go
+++ b/container/gmap/gmap.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package gmap provides most commonly used map container which also support concurrent-safe/unsafe switch feature.
diff --git a/container/gmap/gmap_hash_any_any_map.go b/container/gmap/gmap_hash_any_any_map.go
index 1a248bccb..09e5d5297 100644
--- a/container/gmap/gmap_hash_any_any_map.go
+++ b/container/gmap/gmap_hash_any_any_map.go
@@ -1,251 +1,149 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap
 
 import (
-	"reflect"
+	"sync"
 
 	"github.com/gogf/gf/v2/container/gvar"
-	"github.com/gogf/gf/v2/internal/deepcopy"
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // AnyAnyMap wraps map type `map[any]any` and provides more map features.
 type AnyAnyMap struct {
-	mu   rwmutex.RWMutex
-	data map[any]any
+	*KVMap[any, any]
+	once sync.Once
 }
 
 // NewAnyAnyMap creates and returns an empty hash map.
 // The parameter `safe` is used to specify whether using map in concurrent-safety,
 // which is false in default.
 func NewAnyAnyMap(safe ...bool) *AnyAnyMap {
-	return &AnyAnyMap{
-		mu:   rwmutex.Create(safe...),
-		data: make(map[any]any),
+	m := &AnyAnyMap{
+		KVMap: NewKVMap[any, any](safe...),
 	}
+	return m
 }
 
 // NewAnyAnyMapFrom creates and returns a hash map from given map `data`.
 // Note that, the param `data` map will be set as the underlying data map(no deep copy),
 // there might be some concurrent-safe issues when changing the map outside.
 func NewAnyAnyMapFrom(data map[any]any, safe ...bool) *AnyAnyMap {
-	return &AnyAnyMap{
-		mu:   rwmutex.Create(safe...),
-		data: data,
+	m := &AnyAnyMap{
+		KVMap: NewKVMapFrom(data, safe...),
 	}
+	return m
+}
+
+// lazyInit lazily initializes the map.
+func (m *AnyAnyMap) lazyInit() {
+	m.once.Do(func() {
+		if m.KVMap == nil {
+			m.KVMap = NewKVMap[any, any](false)
+		}
+	})
 }
 
 // Iterator iterates the hash map readonly with custom callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (m *AnyAnyMap) Iterator(f func(k any, v any) bool) {
-	for k, v := range m.Map() {
-		if !f(k, v) {
-			break
-		}
-	}
+	m.lazyInit()
+	m.KVMap.Iterator(f)
 }
 
 // Clone returns a new hash map with copy of current map data.
 func (m *AnyAnyMap) Clone(safe ...bool) *AnyAnyMap {
-	return NewFrom(m.MapCopy(), safe...)
+	m.lazyInit()
+	return NewAnyAnyMapFrom(m.MapCopy(), safe...)
 }
 
 // Map returns the underlying data map.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (m *AnyAnyMap) Map() map[any]any {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if !m.mu.IsSafe() {
-		return m.data
-	}
-	data := make(map[any]any, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.Map()
 }
 
 // MapCopy returns a shallow copy of the underlying data of the hash map.
 func (m *AnyAnyMap) MapCopy() map[any]any {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[any]any, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.MapCopy()
 }
 
 // MapStrAny returns a copy of the underlying data of the map as map[string]any.
 func (m *AnyAnyMap) MapStrAny() map[string]any {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[string]any, len(m.data))
-	for k, v := range m.data {
-		data[gconv.String(k)] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.MapStrAny()
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *AnyAnyMap) FilterEmpty() {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	for k, v := range m.data {
-		if empty.IsEmpty(v) {
-			delete(m.data, k)
-		}
-	}
+	m.lazyInit()
+	m.KVMap.FilterEmpty()
 }
 
 // FilterNil deletes all key-value pair of which the value is nil.
 func (m *AnyAnyMap) FilterNil() {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	for k, v := range m.data {
-		if empty.IsNil(v) {
-			delete(m.data, k)
-		}
-	}
+	m.lazyInit()
+	m.KVMap.FilterNil()
 }
 
 // Set sets key-value to the hash map.
 func (m *AnyAnyMap) Set(key any, value any) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = make(map[any]any)
-	}
-	m.data[key] = value
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Set(key, value)
 }
 
 // Sets batch sets key-values to the hash map.
 func (m *AnyAnyMap) Sets(data map[any]any) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = data
-	} else {
-		for k, v := range data {
-			m.data[k] = v
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Sets(data)
 }
 
 // Search searches the map with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (m *AnyAnyMap) Search(key any) (value any, found bool) {
-	m.mu.RLock()
-	if m.data != nil {
-		value, found = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Search(key)
 }
 
 // Get returns the value by given `key`.
 func (m *AnyAnyMap) Get(key any) (value any) {
-	m.mu.RLock()
-	if m.data != nil {
-		value = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Get(key)
 }
 
 // Pop retrieves and deletes an item from the map.
 func (m *AnyAnyMap) Pop() (key, value any) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	for key, value = range m.data {
-		delete(m.data, key)
-		return
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Pop()
 }
 
 // Pops retrieves and deletes `size` items from the map.
 // It returns all items if size == -1.
 func (m *AnyAnyMap) Pops(size int) map[any]any {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if size > len(m.data) || size == -1 {
-		size = len(m.data)
-	}
-	if size == 0 {
-		return nil
-	}
-	var (
-		index  = 0
-		newMap = make(map[any]any, size)
-	)
-	for k, v := range m.data {
-		delete(m.data, k)
-		newMap[k] = v
-		index++
-		if index == size {
-			break
-		}
-	}
-	return newMap
-}
-
-// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
-// if not exists, set value to the map with given `key`,
-// or else just return the existing value.
-//
-// When setting value, if `value` is type of `func() interface {}`,
-// it will be executed with mutex.Lock of the hash map,
-// and its return value will be set to the map with `key`.
-//
-// It returns value with given `key`.
-func (m *AnyAnyMap) doSetWithLockCheck(key any, value any) any {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[any]any)
-	}
-	if v, ok := m.data[key]; ok {
-		return v
-	}
-	if f, ok := value.(func() any); ok {
-		value = f()
-	}
-	if value != nil {
-		m.data[key] = value
-	}
-	return value
+	m.lazyInit()
+	return m.KVMap.Pops(size)
 }
 
 // GetOrSet returns the value by key,
 // or sets value with given `value` if it does not exist and then returns this value.
 func (m *AnyAnyMap) GetOrSet(key any, value any) any {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, value)
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSet(key, value)
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist
 // and then returns this value.
 func (m *AnyAnyMap) GetOrSetFunc(key any, f func() any) any {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, f())
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFunc(key, f)
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -255,55 +153,50 @@ func (m *AnyAnyMap) GetOrSetFunc(key any, f func() any) any {
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
 func (m *AnyAnyMap) GetOrSetFuncLock(key any, f func() any) any {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, f)
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFuncLock(key, f)
 }
 
 // GetVar returns a Var with the value by given `key`.
 // The returned Var is un-concurrent safe.
 func (m *AnyAnyMap) GetVar(key any) *gvar.Var {
-	return gvar.New(m.Get(key))
+	m.lazyInit()
+	return m.KVMap.GetVar(key)
 }
 
 // GetVarOrSet returns a Var with result from GetOrSet.
 // The returned Var is un-concurrent safe.
 func (m *AnyAnyMap) GetVarOrSet(key any, value any) *gvar.Var {
-	return gvar.New(m.GetOrSet(key, value))
+	m.lazyInit()
+	return m.KVMap.GetVarOrSet(key, value)
 }
 
 // GetVarOrSetFunc returns a Var with result from GetOrSetFunc.
 // The returned Var is un-concurrent safe.
 func (m *AnyAnyMap) GetVarOrSetFunc(key any, f func() any) *gvar.Var {
-	return gvar.New(m.GetOrSetFunc(key, f))
+	m.lazyInit()
+	return m.KVMap.GetVarOrSetFunc(key, f)
 }
 
 // GetVarOrSetFuncLock returns a Var with result from GetOrSetFuncLock.
 // The returned Var is un-concurrent safe.
 func (m *AnyAnyMap) GetVarOrSetFuncLock(key any, f func() any) *gvar.Var {
-	return gvar.New(m.GetOrSetFuncLock(key, f))
+	m.lazyInit()
+	return m.KVMap.GetVarOrSetFuncLock(key, f)
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *AnyAnyMap) SetIfNotExist(key any, value any) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, value)
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExist(key, value)
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *AnyAnyMap) SetIfNotExistFunc(key any, f func() any) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, f())
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFunc(key, f)
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -312,119 +205,76 @@ func (m *AnyAnyMap) SetIfNotExistFunc(key any, f func() any) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the hash map.
 func (m *AnyAnyMap) SetIfNotExistFuncLock(key any, f func() any) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, f)
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFuncLock(key, f)
 }
 
 // Remove deletes value from map by given `key`, and return this deleted value.
 func (m *AnyAnyMap) Remove(key any) (value any) {
-	m.mu.Lock()
-	if m.data != nil {
-		var ok bool
-		if value, ok = m.data[key]; ok {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Remove(key)
 }
 
 // Removes batch deletes values of the map by keys.
 func (m *AnyAnyMap) Removes(keys []any) {
-	m.mu.Lock()
-	if m.data != nil {
-		for _, key := range keys {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Removes(keys)
 }
 
 // Keys returns all keys of the map as a slice.
 func (m *AnyAnyMap) Keys() []any {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	var (
-		keys  = make([]any, len(m.data))
-		index = 0
-	)
-	for key := range m.data {
-		keys[index] = key
-		index++
-	}
-	return keys
+	m.lazyInit()
+	return m.KVMap.Keys()
 }
 
 // Values returns all values of the map as a slice.
 func (m *AnyAnyMap) Values() []any {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	var (
-		values = make([]any, len(m.data))
-		index  = 0
-	)
-	for _, value := range m.data {
-		values[index] = value
-		index++
-	}
-	return values
+	m.lazyInit()
+	return m.KVMap.Values()
 }
 
 // Contains checks whether a key exists.
 // It returns true if the `key` exists, or else false.
 func (m *AnyAnyMap) Contains(key any) bool {
-	var ok bool
-	m.mu.RLock()
-	if m.data != nil {
-		_, ok = m.data[key]
-	}
-	m.mu.RUnlock()
-	return ok
+	m.lazyInit()
+	return m.KVMap.Contains(key)
 }
 
 // Size returns the size of the map.
 func (m *AnyAnyMap) Size() int {
-	m.mu.RLock()
-	length := len(m.data)
-	m.mu.RUnlock()
-	return length
+	m.lazyInit()
+	return m.KVMap.Size()
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *AnyAnyMap) IsEmpty() bool {
-	return m.Size() == 0
+	m.lazyInit()
+	return m.KVMap.IsEmpty()
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *AnyAnyMap) Clear() {
-	m.mu.Lock()
-	m.data = make(map[any]any)
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Clear()
 }
 
 // Replace the data of the map with given `data`.
 func (m *AnyAnyMap) Replace(data map[any]any) {
-	m.mu.Lock()
-	m.data = data
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Replace(data)
 }
 
 // LockFunc locks writing with given callback function `f` within RWMutex.Lock.
 func (m *AnyAnyMap) LockFunc(f func(m map[any]any)) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.LockFunc(f)
 }
 
 // RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
 func (m *AnyAnyMap) RLockFunc(f func(m map[any]any)) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.RLockFunc(f)
 }
 
 // Flip exchanges key-value of the map to value-key.
@@ -441,19 +291,8 @@ func (m *AnyAnyMap) Flip() {
 // Merge merges two hash maps.
 // The `other` map will be merged into the map `m`.
 func (m *AnyAnyMap) Merge(other *AnyAnyMap) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = other.MapCopy()
-		return
-	}
-	if other != m {
-		other.mu.RLock()
-		defer other.mu.RUnlock()
-	}
-	for k, v := range other.data {
-		m.data[k] = v
-	}
+	m.lazyInit()
+	m.KVMap.Merge(other.KVMap)
 }
 
 // String returns the map as a string.
@@ -461,79 +300,40 @@ func (m *AnyAnyMap) String() string {
 	if m == nil {
 		return ""
 	}
-	b, _ := m.MarshalJSON()
-	return string(b)
+	m.lazyInit()
+	return m.KVMap.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m AnyAnyMap) MarshalJSON() ([]byte, error) {
-	return json.Marshal(gconv.Map(m.Map()))
+	m.lazyInit()
+	return m.KVMap.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (m *AnyAnyMap) UnmarshalJSON(b []byte) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[any]any)
-	}
-	var data map[string]any
-	if err := json.UnmarshalUseNumber(b, &data); err != nil {
-		return err
-	}
-	for k, v := range data {
-		m.data[k] = v
-	}
-	return nil
+	m.lazyInit()
+	return m.KVMap.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
 func (m *AnyAnyMap) UnmarshalValue(value any) (err error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[any]any)
-	}
-	for k, v := range gconv.Map(value) {
-		m.data[k] = v
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.UnmarshalValue(value)
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *AnyAnyMap) DeepCopy() any {
-	if m == nil {
-		return nil
+	m.lazyInit()
+	return &AnyAnyMap{
+		KVMap: m.KVMap.DeepCopy().(*KVMap[any, any]),
 	}
-
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[any]any, len(m.data))
-	for k, v := range m.data {
-		data[k] = deepcopy.Copy(v)
-	}
-	return NewFrom(data, m.mu.IsSafe())
 }
 
 // IsSubOf checks whether the current map is a sub-map of `other`.
 func (m *AnyAnyMap) IsSubOf(other *AnyAnyMap) bool {
-	if m == other {
-		return true
-	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	for key, value := range m.data {
-		otherValue, ok := other.data[key]
-		if !ok {
-			return false
-		}
-		if otherValue != value {
-			return false
-		}
-	}
-	return true
+	m.lazyInit()
+	return m.KVMap.IsSubOf(other.KVMap)
 }
 
 // Diff compares current map `m` with map `other` and returns their different keys.
@@ -541,22 +341,6 @@ func (m *AnyAnyMap) IsSubOf(other *AnyAnyMap) bool {
 // The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
 // The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
 func (m *AnyAnyMap) Diff(other *AnyAnyMap) (addedKeys, removedKeys, updatedKeys []any) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-
-	for key := range m.data {
-		if _, ok := other.data[key]; !ok {
-			removedKeys = append(removedKeys, key)
-		} else if !reflect.DeepEqual(m.data[key], other.data[key]) {
-			updatedKeys = append(updatedKeys, key)
-		}
-	}
-	for key := range other.data {
-		if _, ok := m.data[key]; !ok {
-			addedKeys = append(addedKeys, key)
-		}
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Diff(other.KVMap)
 }
diff --git a/container/gmap/gmap_hash_int_any_map.go b/container/gmap/gmap_hash_int_any_map.go
index da4376a9d..5785d4bc0 100644
--- a/container/gmap/gmap_hash_int_any_map.go
+++ b/container/gmap/gmap_hash_int_any_map.go
@@ -1,251 +1,150 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 //
 
 package gmap
 
 import (
-	"reflect"
+	"sync"
 
 	"github.com/gogf/gf/v2/container/gvar"
-	"github.com/gogf/gf/v2/internal/deepcopy"
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // IntAnyMap implements map[int]any with RWMutex that has switch.
 type IntAnyMap struct {
-	mu   rwmutex.RWMutex
-	data map[int]any
+	*KVMap[int, any]
+	once sync.Once
 }
 
 // NewIntAnyMap returns an empty IntAnyMap object.
 // The parameter `safe` is used to specify whether using map in concurrent-safety,
 // which is false in default.
 func NewIntAnyMap(safe ...bool) *IntAnyMap {
-	return &IntAnyMap{
-		mu:   rwmutex.Create(safe...),
-		data: make(map[int]any),
+	m := &IntAnyMap{
+		KVMap: NewKVMap[int, any](safe...),
 	}
+	return m
 }
 
 // NewIntAnyMapFrom creates and returns a hash map from given map `data`.
 // Note that, the param `data` map will be set as the underlying data map(no deep copy),
 // there might be some concurrent-safe issues when changing the map outside.
 func NewIntAnyMapFrom(data map[int]any, safe ...bool) *IntAnyMap {
-	return &IntAnyMap{
-		mu:   rwmutex.Create(safe...),
-		data: data,
+	m := &IntAnyMap{
+		KVMap: NewKVMapFrom(data, safe...),
 	}
+	return m
+}
+
+// lazyInit lazily initializes the map.
+func (m *IntAnyMap) lazyInit() {
+	m.once.Do(func() {
+		if m.KVMap == nil {
+			m.KVMap = NewKVMap[int, any](false)
+		}
+	})
 }
 
 // Iterator iterates the hash map readonly with custom callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (m *IntAnyMap) Iterator(f func(k int, v any) bool) {
-	for k, v := range m.Map() {
-		if !f(k, v) {
-			break
-		}
-	}
+	m.lazyInit()
+	m.KVMap.Iterator(f)
 }
 
 // Clone returns a new hash map with copy of current map data.
-func (m *IntAnyMap) Clone() *IntAnyMap {
-	return NewIntAnyMapFrom(m.MapCopy(), m.mu.IsSafe())
+func (m *IntAnyMap) Clone(safe ...bool) *IntAnyMap {
+	m.lazyInit()
+	return NewIntAnyMapFrom(m.MapCopy(), safe...)
 }
 
 // Map returns the underlying data map.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (m *IntAnyMap) Map() map[int]any {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if !m.mu.IsSafe() {
-		return m.data
-	}
-	data := make(map[int]any, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.Map()
 }
 
 // MapStrAny returns a copy of the underlying data of the map as map[string]any.
 func (m *IntAnyMap) MapStrAny() map[string]any {
-	m.mu.RLock()
-	data := make(map[string]any, len(m.data))
-	for k, v := range m.data {
-		data[gconv.String(k)] = v
-	}
-	m.mu.RUnlock()
-	return data
+	m.lazyInit()
+	return m.KVMap.MapStrAny()
 }
 
 // MapCopy returns a copy of the underlying data of the hash map.
 func (m *IntAnyMap) MapCopy() map[int]any {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[int]any, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.MapCopy()
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *IntAnyMap) FilterEmpty() {
-	m.mu.Lock()
-	for k, v := range m.data {
-		if empty.IsEmpty(v) {
-			delete(m.data, k)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.FilterEmpty()
 }
 
 // FilterNil deletes all key-value pair of which the value is nil.
 func (m *IntAnyMap) FilterNil() {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	for k, v := range m.data {
-		if empty.IsNil(v) {
-			delete(m.data, k)
-		}
-	}
+	m.lazyInit()
+	m.KVMap.FilterNil()
 }
 
 // Set sets key-value to the hash map.
 func (m *IntAnyMap) Set(key int, val any) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = make(map[int]any)
-	}
-	m.data[key] = val
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Set(key, val)
 }
 
 // Sets batch sets key-values to the hash map.
 func (m *IntAnyMap) Sets(data map[int]any) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = data
-	} else {
-		for k, v := range data {
-			m.data[k] = v
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Sets(data)
 }
 
 // Search searches the map with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (m *IntAnyMap) Search(key int) (value any, found bool) {
-	m.mu.RLock()
-	if m.data != nil {
-		value, found = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Search(key)
 }
 
 // Get returns the value by given `key`.
 func (m *IntAnyMap) Get(key int) (value any) {
-	m.mu.RLock()
-	if m.data != nil {
-		value = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Get(key)
 }
 
 // Pop retrieves and deletes an item from the map.
 func (m *IntAnyMap) Pop() (key int, value any) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	for key, value = range m.data {
-		delete(m.data, key)
-		return
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Pop()
 }
 
 // Pops retrieves and deletes `size` items from the map.
 // It returns all items if size == -1.
 func (m *IntAnyMap) Pops(size int) map[int]any {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if size > len(m.data) || size == -1 {
-		size = len(m.data)
-	}
-	if size == 0 {
-		return nil
-	}
-	var (
-		index  = 0
-		newMap = make(map[int]any, size)
-	)
-	for k, v := range m.data {
-		delete(m.data, k)
-		newMap[k] = v
-		index++
-		if index == size {
-			break
-		}
-	}
-	return newMap
-}
-
-// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
-// if not exists, set value to the map with given `key`,
-// or else just return the existing value.
-//
-// When setting value, if `value` is type of `func() interface {}`,
-// it will be executed with mutex.Lock of the hash map,
-// and its return value will be set to the map with `key`.
-//
-// It returns value with given `key`.
-func (m *IntAnyMap) doSetWithLockCheck(key int, value any) any {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[int]any)
-	}
-	if v, ok := m.data[key]; ok {
-		return v
-	}
-	if f, ok := value.(func() any); ok {
-		value = f()
-	}
-	if value != nil {
-		m.data[key] = value
-	}
-	return value
+	m.lazyInit()
+	return m.KVMap.Pops(size)
 }
 
 // GetOrSet returns the value by key,
 // or sets value with given `value` if it does not exist and then returns this value.
 func (m *IntAnyMap) GetOrSet(key int, value any) any {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, value)
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSet(key, value)
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist and returns this value.
 func (m *IntAnyMap) GetOrSetFunc(key int, f func() any) any {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, f())
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFunc(key, f)
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -254,55 +153,50 @@ func (m *IntAnyMap) GetOrSetFunc(key int, f func() any) any {
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
 func (m *IntAnyMap) GetOrSetFuncLock(key int, f func() any) any {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, f)
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFuncLock(key, f)
 }
 
 // GetVar returns a Var with the value by given `key`.
 // The returned Var is un-concurrent safe.
 func (m *IntAnyMap) GetVar(key int) *gvar.Var {
-	return gvar.New(m.Get(key))
+	m.lazyInit()
+	return m.KVMap.GetVar(key)
 }
 
 // GetVarOrSet returns a Var with result from GetVarOrSet.
 // The returned Var is un-concurrent safe.
 func (m *IntAnyMap) GetVarOrSet(key int, value any) *gvar.Var {
-	return gvar.New(m.GetOrSet(key, value))
+	m.lazyInit()
+	return m.KVMap.GetVarOrSet(key, value)
 }
 
 // GetVarOrSetFunc returns a Var with result from GetOrSetFunc.
 // The returned Var is un-concurrent safe.
 func (m *IntAnyMap) GetVarOrSetFunc(key int, f func() any) *gvar.Var {
-	return gvar.New(m.GetOrSetFunc(key, f))
+	m.lazyInit()
+	return m.KVMap.GetVarOrSetFunc(key, f)
 }
 
 // GetVarOrSetFuncLock returns a Var with result from GetOrSetFuncLock.
 // The returned Var is un-concurrent safe.
 func (m *IntAnyMap) GetVarOrSetFuncLock(key int, f func() any) *gvar.Var {
-	return gvar.New(m.GetOrSetFuncLock(key, f))
+	m.lazyInit()
+	return m.KVMap.GetVarOrSetFuncLock(key, f)
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *IntAnyMap) SetIfNotExist(key int, value any) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, value)
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExist(key, value)
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *IntAnyMap) SetIfNotExistFunc(key int, f func() any) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, f())
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFunc(key, f)
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -311,119 +205,76 @@ func (m *IntAnyMap) SetIfNotExistFunc(key int, f func() any) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the hash map.
 func (m *IntAnyMap) SetIfNotExistFuncLock(key int, f func() any) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, f)
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFuncLock(key, f)
 }
 
 // Removes batch deletes values of the map by keys.
 func (m *IntAnyMap) Removes(keys []int) {
-	m.mu.Lock()
-	if m.data != nil {
-		for _, key := range keys {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Removes(keys)
 }
 
 // Remove deletes value from map by given `key`, and return this deleted value.
 func (m *IntAnyMap) Remove(key int) (value any) {
-	m.mu.Lock()
-	if m.data != nil {
-		var ok bool
-		if value, ok = m.data[key]; ok {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Remove(key)
 }
 
 // Keys returns all keys of the map as a slice.
 func (m *IntAnyMap) Keys() []int {
-	m.mu.RLock()
-	var (
-		keys  = make([]int, len(m.data))
-		index = 0
-	)
-	for key := range m.data {
-		keys[index] = key
-		index++
-	}
-	m.mu.RUnlock()
-	return keys
+	m.lazyInit()
+	return m.KVMap.Keys()
 }
 
 // Values returns all values of the map as a slice.
 func (m *IntAnyMap) Values() []any {
-	m.mu.RLock()
-	var (
-		values = make([]any, len(m.data))
-		index  = 0
-	)
-	for _, value := range m.data {
-		values[index] = value
-		index++
-	}
-	m.mu.RUnlock()
-	return values
+	m.lazyInit()
+	return m.KVMap.Values()
 }
 
 // Contains checks whether a key exists.
 // It returns true if the `key` exists, or else false.
 func (m *IntAnyMap) Contains(key int) bool {
-	var ok bool
-	m.mu.RLock()
-	if m.data != nil {
-		_, ok = m.data[key]
-	}
-	m.mu.RUnlock()
-	return ok
+	m.lazyInit()
+	return m.KVMap.Contains(key)
 }
 
 // Size returns the size of the map.
 func (m *IntAnyMap) Size() int {
-	m.mu.RLock()
-	length := len(m.data)
-	m.mu.RUnlock()
-	return length
+	m.lazyInit()
+	return m.KVMap.Size()
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *IntAnyMap) IsEmpty() bool {
-	return m.Size() == 0
+	m.lazyInit()
+	return m.KVMap.IsEmpty()
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *IntAnyMap) Clear() {
-	m.mu.Lock()
-	m.data = make(map[int]any)
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Clear()
 }
 
 // Replace the data of the map with given `data`.
 func (m *IntAnyMap) Replace(data map[int]any) {
-	m.mu.Lock()
-	m.data = data
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Replace(data)
 }
 
 // LockFunc locks writing with given callback function `f` within RWMutex.Lock.
 func (m *IntAnyMap) LockFunc(f func(m map[int]any)) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.LockFunc(f)
 }
 
 // RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
 func (m *IntAnyMap) RLockFunc(f func(m map[int]any)) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.RLockFunc(f)
 }
 
 // Flip exchanges key-value of the map to value-key.
@@ -440,19 +291,8 @@ func (m *IntAnyMap) Flip() {
 // Merge merges two hash maps.
 // The `other` map will be merged into the map `m`.
 func (m *IntAnyMap) Merge(other *IntAnyMap) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = other.MapCopy()
-		return
-	}
-	if other != m {
-		other.mu.RLock()
-		defer other.mu.RUnlock()
-	}
-	for k, v := range other.data {
-		m.data[k] = v
-	}
+	m.lazyInit()
+	m.KVMap.Merge(other.KVMap)
 }
 
 // String returns the map as a string.
@@ -460,81 +300,40 @@ func (m *IntAnyMap) String() string {
 	if m == nil {
 		return ""
 	}
-	b, _ := m.MarshalJSON()
-	return string(b)
+	m.lazyInit()
+	return m.KVMap.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m IntAnyMap) MarshalJSON() ([]byte, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return json.Marshal(m.data)
+	m.lazyInit()
+	return m.KVMap.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (m *IntAnyMap) UnmarshalJSON(b []byte) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[int]any)
-	}
-	if err := json.UnmarshalUseNumber(b, &m.data); err != nil {
-		return err
-	}
-	return nil
+	m.lazyInit()
+	return m.KVMap.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
 func (m *IntAnyMap) UnmarshalValue(value any) (err error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[int]any)
-	}
-	switch value.(type) {
-	case string, []byte:
-		return json.UnmarshalUseNumber(gconv.Bytes(value), &m.data)
-	default:
-		for k, v := range gconv.Map(value) {
-			m.data[gconv.Int(k)] = v
-		}
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.UnmarshalValue(value)
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *IntAnyMap) DeepCopy() any {
-	if m == nil {
-		return nil
+	m.lazyInit()
+	return &IntAnyMap{
+		KVMap: m.KVMap.DeepCopy().(*KVMap[int, any]),
 	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[int]any, len(m.data))
-	for k, v := range m.data {
-		data[k] = deepcopy.Copy(v)
-	}
-	return NewIntAnyMapFrom(data, m.mu.IsSafe())
 }
 
 // IsSubOf checks whether the current map is a sub-map of `other`.
 func (m *IntAnyMap) IsSubOf(other *IntAnyMap) bool {
-	if m == other {
-		return true
-	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	for key, value := range m.data {
-		otherValue, ok := other.data[key]
-		if !ok {
-			return false
-		}
-		if otherValue != value {
-			return false
-		}
-	}
-	return true
+	m.lazyInit()
+	return m.KVMap.IsSubOf(other.KVMap)
 }
 
 // Diff compares current map `m` with map `other` and returns their different keys.
@@ -542,22 +341,6 @@ func (m *IntAnyMap) IsSubOf(other *IntAnyMap) bool {
 // The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
 // The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
 func (m *IntAnyMap) Diff(other *IntAnyMap) (addedKeys, removedKeys, updatedKeys []int) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-
-	for key := range m.data {
-		if _, ok := other.data[key]; !ok {
-			removedKeys = append(removedKeys, key)
-		} else if !reflect.DeepEqual(m.data[key], other.data[key]) {
-			updatedKeys = append(updatedKeys, key)
-		}
-	}
-	for key := range other.data {
-		if _, ok := m.data[key]; !ok {
-			addedKeys = append(addedKeys, key)
-		}
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Diff(other.KVMap)
 }
diff --git a/container/gmap/gmap_hash_int_int_map.go b/container/gmap/gmap_hash_int_int_map.go
index eb71c81fe..80685e01d 100644
--- a/container/gmap/gmap_hash_int_int_map.go
+++ b/container/gmap/gmap_hash_int_int_map.go
@@ -1,22 +1,17 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap
 
-import (
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/util/gconv"
-)
+import "sync"
 
 // IntIntMap implements map[int]int with RWMutex that has switch.
 type IntIntMap struct {
-	mu   rwmutex.RWMutex
-	data map[int]int
+	*KVMap[int, int]
+	once sync.Once
 }
 
 // NewIntIntMap returns an empty IntIntMap object.
@@ -24,8 +19,7 @@ type IntIntMap struct {
 // which is false in default.
 func NewIntIntMap(safe ...bool) *IntIntMap {
 	return &IntIntMap{
-		mu:   rwmutex.Create(safe...),
-		data: make(map[int]int),
+		KVMap: NewKVMap[int, int](safe...),
 	}
 }
 
@@ -34,193 +28,109 @@ func NewIntIntMap(safe ...bool) *IntIntMap {
 // there might be some concurrent-safe issues when changing the map outside.
 func NewIntIntMapFrom(data map[int]int, safe ...bool) *IntIntMap {
 	return &IntIntMap{
-		mu:   rwmutex.Create(safe...),
-		data: data,
+		KVMap: NewKVMapFrom(data, safe...),
 	}
 }
 
+// lazyInit lazily initializes the map.
+func (m *IntIntMap) lazyInit() {
+	m.once.Do(func() {
+		if m.KVMap == nil {
+			m.KVMap = NewKVMap[int, int](false)
+		}
+	})
+}
+
 // Iterator iterates the hash map readonly with custom callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (m *IntIntMap) Iterator(f func(k int, v int) bool) {
-	for k, v := range m.Map() {
-		if !f(k, v) {
-			break
-		}
-	}
+	m.lazyInit()
+	m.KVMap.Iterator(f)
 }
 
 // Clone returns a new hash map with copy of current map data.
-func (m *IntIntMap) Clone() *IntIntMap {
-	return NewIntIntMapFrom(m.MapCopy(), m.mu.IsSafe())
+func (m *IntIntMap) Clone(safe ...bool) *IntIntMap {
+	m.lazyInit()
+	return &IntIntMap{KVMap: m.KVMap.Clone(safe...)}
 }
 
 // Map returns the underlying data map.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (m *IntIntMap) Map() map[int]int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if !m.mu.IsSafe() {
-		return m.data
-	}
-	data := make(map[int]int, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.Map()
 }
 
 // MapStrAny returns a copy of the underlying data of the map as map[string]any.
 func (m *IntIntMap) MapStrAny() map[string]any {
-	m.mu.RLock()
-	data := make(map[string]any, len(m.data))
-	for k, v := range m.data {
-		data[gconv.String(k)] = v
-	}
-	m.mu.RUnlock()
-	return data
+	m.lazyInit()
+	return m.KVMap.MapStrAny()
 }
 
 // MapCopy returns a copy of the underlying data of the hash map.
 func (m *IntIntMap) MapCopy() map[int]int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[int]int, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.MapCopy()
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *IntIntMap) FilterEmpty() {
-	m.mu.Lock()
-	for k, v := range m.data {
-		if empty.IsEmpty(v) {
-			delete(m.data, k)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.FilterEmpty()
 }
 
 // Set sets key-value to the hash map.
 func (m *IntIntMap) Set(key int, val int) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = make(map[int]int)
-	}
-	m.data[key] = val
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Set(key, val)
 }
 
 // Sets batch sets key-values to the hash map.
 func (m *IntIntMap) Sets(data map[int]int) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = data
-	} else {
-		for k, v := range data {
-			m.data[k] = v
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Sets(data)
 }
 
 // Search searches the map with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (m *IntIntMap) Search(key int) (value int, found bool) {
-	m.mu.RLock()
-	if m.data != nil {
-		value, found = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Search(key)
 }
 
 // Get returns the value by given `key`.
 func (m *IntIntMap) Get(key int) (value int) {
-	m.mu.RLock()
-	if m.data != nil {
-		value = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Get(key)
 }
 
 // Pop retrieves and deletes an item from the map.
 func (m *IntIntMap) Pop() (key, value int) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	for key, value = range m.data {
-		delete(m.data, key)
-		return
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Pop()
 }
 
 // Pops retrieves and deletes `size` items from the map.
 // It returns all items if size == -1.
 func (m *IntIntMap) Pops(size int) map[int]int {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if size > len(m.data) || size == -1 {
-		size = len(m.data)
-	}
-	if size == 0 {
-		return nil
-	}
-	var (
-		index  = 0
-		newMap = make(map[int]int, size)
-	)
-	for k, v := range m.data {
-		delete(m.data, k)
-		newMap[k] = v
-		index++
-		if index == size {
-			break
-		}
-	}
-	return newMap
-}
-
-// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
-// if not exists, set value to the map with given `key`,
-// or else just return the existing value.
-//
-// It returns value with given `key`.
-func (m *IntIntMap) doSetWithLockCheck(key int, value int) int {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[int]int)
-	}
-	if v, ok := m.data[key]; ok {
-		return v
-	}
-	m.data[key] = value
-	return value
+	m.lazyInit()
+	return m.KVMap.Pops(size)
 }
 
 // GetOrSet returns the value by key,
 // or sets value with given `value` if it does not exist and then returns this value.
 func (m *IntIntMap) GetOrSet(key int, value int) int {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, value)
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSet(key, value)
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist and returns this value.
 func (m *IntIntMap) GetOrSetFunc(key int, f func() int) int {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, f())
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFunc(key, f)
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -229,41 +139,22 @@ func (m *IntIntMap) GetOrSetFunc(key int, f func() int) int {
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
 func (m *IntIntMap) GetOrSetFuncLock(key int, f func() int) int {
-	if v, ok := m.Search(key); !ok {
-		m.mu.Lock()
-		defer m.mu.Unlock()
-		if m.data == nil {
-			m.data = make(map[int]int)
-		}
-		if v, ok = m.data[key]; ok {
-			return v
-		}
-		v = f()
-		m.data[key] = v
-		return v
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFuncLock(key, f)
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *IntIntMap) SetIfNotExist(key int, value int) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, value)
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExist(key, value)
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *IntIntMap) SetIfNotExistFunc(key int, f func() int) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, f())
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFunc(key, f)
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -272,126 +163,76 @@ func (m *IntIntMap) SetIfNotExistFunc(key int, f func() int) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the hash map.
 func (m *IntIntMap) SetIfNotExistFuncLock(key int, f func() int) bool {
-	if !m.Contains(key) {
-		m.mu.Lock()
-		defer m.mu.Unlock()
-		if m.data == nil {
-			m.data = make(map[int]int)
-		}
-		if _, ok := m.data[key]; !ok {
-			m.data[key] = f()
-		}
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFuncLock(key, f)
 }
 
 // Removes batch deletes values of the map by keys.
 func (m *IntIntMap) Removes(keys []int) {
-	m.mu.Lock()
-	if m.data != nil {
-		for _, key := range keys {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Removes(keys)
 }
 
 // Remove deletes value from map by given `key`, and return this deleted value.
 func (m *IntIntMap) Remove(key int) (value int) {
-	m.mu.Lock()
-	if m.data != nil {
-		var ok bool
-		if value, ok = m.data[key]; ok {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Remove(key)
 }
 
 // Keys returns all keys of the map as a slice.
 func (m *IntIntMap) Keys() []int {
-	m.mu.RLock()
-	var (
-		keys  = make([]int, len(m.data))
-		index = 0
-	)
-	for key := range m.data {
-		keys[index] = key
-		index++
-	}
-	m.mu.RUnlock()
-	return keys
+	m.lazyInit()
+	return m.KVMap.Keys()
 }
 
 // Values returns all values of the map as a slice.
 func (m *IntIntMap) Values() []int {
-	m.mu.RLock()
-	var (
-		values = make([]int, len(m.data))
-		index  = 0
-	)
-	for _, value := range m.data {
-		values[index] = value
-		index++
-	}
-	m.mu.RUnlock()
-	return values
+	m.lazyInit()
+	return m.KVMap.Values()
 }
 
 // Contains checks whether a key exists.
 // It returns true if the `key` exists, or else false.
 func (m *IntIntMap) Contains(key int) bool {
-	var ok bool
-	m.mu.RLock()
-	if m.data != nil {
-		_, ok = m.data[key]
-	}
-	m.mu.RUnlock()
-	return ok
+	m.lazyInit()
+	return m.KVMap.Contains(key)
 }
 
 // Size returns the size of the map.
 func (m *IntIntMap) Size() int {
-	m.mu.RLock()
-	length := len(m.data)
-	m.mu.RUnlock()
-	return length
+	m.lazyInit()
+	return m.KVMap.Size()
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *IntIntMap) IsEmpty() bool {
-	return m.Size() == 0
+	m.lazyInit()
+	return m.KVMap.IsEmpty()
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *IntIntMap) Clear() {
-	m.mu.Lock()
-	m.data = make(map[int]int)
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Clear()
 }
 
 // Replace the data of the map with given `data`.
 func (m *IntIntMap) Replace(data map[int]int) {
-	m.mu.Lock()
-	m.data = data
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Replace(data)
 }
 
 // LockFunc locks writing with given callback function `f` within RWMutex.Lock.
 func (m *IntIntMap) LockFunc(f func(m map[int]int)) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.LockFunc(f)
 }
 
 // RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
 func (m *IntIntMap) RLockFunc(f func(m map[int]int)) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.RLockFunc(f)
 }
 
 // Flip exchanges key-value of the map to value-key.
@@ -408,19 +249,8 @@ func (m *IntIntMap) Flip() {
 // Merge merges two hash maps.
 // The `other` map will be merged into the map `m`.
 func (m *IntIntMap) Merge(other *IntIntMap) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = other.MapCopy()
-		return
-	}
-	if other != m {
-		other.mu.RLock()
-		defer other.mu.RUnlock()
-	}
-	for k, v := range other.data {
-		m.data[k] = v
-	}
+	m.lazyInit()
+	m.KVMap.Merge(other.KVMap)
 }
 
 // String returns the map as a string.
@@ -428,81 +258,40 @@ func (m *IntIntMap) String() string {
 	if m == nil {
 		return ""
 	}
-	b, _ := m.MarshalJSON()
-	return string(b)
+	m.lazyInit()
+	return m.KVMap.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m IntIntMap) MarshalJSON() ([]byte, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return json.Marshal(m.data)
+	m.lazyInit()
+	return m.KVMap.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (m *IntIntMap) UnmarshalJSON(b []byte) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[int]int)
-	}
-	if err := json.UnmarshalUseNumber(b, &m.data); err != nil {
-		return err
-	}
-	return nil
+	m.lazyInit()
+	return m.KVMap.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
 func (m *IntIntMap) UnmarshalValue(value any) (err error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[int]int)
-	}
-	switch value.(type) {
-	case string, []byte:
-		return json.UnmarshalUseNumber(gconv.Bytes(value), &m.data)
-	default:
-		for k, v := range gconv.Map(value) {
-			m.data[gconv.Int(k)] = gconv.Int(v)
-		}
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.UnmarshalValue(value)
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *IntIntMap) DeepCopy() any {
-	if m == nil {
-		return nil
+	m.lazyInit()
+	return &IntIntMap{
+		KVMap: m.KVMap.DeepCopy().(*KVMap[int, int]),
 	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[int]int, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return NewIntIntMapFrom(data, m.mu.IsSafe())
 }
 
 // IsSubOf checks whether the current map is a sub-map of `other`.
 func (m *IntIntMap) IsSubOf(other *IntIntMap) bool {
-	if m == other {
-		return true
-	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	for key, value := range m.data {
-		otherValue, ok := other.data[key]
-		if !ok {
-			return false
-		}
-		if otherValue != value {
-			return false
-		}
-	}
-	return true
+	m.lazyInit()
+	return m.KVMap.IsSubOf(other.KVMap)
 }
 
 // Diff compares current map `m` with map `other` and returns their different keys.
@@ -510,22 +299,6 @@ func (m *IntIntMap) IsSubOf(other *IntIntMap) bool {
 // The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
 // The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
 func (m *IntIntMap) Diff(other *IntIntMap) (addedKeys, removedKeys, updatedKeys []int) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-
-	for key := range m.data {
-		if _, ok := other.data[key]; !ok {
-			removedKeys = append(removedKeys, key)
-		} else if m.data[key] != other.data[key] {
-			updatedKeys = append(updatedKeys, key)
-		}
-	}
-	for key := range other.data {
-		if _, ok := m.data[key]; !ok {
-			addedKeys = append(addedKeys, key)
-		}
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Diff(other.KVMap)
 }
diff --git a/container/gmap/gmap_hash_int_str_map.go b/container/gmap/gmap_hash_int_str_map.go
index dfdba27bc..e6e3177bb 100644
--- a/container/gmap/gmap_hash_int_str_map.go
+++ b/container/gmap/gmap_hash_int_str_map.go
@@ -1,22 +1,21 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap
 
 import (
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
+	"sync"
+
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // IntStrMap implements map[int]string with RWMutex that has switch.
 type IntStrMap struct {
-	mu   rwmutex.RWMutex
-	data map[int]string
+	*KVMap[int, string]
+	once sync.Once
 }
 
 // NewIntStrMap returns an empty IntStrMap object.
@@ -24,8 +23,7 @@ type IntStrMap struct {
 // which is false in default.
 func NewIntStrMap(safe ...bool) *IntStrMap {
 	return &IntStrMap{
-		mu:   rwmutex.Create(safe...),
-		data: make(map[int]string),
+		KVMap: NewKVMap[int, string](safe...),
 	}
 }
 
@@ -34,193 +32,109 @@ func NewIntStrMap(safe ...bool) *IntStrMap {
 // there might be some concurrent-safe issues when changing the map outside.
 func NewIntStrMapFrom(data map[int]string, safe ...bool) *IntStrMap {
 	return &IntStrMap{
-		mu:   rwmutex.Create(safe...),
-		data: data,
+		KVMap: NewKVMapFrom(data, safe...),
 	}
 }
 
+// lazyInit lazily initializes the map.
+func (m *IntStrMap) lazyInit() {
+	m.once.Do(func() {
+		if m.KVMap == nil {
+			m.KVMap = NewKVMap[int, string](false)
+		}
+	})
+}
+
 // Iterator iterates the hash map readonly with custom callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (m *IntStrMap) Iterator(f func(k int, v string) bool) {
-	for k, v := range m.Map() {
-		if !f(k, v) {
-			break
-		}
-	}
+	m.lazyInit()
+	m.KVMap.Iterator(f)
 }
 
 // Clone returns a new hash map with copy of current map data.
-func (m *IntStrMap) Clone() *IntStrMap {
-	return NewIntStrMapFrom(m.MapCopy(), m.mu.IsSafe())
+func (m *IntStrMap) Clone(safe ...bool) *IntStrMap {
+	m.lazyInit()
+	return &IntStrMap{KVMap: m.KVMap.Clone(safe...)}
 }
 
 // Map returns the underlying data map.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (m *IntStrMap) Map() map[int]string {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if !m.mu.IsSafe() {
-		return m.data
-	}
-	data := make(map[int]string, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.Map()
 }
 
 // MapStrAny returns a copy of the underlying data of the map as map[string]any.
 func (m *IntStrMap) MapStrAny() map[string]any {
-	m.mu.RLock()
-	data := make(map[string]any, len(m.data))
-	for k, v := range m.data {
-		data[gconv.String(k)] = v
-	}
-	m.mu.RUnlock()
-	return data
+	m.lazyInit()
+	return m.KVMap.MapStrAny()
 }
 
 // MapCopy returns a copy of the underlying data of the hash map.
 func (m *IntStrMap) MapCopy() map[int]string {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[int]string, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.MapCopy()
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *IntStrMap) FilterEmpty() {
-	m.mu.Lock()
-	for k, v := range m.data {
-		if empty.IsEmpty(v) {
-			delete(m.data, k)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.FilterEmpty()
 }
 
 // Set sets key-value to the hash map.
 func (m *IntStrMap) Set(key int, val string) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = make(map[int]string)
-	}
-	m.data[key] = val
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Set(key, val)
 }
 
 // Sets batch sets key-values to the hash map.
 func (m *IntStrMap) Sets(data map[int]string) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = data
-	} else {
-		for k, v := range data {
-			m.data[k] = v
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Sets(data)
 }
 
 // Search searches the map with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (m *IntStrMap) Search(key int) (value string, found bool) {
-	m.mu.RLock()
-	if m.data != nil {
-		value, found = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Search(key)
 }
 
 // Get returns the value by given `key`.
 func (m *IntStrMap) Get(key int) (value string) {
-	m.mu.RLock()
-	if m.data != nil {
-		value = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Get(key)
 }
 
 // Pop retrieves and deletes an item from the map.
 func (m *IntStrMap) Pop() (key int, value string) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	for key, value = range m.data {
-		delete(m.data, key)
-		return
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Pop()
 }
 
 // Pops retrieves and deletes `size` items from the map.
 // It returns all items if size == -1.
 func (m *IntStrMap) Pops(size int) map[int]string {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if size > len(m.data) || size == -1 {
-		size = len(m.data)
-	}
-	if size == 0 {
-		return nil
-	}
-	var (
-		index  = 0
-		newMap = make(map[int]string, size)
-	)
-	for k, v := range m.data {
-		delete(m.data, k)
-		newMap[k] = v
-		index++
-		if index == size {
-			break
-		}
-	}
-	return newMap
-}
-
-// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
-// if not exists, set value to the map with given `key`,
-// or else just return the existing value.
-//
-// It returns value with given `key`.
-func (m *IntStrMap) doSetWithLockCheck(key int, value string) string {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[int]string)
-	}
-	if v, ok := m.data[key]; ok {
-		return v
-	}
-	m.data[key] = value
-	return value
+	m.lazyInit()
+	return m.KVMap.Pops(size)
 }
 
 // GetOrSet returns the value by key,
 // or sets value with given `value` if it does not exist and then returns this value.
 func (m *IntStrMap) GetOrSet(key int, value string) string {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, value)
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSet(key, value)
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist and returns this value.
 func (m *IntStrMap) GetOrSetFunc(key int, f func() string) string {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, f())
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFunc(key, f)
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -229,41 +143,22 @@ func (m *IntStrMap) GetOrSetFunc(key int, f func() string) string {
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
 func (m *IntStrMap) GetOrSetFuncLock(key int, f func() string) string {
-	if v, ok := m.Search(key); !ok {
-		m.mu.Lock()
-		defer m.mu.Unlock()
-		if m.data == nil {
-			m.data = make(map[int]string)
-		}
-		if v, ok = m.data[key]; ok {
-			return v
-		}
-		v = f()
-		m.data[key] = v
-		return v
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFuncLock(key, f)
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *IntStrMap) SetIfNotExist(key int, value string) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, value)
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExist(key, value)
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *IntStrMap) SetIfNotExistFunc(key int, f func() string) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, f())
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFunc(key, f)
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -272,126 +167,76 @@ func (m *IntStrMap) SetIfNotExistFunc(key int, f func() string) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the hash map.
 func (m *IntStrMap) SetIfNotExistFuncLock(key int, f func() string) bool {
-	if !m.Contains(key) {
-		m.mu.Lock()
-		defer m.mu.Unlock()
-		if m.data == nil {
-			m.data = make(map[int]string)
-		}
-		if _, ok := m.data[key]; !ok {
-			m.data[key] = f()
-		}
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFuncLock(key, f)
 }
 
 // Removes batch deletes values of the map by keys.
 func (m *IntStrMap) Removes(keys []int) {
-	m.mu.Lock()
-	if m.data != nil {
-		for _, key := range keys {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Removes(keys)
 }
 
 // Remove deletes value from map by given `key`, and return this deleted value.
 func (m *IntStrMap) Remove(key int) (value string) {
-	m.mu.Lock()
-	if m.data != nil {
-		var ok bool
-		if value, ok = m.data[key]; ok {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Remove(key)
 }
 
 // Keys returns all keys of the map as a slice.
 func (m *IntStrMap) Keys() []int {
-	m.mu.RLock()
-	var (
-		keys  = make([]int, len(m.data))
-		index = 0
-	)
-	for key := range m.data {
-		keys[index] = key
-		index++
-	}
-	m.mu.RUnlock()
-	return keys
+	m.lazyInit()
+	return m.KVMap.Keys()
 }
 
 // Values returns all values of the map as a slice.
 func (m *IntStrMap) Values() []string {
-	m.mu.RLock()
-	var (
-		values = make([]string, len(m.data))
-		index  = 0
-	)
-	for _, value := range m.data {
-		values[index] = value
-		index++
-	}
-	m.mu.RUnlock()
-	return values
+	m.lazyInit()
+	return m.KVMap.Values()
 }
 
 // Contains checks whether a key exists.
 // It returns true if the `key` exists, or else false.
 func (m *IntStrMap) Contains(key int) bool {
-	var ok bool
-	m.mu.RLock()
-	if m.data != nil {
-		_, ok = m.data[key]
-	}
-	m.mu.RUnlock()
-	return ok
+	m.lazyInit()
+	return m.KVMap.Contains(key)
 }
 
 // Size returns the size of the map.
 func (m *IntStrMap) Size() int {
-	m.mu.RLock()
-	length := len(m.data)
-	m.mu.RUnlock()
-	return length
+	m.lazyInit()
+	return m.KVMap.Size()
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *IntStrMap) IsEmpty() bool {
-	return m.Size() == 0
+	m.lazyInit()
+	return m.KVMap.IsEmpty()
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *IntStrMap) Clear() {
-	m.mu.Lock()
-	m.data = make(map[int]string)
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Clear()
 }
 
 // Replace the data of the map with given `data`.
 func (m *IntStrMap) Replace(data map[int]string) {
-	m.mu.Lock()
-	m.data = data
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Replace(data)
 }
 
 // LockFunc locks writing with given callback function `f` within RWMutex.Lock.
 func (m *IntStrMap) LockFunc(f func(m map[int]string)) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.LockFunc(f)
 }
 
 // RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
 func (m *IntStrMap) RLockFunc(f func(m map[int]string)) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.RLockFunc(f)
 }
 
 // Flip exchanges key-value of the map to value-key.
@@ -408,19 +253,8 @@ func (m *IntStrMap) Flip() {
 // Merge merges two hash maps.
 // The `other` map will be merged into the map `m`.
 func (m *IntStrMap) Merge(other *IntStrMap) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = other.MapCopy()
-		return
-	}
-	if other != m {
-		other.mu.RLock()
-		defer other.mu.RUnlock()
-	}
-	for k, v := range other.data {
-		m.data[k] = v
-	}
+	m.lazyInit()
+	m.KVMap.Merge(other.KVMap)
 }
 
 // String returns the map as a string.
@@ -428,81 +262,40 @@ func (m *IntStrMap) String() string {
 	if m == nil {
 		return ""
 	}
-	b, _ := m.MarshalJSON()
-	return string(b)
+	m.lazyInit()
+	return m.KVMap.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m IntStrMap) MarshalJSON() ([]byte, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return json.Marshal(m.data)
+	m.lazyInit()
+	return m.KVMap.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (m *IntStrMap) UnmarshalJSON(b []byte) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[int]string)
-	}
-	if err := json.UnmarshalUseNumber(b, &m.data); err != nil {
-		return err
-	}
-	return nil
+	m.lazyInit()
+	return m.KVMap.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
 func (m *IntStrMap) UnmarshalValue(value any) (err error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[int]string)
-	}
-	switch value.(type) {
-	case string, []byte:
-		return json.UnmarshalUseNumber(gconv.Bytes(value), &m.data)
-	default:
-		for k, v := range gconv.Map(value) {
-			m.data[gconv.Int(k)] = gconv.String(v)
-		}
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.UnmarshalValue(value)
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *IntStrMap) DeepCopy() any {
-	if m == nil {
-		return nil
+	m.lazyInit()
+	return &IntStrMap{
+		KVMap: m.KVMap.DeepCopy().(*KVMap[int, string]),
 	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[int]string, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return NewIntStrMapFrom(data, m.mu.IsSafe())
 }
 
 // IsSubOf checks whether the current map is a sub-map of `other`.
 func (m *IntStrMap) IsSubOf(other *IntStrMap) bool {
-	if m == other {
-		return true
-	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	for key, value := range m.data {
-		otherValue, ok := other.data[key]
-		if !ok {
-			return false
-		}
-		if otherValue != value {
-			return false
-		}
-	}
-	return true
+	m.lazyInit()
+	return m.KVMap.IsSubOf(other.KVMap)
 }
 
 // Diff compares current map `m` with map `other` and returns their different keys.
@@ -510,22 +303,6 @@ func (m *IntStrMap) IsSubOf(other *IntStrMap) bool {
 // The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
 // The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
 func (m *IntStrMap) Diff(other *IntStrMap) (addedKeys, removedKeys, updatedKeys []int) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-
-	for key := range m.data {
-		if _, ok := other.data[key]; !ok {
-			removedKeys = append(removedKeys, key)
-		} else if m.data[key] != other.data[key] {
-			updatedKeys = append(updatedKeys, key)
-		}
-	}
-	for key := range other.data {
-		if _, ok := m.data[key]; !ok {
-			addedKeys = append(addedKeys, key)
-		}
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Diff(other.KVMap)
 }
diff --git a/container/gmap/gmap_hash_k_v_map.go b/container/gmap/gmap_hash_k_v_map.go
new file mode 100644
index 000000000..c8f6372e0
--- /dev/null
+++ b/container/gmap/gmap_hash_k_v_map.go
@@ -0,0 +1,633 @@
+// 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 gmap
+
+import (
+	"reflect"
+
+	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/deepcopy"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+// NilChecker is a function that checks whether the given value is nil.
+type NilChecker[V any] func(V) bool
+
+// KVMap wraps map type `map[K]V` and provides more map features.
+type KVMap[K comparable, V any] struct {
+	mu   rwmutex.RWMutex
+	data map[K]V
+
+	// nilChecker is the custom nil checker function.
+	// It uses empty.IsNil if it's nil.
+	nilChecker NilChecker[V]
+}
+
+// NewKVMap creates and returns an empty hash map.
+// The parameter `safe` is used to specify whether to use the map in concurrent-safety mode, which is false by default.
+func NewKVMap[K comparable, V any](safe ...bool) *KVMap[K, V] {
+	return NewKVMapFrom(make(map[K]V), safe...)
+}
+
+// NewKVMapWithChecker creates and returns an empty hash map with a custom nil checker.
+// The parameter `checker` is a function used to determine if a value is nil.
+// The parameter `safe` is used to specify whether to use the map in concurrent-safety mode, which is false by default.
+func NewKVMapWithChecker[K comparable, V any](checker NilChecker[V], safe ...bool) *KVMap[K, V] {
+	return NewKVMapWithCheckerFrom(make(map[K]V), checker, safe...)
+}
+
+// NewKVMapFrom creates and returns a hash map from given map `data`.
+// Note that, the param `data` map will be set as the underlying data map (no deep copy),
+// there might be some concurrent-safe issues when changing the map outside.
+func NewKVMapFrom[K comparable, V any](data map[K]V, safe ...bool) *KVMap[K, V] {
+	m := &KVMap[K, V]{
+		mu:   rwmutex.Create(safe...),
+		data: data,
+	}
+	return m
+}
+
+// NewKVMapWithCheckerFrom creates and returns a hash map from given map `data` with a custom nil checker.
+// Note that, the param `data` map will be set as the underlying data map (no deep copy),
+// and there might be some concurrent-safe issues when changing the map outside.
+// The parameter `checker` is a function used to determine if a value is nil.
+// The parameter `safe` is used to specify whether to use the map in concurrent-safety mode, which is false by default.
+func NewKVMapWithCheckerFrom[K comparable, V any](data map[K]V, checker NilChecker[V], safe ...bool) *KVMap[K, V] {
+	m := NewKVMapFrom[K, V](data, safe...)
+	m.SetNilChecker(checker)
+	return m
+}
+
+// SetNilChecker registers a custom nil checker function for the map values.
+// This function is used to determine if a value should be considered as nil.
+// The nil checker function takes a value of type V and returns a boolean indicating
+// whether the value should be treated as nil.
+func (m *KVMap[K, V]) SetNilChecker(nilChecker NilChecker[V]) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.nilChecker = nilChecker
+}
+
+// isNil checks whether the given value is nil.
+// It first checks if a custom nil checker function is registered and uses it if available,
+// otherwise it falls back to the default empty.IsNil function.
+func (m *KVMap[K, V]) isNil(v V) bool {
+	if m.nilChecker != nil {
+		return m.nilChecker(v)
+	}
+	return empty.IsNil(v)
+}
+
+// Iterator iterates the hash map readonly with custom callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (m *KVMap[K, V]) Iterator(f func(k K, v V) bool) {
+	for k, v := range m.Map() {
+		if !f(k, v) {
+			break
+		}
+	}
+}
+
+// Clone returns a new hash map with copy of current map data.
+func (m *KVMap[K, V]) Clone(safe ...bool) *KVMap[K, V] {
+	if len(safe) == 0 {
+		return NewKVMapFrom(m.MapCopy(), m.mu.IsSafe())
+	}
+	return NewKVMapFrom(m.MapCopy(), safe...)
+}
+
+// Map returns the underlying data map.
+// Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
+// or else a pointer to the underlying data.
+func (m *KVMap[K, V]) Map() map[K]V {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	if !m.mu.IsSafe() {
+		return m.data
+	}
+	data := make(map[K]V, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return data
+}
+
+// MapCopy returns a shallow copy of the underlying data of the hash map.
+func (m *KVMap[K, V]) MapCopy() map[K]V {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[K]V, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return data
+}
+
+// MapStrAny returns a copy of the underlying data of the map as map[string]any.
+func (m *KVMap[K, V]) MapStrAny() map[string]any {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[string]any, len(m.data))
+	for k, v := range m.data {
+		data[gconv.String(k)] = v
+	}
+	return data
+}
+
+// FilterEmpty deletes all key-value pair of which the value is empty.
+// Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
+func (m *KVMap[K, V]) FilterEmpty() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for k, v := range m.data {
+		if empty.IsEmpty(v) {
+			delete(m.data, k)
+		}
+	}
+}
+
+// FilterNil deletes all key-value pair of which the value is nil.
+func (m *KVMap[K, V]) FilterNil() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for k, v := range m.data {
+		if empty.IsNil(v) {
+			delete(m.data, k)
+		}
+	}
+}
+
+// Set sets key-value to the hash map.
+func (m *KVMap[K, V]) Set(key K, value V) {
+	m.mu.Lock()
+	if m.data == nil {
+		m.data = make(map[K]V)
+	}
+	m.data[key] = value
+	m.mu.Unlock()
+}
+
+// Sets batch sets key-values to the hash map.
+func (m *KVMap[K, V]) Sets(data map[K]V) {
+	m.mu.Lock()
+	if m.data == nil {
+		m.data = data
+	} else {
+		for k, v := range data {
+			m.data[k] = v
+		}
+	}
+	m.mu.Unlock()
+}
+
+// Search searches the map with given `key`.
+// Second return parameter `found` is true if key was found, otherwise false.
+func (m *KVMap[K, V]) Search(key K) (value V, found bool) {
+	m.mu.RLock()
+	if m.data != nil {
+		value, found = m.data[key]
+	}
+	m.mu.RUnlock()
+	return
+}
+
+// Get returns the value by given `key`.
+func (m *KVMap[K, V]) Get(key K) (value V) {
+	m.mu.RLock()
+	if m.data != nil {
+		value = m.data[key]
+	}
+	m.mu.RUnlock()
+	return
+}
+
+// Pop retrieves and deletes an item from the map.
+func (m *KVMap[K, V]) Pop() (key K, value V) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for key, value = range m.data {
+		delete(m.data, key)
+		return
+	}
+	return
+}
+
+// Pops retrieves and deletes `size` items from the map.
+// It returns all items if size == -1.
+func (m *KVMap[K, V]) Pops(size int) map[K]V {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if size > len(m.data) || size == -1 {
+		size = len(m.data)
+	}
+	if size == 0 {
+		return nil
+	}
+	var (
+		index  = 0
+		newMap = make(map[K]V, size)
+	)
+	for k, v := range m.data {
+		delete(m.data, k)
+		newMap[k] = v
+		index++
+		if index == size {
+			break
+		}
+	}
+	return newMap
+}
+
+// doSetWithLockCheck sets value with given `value` if it does not exist,
+// and then returns this value and whether it exists.
+//
+// It is a helper function for GetOrSet* functions.
+//
+// Note that, it does not add the value to the map if the given `value` is nil.
+func (m *KVMap[K, V]) doSetWithLockCheck(key K, value V) (val V, ok bool) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.data == nil {
+		m.data = make(map[K]V)
+	}
+
+	if v, ok := m.data[key]; ok {
+		return v, true
+	}
+	if !m.isNil(value) {
+		m.data[key] = value
+	}
+	return value, false
+}
+
+// GetOrSet returns the value by key,
+// or sets value with given `value` if it does not exist and then returns this value.
+func (m *KVMap[K, V]) GetOrSet(key K, value V) V {
+	v, _ := m.doSetWithLockCheck(key, value)
+	return v
+}
+
+// GetOrSetFunc returns the value by key,
+// or sets value with returned value of callback function `f` if it does not exist
+// and then returns this value.
+//
+// Note that, it does not add the value to the map if the returned value of `f` is nil.
+func (m *KVMap[K, V]) GetOrSetFunc(key K, f func() V) V {
+	v, _ := m.doSetWithLockCheck(key, f())
+	return v
+}
+
+// GetOrSetFuncLock returns the value by key,
+// or sets value with returned value of callback function `f` if it does not exist
+// and then returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
+// with mutex.Lock of the hash map.
+//
+// Note that, it does not add the value to the map if the returned value of `f` is nil.
+func (m *KVMap[K, V]) GetOrSetFuncLock(key K, f func() V) V {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[K]V)
+	}
+	if v, ok := m.data[key]; ok {
+		return v
+	}
+	value := f()
+	if !m.isNil(value) {
+		m.data[key] = value
+	}
+	return value
+}
+
+// GetVar returns a Var with the value by given `key`.
+// The returned Var is un-concurrent safe.
+func (m *KVMap[K, V]) GetVar(key K) *gvar.Var {
+	return gvar.New(m.Get(key))
+}
+
+// GetVarOrSet returns a Var with result from GetOrSet.
+// The returned Var is un-concurrent safe.
+func (m *KVMap[K, V]) GetVarOrSet(key K, value V) *gvar.Var {
+	return gvar.New(m.GetOrSet(key, value))
+}
+
+// GetVarOrSetFunc returns a Var with result from GetOrSetFunc.
+// The returned Var is un-concurrent safe.
+func (m *KVMap[K, V]) GetVarOrSetFunc(key K, f func() V) *gvar.Var {
+	return gvar.New(m.GetOrSetFunc(key, f))
+}
+
+// GetVarOrSetFuncLock returns a Var with result from GetOrSetFuncLock.
+// The returned Var is un-concurrent safe.
+func (m *KVMap[K, V]) GetVarOrSetFuncLock(key K, f func() V) *gvar.Var {
+	return gvar.New(m.GetOrSetFuncLock(key, f))
+}
+
+// SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
+// It returns false if `key` exists, and `value` would be ignored.
+func (m *KVMap[K, V]) SetIfNotExist(key K, value V) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[K]V)
+	}
+	if _, ok := m.data[key]; !ok {
+		m.data[key] = value
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
+// It returns false if `key` exists, and `value` would be ignored.
+func (m *KVMap[K, V]) SetIfNotExistFunc(key K, f func() V) bool {
+	if !m.Contains(key) {
+		return m.SetIfNotExist(key, f())
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
+// It returns false if `key` exists, and `value` would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function `f` with mutex.Lock of the hash map.
+func (m *KVMap[K, V]) SetIfNotExistFuncLock(key K, f func() V) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[K]V)
+	}
+	if _, ok := m.data[key]; !ok {
+		m.data[key] = f()
+		return true
+	}
+	return false
+}
+
+// Remove deletes value from map by given `key`, and return this deleted value.
+func (m *KVMap[K, V]) Remove(key K) (value V) {
+	m.mu.Lock()
+	if m.data != nil {
+		var ok bool
+		if value, ok = m.data[key]; ok {
+			delete(m.data, key)
+		}
+	}
+	m.mu.Unlock()
+	return
+}
+
+// Removes batch deletes values of the map by keys.
+func (m *KVMap[K, V]) Removes(keys []K) {
+	m.mu.Lock()
+	if m.data != nil {
+		for _, key := range keys {
+			delete(m.data, key)
+		}
+	}
+	m.mu.Unlock()
+}
+
+// Keys returns all keys of the map as a slice.
+func (m *KVMap[K, V]) Keys() []K {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	var (
+		keys  = make([]K, len(m.data))
+		index = 0
+	)
+	for key := range m.data {
+		keys[index] = key
+		index++
+	}
+	return keys
+}
+
+// Values returns all values of the map as a slice.
+func (m *KVMap[K, V]) Values() []V {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	var (
+		values = make([]V, len(m.data))
+		index  = 0
+	)
+	for _, value := range m.data {
+		values[index] = value
+		index++
+	}
+	return values
+}
+
+// Contains checks whether a key exists.
+// It returns true if the `key` exists, or else false.
+func (m *KVMap[K, V]) Contains(key K) bool {
+	var ok bool
+	m.mu.RLock()
+	if m.data != nil {
+		_, ok = m.data[key]
+	}
+	m.mu.RUnlock()
+	return ok
+}
+
+// Size returns the size of the map.
+func (m *KVMap[K, V]) Size() int {
+	m.mu.RLock()
+	length := len(m.data)
+	m.mu.RUnlock()
+	return length
+}
+
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
+func (m *KVMap[K, V]) IsEmpty() bool {
+	return m.Size() == 0
+}
+
+// Clear deletes all data of the map, it will remake a new underlying data map.
+func (m *KVMap[K, V]) Clear() {
+	m.mu.Lock()
+	m.data = make(map[K]V)
+	m.mu.Unlock()
+}
+
+// Replace the data of the map with given `data`.
+func (m *KVMap[K, V]) Replace(data map[K]V) {
+	m.mu.Lock()
+	m.data = data
+	m.mu.Unlock()
+}
+
+// LockFunc locks writing with given callback function `f` within RWMutex.Lock.
+func (m *KVMap[K, V]) LockFunc(f func(m map[K]V)) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	f(m.data)
+}
+
+// RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
+func (m *KVMap[K, V]) RLockFunc(f func(m map[K]V)) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	f(m.data)
+}
+
+// Flip exchanges key-value of the map to value-key.
+func (m *KVMap[K, V]) Flip() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	n := make(map[K]V, len(m.data))
+	for k, v := range m.data {
+		var (
+			k0 K
+			v0 V
+		)
+		if err := gconv.Scan(v, &k0); err != nil {
+			continue
+		}
+		if err := gconv.Scan(k, &v0); err != nil {
+			continue
+		}
+		n[k0] = v0
+	}
+	m.data = n
+}
+
+// Merge merges two hash maps.
+// The `other` map will be merged into the map `m`.
+func (m *KVMap[K, V]) Merge(other *KVMap[K, V]) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = other.MapCopy()
+		return
+	}
+	if other != m {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.data {
+		m.data[k] = v
+	}
+}
+
+// String returns the map as a string.
+func (m *KVMap[K, V]) String() string {
+	if m == nil {
+		return ""
+	}
+	b, _ := m.MarshalJSON()
+	return string(b)
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+// DO NOT change this receiver to pointer type, as the KVMap can be used as a var defined variable, like:
+// var m gmap.KVMap[int, string]
+// Please refer to corresponding tests for more details.
+func (m KVMap[K, V]) MarshalJSON() ([]byte, error) {
+	return json.Marshal(gconv.Map(m.Map()))
+}
+
+// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
+func (m *KVMap[K, V]) UnmarshalJSON(b []byte) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[K]V)
+	}
+	var data map[string]V
+	if err := json.UnmarshalUseNumber(b, &data); err != nil {
+		return err
+	}
+	if err := gconv.Scan(data, &m.data); err != nil {
+		return err
+	}
+	return nil
+}
+
+// UnmarshalValue is an interface implement which sets any type of value for map.
+func (m *KVMap[K, V]) UnmarshalValue(value any) (err error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[K]V)
+	}
+	data := gconv.Map(value)
+	if err := gconv.Scan(data, &m.data); err != nil {
+		return err
+	}
+	return
+}
+
+// DeepCopy implements interface for deep copy of current type.
+func (m *KVMap[K, V]) DeepCopy() any {
+	if m == nil {
+		return nil
+	}
+
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[K]V, len(m.data))
+	for k, v := range m.data {
+		data[k] = deepcopy.Copy(v).(V)
+	}
+	return NewKVMapFrom(data, m.mu.IsSafe())
+}
+
+// IsSubOf checks whether the current map is a sub-map of `other`.
+func (m *KVMap[K, V]) IsSubOf(other *KVMap[K, V]) bool {
+	if m == other {
+		return true
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+	for key, value := range m.data {
+		otherValue, ok := other.data[key]
+		if !ok {
+			return false
+		}
+
+		if !reflect.DeepEqual(otherValue, value) {
+			return false
+		}
+	}
+	return true
+}
+
+// Diff compares current map `m` with map `other` and returns their different keys.
+// The returned `addedKeys` are the keys that are in map `m` but not in map `other`.
+// The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
+// The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
+func (m *KVMap[K, V]) Diff(other *KVMap[K, V]) (addedKeys, removedKeys, updatedKeys []K) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+
+	for key := range m.data {
+		if _, ok := other.data[key]; !ok {
+			removedKeys = append(removedKeys, key)
+		} else if !reflect.DeepEqual(m.data[key], other.data[key]) {
+			updatedKeys = append(updatedKeys, key)
+		}
+	}
+	for key := range other.data {
+		if _, ok := m.data[key]; !ok {
+			addedKeys = append(addedKeys, key)
+		}
+	}
+	return
+}
diff --git a/container/gmap/gmap_hash_str_any_map.go b/container/gmap/gmap_hash_str_any_map.go
index 467b956c8..9e5db668f 100644
--- a/container/gmap/gmap_hash_str_any_map.go
+++ b/container/gmap/gmap_hash_str_any_map.go
@@ -1,78 +1,73 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 //
 
 package gmap
 
 import (
-	"reflect"
+	"sync"
 
 	"github.com/gogf/gf/v2/container/gvar"
-	"github.com/gogf/gf/v2/internal/deepcopy"
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // StrAnyMap implements map[string]any with RWMutex that has switch.
 type StrAnyMap struct {
-	mu   rwmutex.RWMutex
-	data map[string]any
+	*KVMap[string, any]
+	once sync.Once
 }
 
 // NewStrAnyMap returns an empty StrAnyMap object.
 // The parameter `safe` is used to specify whether using map in concurrent-safety,
 // which is false in default.
 func NewStrAnyMap(safe ...bool) *StrAnyMap {
-	return &StrAnyMap{
-		mu:   rwmutex.Create(safe...),
-		data: make(map[string]any),
+	m := &StrAnyMap{
+		KVMap: NewKVMap[string, any](safe...),
 	}
+	return m
 }
 
 // NewStrAnyMapFrom creates and returns a hash map from given map `data`.
 // Note that, the param `data` map will be set as the underlying data map(no deep copy),
 // there might be some concurrent-safe issues when changing the map outside.
 func NewStrAnyMapFrom(data map[string]any, safe ...bool) *StrAnyMap {
-	return &StrAnyMap{
-		mu:   rwmutex.Create(safe...),
-		data: data,
+	m := &StrAnyMap{
+		KVMap: NewKVMapFrom(data, safe...),
 	}
+	return m
+}
+
+// lazyInit lazily initializes the map.
+func (m *StrAnyMap) lazyInit() {
+	m.once.Do(func() {
+		if m.KVMap == nil {
+			m.KVMap = NewKVMap[string, any](false)
+		}
+	})
 }
 
 // Iterator iterates the hash map readonly with custom callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (m *StrAnyMap) Iterator(f func(k string, v any) bool) {
-	for k, v := range m.Map() {
-		if !f(k, v) {
-			break
-		}
-	}
+	m.lazyInit()
+	m.KVMap.Iterator(f)
 }
 
 // Clone returns a new hash map with copy of current map data.
-func (m *StrAnyMap) Clone() *StrAnyMap {
-	return NewStrAnyMapFrom(m.MapCopy(), m.mu.IsSafe())
+func (m *StrAnyMap) Clone(safe ...bool) *StrAnyMap {
+	m.lazyInit()
+	return NewStrAnyMapFrom(m.MapCopy(), safe...)
 }
 
 // Map returns the underlying data map.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (m *StrAnyMap) Map() map[string]any {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if !m.mu.IsSafe() {
-		return m.data
-	}
-	data := make(map[string]any, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.Map()
 }
 
 // MapStrAny returns a copy of the underlying data of the map as map[string]any.
@@ -82,165 +77,74 @@ func (m *StrAnyMap) MapStrAny() map[string]any {
 
 // MapCopy returns a copy of the underlying data of the hash map.
 func (m *StrAnyMap) MapCopy() map[string]any {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[string]any, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.MapCopy()
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *StrAnyMap) FilterEmpty() {
-	m.mu.Lock()
-	for k, v := range m.data {
-		if empty.IsEmpty(v) {
-			delete(m.data, k)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.FilterEmpty()
 }
 
 // FilterNil deletes all key-value pair of which the value is nil.
 func (m *StrAnyMap) FilterNil() {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	for k, v := range m.data {
-		if empty.IsNil(v) {
-			delete(m.data, k)
-		}
-	}
+	m.lazyInit()
+	m.KVMap.FilterNil()
 }
 
 // Set sets key-value to the hash map.
 func (m *StrAnyMap) Set(key string, val any) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = make(map[string]any)
-	}
-	m.data[key] = val
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Set(key, val)
 }
 
 // Sets batch sets key-values to the hash map.
 func (m *StrAnyMap) Sets(data map[string]any) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = data
-	} else {
-		for k, v := range data {
-			m.data[k] = v
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Sets(data)
 }
 
 // Search searches the map with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (m *StrAnyMap) Search(key string) (value any, found bool) {
-	m.mu.RLock()
-	if m.data != nil {
-		value, found = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Search(key)
 }
 
 // Get returns the value by given `key`.
 func (m *StrAnyMap) Get(key string) (value any) {
-	m.mu.RLock()
-	if m.data != nil {
-		value = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Get(key)
 }
 
 // Pop retrieves and deletes an item from the map.
 func (m *StrAnyMap) Pop() (key string, value any) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	for key, value = range m.data {
-		delete(m.data, key)
-		return
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Pop()
 }
 
 // Pops retrieves and deletes `size` items from the map.
 // It returns all items if size == -1.
 func (m *StrAnyMap) Pops(size int) map[string]any {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if size > len(m.data) || size == -1 {
-		size = len(m.data)
-	}
-	if size == 0 {
-		return nil
-	}
-	var (
-		index  = 0
-		newMap = make(map[string]any, size)
-	)
-	for k, v := range m.data {
-		delete(m.data, k)
-		newMap[k] = v
-		index++
-		if index == size {
-			break
-		}
-	}
-	return newMap
-}
-
-// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
-// if not exists, set value to the map with given `key`,
-// or else just return the existing value.
-//
-// When setting value, if `value` is type of `func() interface {}`,
-// it will be executed with mutex.Lock of the hash map,
-// and its return value will be set to the map with `key`.
-//
-// It returns value with given `key`.
-func (m *StrAnyMap) doSetWithLockCheck(key string, value any) any {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[string]any)
-	}
-	if v, ok := m.data[key]; ok {
-		return v
-	}
-	if f, ok := value.(func() any); ok {
-		value = f()
-	}
-	if value != nil {
-		m.data[key] = value
-	}
-	return value
+	m.lazyInit()
+	return m.KVMap.Pops(size)
 }
 
 // GetOrSet returns the value by key,
 // or sets value with given `value` if it does not exist and then returns this value.
 func (m *StrAnyMap) GetOrSet(key string, value any) any {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, value)
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSet(key, value)
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist
 // and then returns this value.
 func (m *StrAnyMap) GetOrSetFunc(key string, f func() any) any {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, f())
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFunc(key, f)
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -250,55 +154,50 @@ func (m *StrAnyMap) GetOrSetFunc(key string, f func() any) any {
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
 func (m *StrAnyMap) GetOrSetFuncLock(key string, f func() any) any {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, f)
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFuncLock(key, f)
 }
 
 // GetVar returns a Var with the value by given `key`.
 // The returned Var is un-concurrent safe.
 func (m *StrAnyMap) GetVar(key string) *gvar.Var {
-	return gvar.New(m.Get(key))
+	m.lazyInit()
+	return m.KVMap.GetVar(key)
 }
 
 // GetVarOrSet returns a Var with result from GetVarOrSet.
 // The returned Var is un-concurrent safe.
 func (m *StrAnyMap) GetVarOrSet(key string, value any) *gvar.Var {
-	return gvar.New(m.GetOrSet(key, value))
+	m.lazyInit()
+	return m.KVMap.GetVarOrSet(key, value)
 }
 
 // GetVarOrSetFunc returns a Var with result from GetOrSetFunc.
 // The returned Var is un-concurrent safe.
 func (m *StrAnyMap) GetVarOrSetFunc(key string, f func() any) *gvar.Var {
-	return gvar.New(m.GetOrSetFunc(key, f))
+	m.lazyInit()
+	return m.KVMap.GetVarOrSetFunc(key, f)
 }
 
 // GetVarOrSetFuncLock returns a Var with result from GetOrSetFuncLock.
 // The returned Var is un-concurrent safe.
 func (m *StrAnyMap) GetVarOrSetFuncLock(key string, f func() any) *gvar.Var {
-	return gvar.New(m.GetOrSetFuncLock(key, f))
+	m.lazyInit()
+	return m.KVMap.GetVarOrSetFuncLock(key, f)
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *StrAnyMap) SetIfNotExist(key string, value any) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, value)
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExist(key, value)
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *StrAnyMap) SetIfNotExistFunc(key string, f func() any) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, f())
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFunc(key, f)
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -307,119 +206,76 @@ func (m *StrAnyMap) SetIfNotExistFunc(key string, f func() any) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the hash map.
 func (m *StrAnyMap) SetIfNotExistFuncLock(key string, f func() any) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, f)
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFuncLock(key, f)
 }
 
 // Removes batch deletes values of the map by keys.
 func (m *StrAnyMap) Removes(keys []string) {
-	m.mu.Lock()
-	if m.data != nil {
-		for _, key := range keys {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Removes(keys)
 }
 
 // Remove deletes value from map by given `key`, and return this deleted value.
 func (m *StrAnyMap) Remove(key string) (value any) {
-	m.mu.Lock()
-	if m.data != nil {
-		var ok bool
-		if value, ok = m.data[key]; ok {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Remove(key)
 }
 
 // Keys returns all keys of the map as a slice.
 func (m *StrAnyMap) Keys() []string {
-	m.mu.RLock()
-	var (
-		keys  = make([]string, len(m.data))
-		index = 0
-	)
-	for key := range m.data {
-		keys[index] = key
-		index++
-	}
-	m.mu.RUnlock()
-	return keys
+	m.lazyInit()
+	return m.KVMap.Keys()
 }
 
 // Values returns all values of the map as a slice.
 func (m *StrAnyMap) Values() []any {
-	m.mu.RLock()
-	var (
-		values = make([]any, len(m.data))
-		index  = 0
-	)
-	for _, value := range m.data {
-		values[index] = value
-		index++
-	}
-	m.mu.RUnlock()
-	return values
+	m.lazyInit()
+	return m.KVMap.Values()
 }
 
 // Contains checks whether a key exists.
 // It returns true if the `key` exists, or else false.
 func (m *StrAnyMap) Contains(key string) bool {
-	var ok bool
-	m.mu.RLock()
-	if m.data != nil {
-		_, ok = m.data[key]
-	}
-	m.mu.RUnlock()
-	return ok
+	m.lazyInit()
+	return m.KVMap.Contains(key)
 }
 
 // Size returns the size of the map.
 func (m *StrAnyMap) Size() int {
-	m.mu.RLock()
-	length := len(m.data)
-	m.mu.RUnlock()
-	return length
+	m.lazyInit()
+	return m.KVMap.Size()
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *StrAnyMap) IsEmpty() bool {
-	return m.Size() == 0
+	m.lazyInit()
+	return m.KVMap.IsEmpty()
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *StrAnyMap) Clear() {
-	m.mu.Lock()
-	m.data = make(map[string]any)
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Clear()
 }
 
 // Replace the data of the map with given `data`.
 func (m *StrAnyMap) Replace(data map[string]any) {
-	m.mu.Lock()
-	m.data = data
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Replace(data)
 }
 
 // LockFunc locks writing with given callback function `f` within RWMutex.Lock.
 func (m *StrAnyMap) LockFunc(f func(m map[string]any)) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.LockFunc(f)
 }
 
 // RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
 func (m *StrAnyMap) RLockFunc(f func(m map[string]any)) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.RLockFunc(f)
 }
 
 // Flip exchanges key-value of the map to value-key.
@@ -436,19 +292,8 @@ func (m *StrAnyMap) Flip() {
 // Merge merges two hash maps.
 // The `other` map will be merged into the map `m`.
 func (m *StrAnyMap) Merge(other *StrAnyMap) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = other.MapCopy()
-		return
-	}
-	if other != m {
-		other.mu.RLock()
-		defer other.mu.RUnlock()
-	}
-	for k, v := range other.data {
-		m.data[k] = v
-	}
+	m.lazyInit()
+	m.KVMap.Merge(other.KVMap)
 }
 
 // String returns the map as a string.
@@ -456,71 +301,40 @@ func (m *StrAnyMap) String() string {
 	if m == nil {
 		return ""
 	}
-	b, _ := m.MarshalJSON()
-	return string(b)
+	m.lazyInit()
+	return m.KVMap.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m StrAnyMap) MarshalJSON() ([]byte, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return json.Marshal(m.data)
+	m.lazyInit()
+	return m.KVMap.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (m *StrAnyMap) UnmarshalJSON(b []byte) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[string]any)
-	}
-	if err := json.UnmarshalUseNumber(b, &m.data); err != nil {
-		return err
-	}
-	return nil
+	m.lazyInit()
+	return m.KVMap.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
 func (m *StrAnyMap) UnmarshalValue(value any) (err error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.data = gconv.Map(value)
-	return
+	m.lazyInit()
+	return m.KVMap.UnmarshalValue(value)
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *StrAnyMap) DeepCopy() any {
-	if m == nil {
-		return nil
+	m.lazyInit()
+	return &StrAnyMap{
+		KVMap: m.KVMap.DeepCopy().(*KVMap[string, any]),
 	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[string]any, len(m.data))
-	for k, v := range m.data {
-		data[k] = deepcopy.Copy(v)
-	}
-	return NewStrAnyMapFrom(data, m.mu.IsSafe())
 }
 
 // IsSubOf checks whether the current map is a sub-map of `other`.
 func (m *StrAnyMap) IsSubOf(other *StrAnyMap) bool {
-	if m == other {
-		return true
-	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	for key, value := range m.data {
-		otherValue, ok := other.data[key]
-		if !ok {
-			return false
-		}
-		if otherValue != value {
-			return false
-		}
-	}
-	return true
+	m.lazyInit()
+	return m.KVMap.IsSubOf(other.KVMap)
 }
 
 // Diff compares current map `m` with map `other` and returns their different keys.
@@ -528,22 +342,6 @@ func (m *StrAnyMap) IsSubOf(other *StrAnyMap) bool {
 // The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
 // The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
 func (m *StrAnyMap) Diff(other *StrAnyMap) (addedKeys, removedKeys, updatedKeys []string) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-
-	for key := range m.data {
-		if _, ok := other.data[key]; !ok {
-			removedKeys = append(removedKeys, key)
-		} else if !reflect.DeepEqual(m.data[key], other.data[key]) {
-			updatedKeys = append(updatedKeys, key)
-		}
-	}
-	for key := range other.data {
-		if _, ok := m.data[key]; !ok {
-			addedKeys = append(addedKeys, key)
-		}
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Diff(other.KVMap)
 }
diff --git a/container/gmap/gmap_hash_str_int_map.go b/container/gmap/gmap_hash_str_int_map.go
index f9c582d55..6e2b098f4 100644
--- a/container/gmap/gmap_hash_str_int_map.go
+++ b/container/gmap/gmap_hash_str_int_map.go
@@ -1,23 +1,22 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 //
 
 package gmap
 
 import (
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
+	"sync"
+
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // StrIntMap implements map[string]int with RWMutex that has switch.
 type StrIntMap struct {
-	mu   rwmutex.RWMutex
-	data map[string]int
+	*KVMap[string, int]
+	once sync.Once
 }
 
 // NewStrIntMap returns an empty StrIntMap object.
@@ -25,8 +24,7 @@ type StrIntMap struct {
 // which is false in default.
 func NewStrIntMap(safe ...bool) *StrIntMap {
 	return &StrIntMap{
-		mu:   rwmutex.Create(safe...),
-		data: make(map[string]int),
+		KVMap: NewKVMap[string, int](safe...),
 	}
 }
 
@@ -35,195 +33,110 @@ func NewStrIntMap(safe ...bool) *StrIntMap {
 // there might be some concurrent-safe issues when changing the map outside.
 func NewStrIntMapFrom(data map[string]int, safe ...bool) *StrIntMap {
 	return &StrIntMap{
-		mu:   rwmutex.Create(safe...),
-		data: data,
+		KVMap: NewKVMapFrom(data, safe...),
 	}
 }
 
+// lazyInit lazily initializes the map.
+func (m *StrIntMap) lazyInit() {
+	m.once.Do(func() {
+		if m.KVMap == nil {
+			m.KVMap = NewKVMap[string, int](false)
+		}
+	})
+}
+
 // Iterator iterates the hash map readonly with custom callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (m *StrIntMap) Iterator(f func(k string, v int) bool) {
-	for k, v := range m.Map() {
-		if !f(k, v) {
-			break
-		}
-	}
+	m.lazyInit()
+	m.KVMap.Iterator(f)
 }
 
 // Clone returns a new hash map with copy of current map data.
-func (m *StrIntMap) Clone() *StrIntMap {
-	return NewStrIntMapFrom(m.MapCopy(), m.mu.IsSafe())
+func (m *StrIntMap) Clone(safe ...bool) *StrIntMap {
+	m.lazyInit()
+	return &StrIntMap{KVMap: m.KVMap.Clone(safe...)}
 }
 
 // Map returns the underlying data map.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (m *StrIntMap) Map() map[string]int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if !m.mu.IsSafe() {
-		return m.data
-	}
-	data := make(map[string]int, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.Map()
 }
 
 // MapStrAny returns a copy of the underlying data of the map as map[string]any.
 func (m *StrIntMap) MapStrAny() map[string]any {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[string]any, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.MapStrAny()
 }
 
 // MapCopy returns a copy of the underlying data of the hash map.
 func (m *StrIntMap) MapCopy() map[string]int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[string]int, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.MapCopy()
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *StrIntMap) FilterEmpty() {
-	m.mu.Lock()
-	for k, v := range m.data {
-		if empty.IsEmpty(v) {
-			delete(m.data, k)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.FilterEmpty()
 }
 
 // Set sets key-value to the hash map.
 func (m *StrIntMap) Set(key string, val int) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = make(map[string]int)
-	}
-	m.data[key] = val
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Set(key, val)
 }
 
 // Sets batch sets key-values to the hash map.
 func (m *StrIntMap) Sets(data map[string]int) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = data
-	} else {
-		for k, v := range data {
-			m.data[k] = v
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Sets(data)
 }
 
 // Search searches the map with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (m *StrIntMap) Search(key string) (value int, found bool) {
-	m.mu.RLock()
-	if m.data != nil {
-		value, found = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Search(key)
 }
 
 // Get returns the value by given `key`.
 func (m *StrIntMap) Get(key string) (value int) {
-	m.mu.RLock()
-	if m.data != nil {
-		value = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Get(key)
 }
 
 // Pop retrieves and deletes an item from the map.
 func (m *StrIntMap) Pop() (key string, value int) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	for key, value = range m.data {
-		delete(m.data, key)
-		return
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Pop()
 }
 
 // Pops retrieves and deletes `size` items from the map.
 // It returns all items if size == -1.
 func (m *StrIntMap) Pops(size int) map[string]int {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if size > len(m.data) || size == -1 {
-		size = len(m.data)
-	}
-	if size == 0 {
-		return nil
-	}
-	var (
-		index  = 0
-		newMap = make(map[string]int, size)
-	)
-	for k, v := range m.data {
-		delete(m.data, k)
-		newMap[k] = v
-		index++
-		if index == size {
-			break
-		}
-	}
-	return newMap
-}
-
-// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
-// if not exists, set value to the map with given `key`,
-// or else just return the existing value.
-//
-// It returns value with given `key`.
-func (m *StrIntMap) doSetWithLockCheck(key string, value int) int {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = make(map[string]int)
-	}
-	if v, ok := m.data[key]; ok {
-		m.mu.Unlock()
-		return v
-	}
-	m.data[key] = value
-	m.mu.Unlock()
-	return value
+	m.lazyInit()
+	return m.KVMap.Pops(size)
 }
 
 // GetOrSet returns the value by key,
 // or sets value with given `value` if it does not exist and then returns this value.
 func (m *StrIntMap) GetOrSet(key string, value int) int {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, value)
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSet(key, value)
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist
 // and then returns this value.
 func (m *StrIntMap) GetOrSetFunc(key string, f func() int) int {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, f())
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFunc(key, f)
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -233,41 +146,22 @@ func (m *StrIntMap) GetOrSetFunc(key string, f func() int) int {
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
 func (m *StrIntMap) GetOrSetFuncLock(key string, f func() int) int {
-	if v, ok := m.Search(key); !ok {
-		m.mu.Lock()
-		defer m.mu.Unlock()
-		if m.data == nil {
-			m.data = make(map[string]int)
-		}
-		if v, ok = m.data[key]; ok {
-			return v
-		}
-		v = f()
-		m.data[key] = v
-		return v
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFuncLock(key, f)
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *StrIntMap) SetIfNotExist(key string, value int) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, value)
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExist(key, value)
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *StrIntMap) SetIfNotExistFunc(key string, f func() int) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, f())
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFunc(key, f)
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -276,126 +170,76 @@ func (m *StrIntMap) SetIfNotExistFunc(key string, f func() int) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the hash map.
 func (m *StrIntMap) SetIfNotExistFuncLock(key string, f func() int) bool {
-	if !m.Contains(key) {
-		m.mu.Lock()
-		defer m.mu.Unlock()
-		if m.data == nil {
-			m.data = make(map[string]int)
-		}
-		if _, ok := m.data[key]; !ok {
-			m.data[key] = f()
-		}
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFuncLock(key, f)
 }
 
 // Removes batch deletes values of the map by keys.
 func (m *StrIntMap) Removes(keys []string) {
-	m.mu.Lock()
-	if m.data != nil {
-		for _, key := range keys {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Removes(keys)
 }
 
 // Remove deletes value from map by given `key`, and return this deleted value.
 func (m *StrIntMap) Remove(key string) (value int) {
-	m.mu.Lock()
-	if m.data != nil {
-		var ok bool
-		if value, ok = m.data[key]; ok {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Remove(key)
 }
 
 // Keys returns all keys of the map as a slice.
 func (m *StrIntMap) Keys() []string {
-	m.mu.RLock()
-	var (
-		keys  = make([]string, len(m.data))
-		index = 0
-	)
-	for key := range m.data {
-		keys[index] = key
-		index++
-	}
-	m.mu.RUnlock()
-	return keys
+	m.lazyInit()
+	return m.KVMap.Keys()
 }
 
 // Values returns all values of the map as a slice.
 func (m *StrIntMap) Values() []int {
-	m.mu.RLock()
-	var (
-		values = make([]int, len(m.data))
-		index  = 0
-	)
-	for _, value := range m.data {
-		values[index] = value
-		index++
-	}
-	m.mu.RUnlock()
-	return values
+	m.lazyInit()
+	return m.KVMap.Values()
 }
 
 // Contains checks whether a key exists.
 // It returns true if the `key` exists, or else false.
 func (m *StrIntMap) Contains(key string) bool {
-	var ok bool
-	m.mu.RLock()
-	if m.data != nil {
-		_, ok = m.data[key]
-	}
-	m.mu.RUnlock()
-	return ok
+	m.lazyInit()
+	return m.KVMap.Contains(key)
 }
 
 // Size returns the size of the map.
 func (m *StrIntMap) Size() int {
-	m.mu.RLock()
-	length := len(m.data)
-	m.mu.RUnlock()
-	return length
+	m.lazyInit()
+	return m.KVMap.Size()
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *StrIntMap) IsEmpty() bool {
-	return m.Size() == 0
+	m.lazyInit()
+	return m.KVMap.IsEmpty()
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *StrIntMap) Clear() {
-	m.mu.Lock()
-	m.data = make(map[string]int)
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Clear()
 }
 
 // Replace the data of the map with given `data`.
 func (m *StrIntMap) Replace(data map[string]int) {
-	m.mu.Lock()
-	m.data = data
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Replace(data)
 }
 
 // LockFunc locks writing with given callback function `f` within RWMutex.Lock.
 func (m *StrIntMap) LockFunc(f func(m map[string]int)) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.LockFunc(f)
 }
 
 // RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
 func (m *StrIntMap) RLockFunc(f func(m map[string]int)) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.RLockFunc(f)
 }
 
 // Flip exchanges key-value of the map to value-key.
@@ -412,19 +256,8 @@ func (m *StrIntMap) Flip() {
 // Merge merges two hash maps.
 // The `other` map will be merged into the map `m`.
 func (m *StrIntMap) Merge(other *StrIntMap) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = other.MapCopy()
-		return
-	}
-	if other != m {
-		other.mu.RLock()
-		defer other.mu.RUnlock()
-	}
-	for k, v := range other.data {
-		m.data[k] = v
-	}
+	m.lazyInit()
+	m.KVMap.Merge(other.KVMap)
 }
 
 // String returns the map as a string.
@@ -432,81 +265,40 @@ func (m *StrIntMap) String() string {
 	if m == nil {
 		return ""
 	}
-	b, _ := m.MarshalJSON()
-	return string(b)
+	m.lazyInit()
+	return m.KVMap.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m StrIntMap) MarshalJSON() ([]byte, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return json.Marshal(m.data)
+	m.lazyInit()
+	return m.KVMap.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (m *StrIntMap) UnmarshalJSON(b []byte) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[string]int)
-	}
-	if err := json.UnmarshalUseNumber(b, &m.data); err != nil {
-		return err
-	}
-	return nil
+	m.lazyInit()
+	return m.KVMap.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
 func (m *StrIntMap) UnmarshalValue(value any) (err error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[string]int)
-	}
-	switch value.(type) {
-	case string, []byte:
-		return json.UnmarshalUseNumber(gconv.Bytes(value), &m.data)
-	default:
-		for k, v := range gconv.Map(value) {
-			m.data[k] = gconv.Int(v)
-		}
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.UnmarshalValue(value)
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *StrIntMap) DeepCopy() any {
-	if m == nil {
-		return nil
+	m.lazyInit()
+	return &StrIntMap{
+		KVMap: m.KVMap.DeepCopy().(*KVMap[string, int]),
 	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[string]int, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return NewStrIntMapFrom(data, m.mu.IsSafe())
 }
 
 // IsSubOf checks whether the current map is a sub-map of `other`.
 func (m *StrIntMap) IsSubOf(other *StrIntMap) bool {
-	if m == other {
-		return true
-	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	for key, value := range m.data {
-		otherValue, ok := other.data[key]
-		if !ok {
-			return false
-		}
-		if otherValue != value {
-			return false
-		}
-	}
-	return true
+	m.lazyInit()
+	return m.KVMap.IsSubOf(other.KVMap)
 }
 
 // Diff compares current map `m` with map `other` and returns their different keys.
@@ -514,22 +306,6 @@ func (m *StrIntMap) IsSubOf(other *StrIntMap) bool {
 // The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
 // The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
 func (m *StrIntMap) Diff(other *StrIntMap) (addedKeys, removedKeys, updatedKeys []string) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-
-	for key := range m.data {
-		if _, ok := other.data[key]; !ok {
-			removedKeys = append(removedKeys, key)
-		} else if m.data[key] != other.data[key] {
-			updatedKeys = append(updatedKeys, key)
-		}
-	}
-	for key := range other.data {
-		if _, ok := m.data[key]; !ok {
-			addedKeys = append(addedKeys, key)
-		}
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Diff(other.KVMap)
 }
diff --git a/container/gmap/gmap_hash_str_str_map.go b/container/gmap/gmap_hash_str_str_map.go
index b346bdfb2..6722f3037 100644
--- a/container/gmap/gmap_hash_str_str_map.go
+++ b/container/gmap/gmap_hash_str_str_map.go
@@ -1,23 +1,18 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 //
 
 package gmap
 
-import (
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/util/gconv"
-)
+import "sync"
 
 // StrStrMap implements map[string]string with RWMutex that has switch.
 type StrStrMap struct {
-	mu   rwmutex.RWMutex
-	data map[string]string
+	*KVMap[string, string]
+	once sync.Once
 }
 
 // NewStrStrMap returns an empty StrStrMap object.
@@ -25,8 +20,7 @@ type StrStrMap struct {
 // which is false in default.
 func NewStrStrMap(safe ...bool) *StrStrMap {
 	return &StrStrMap{
-		data: make(map[string]string),
-		mu:   rwmutex.Create(safe...),
+		KVMap: NewKVMap[string, string](safe...),
 	}
 }
 
@@ -35,194 +29,110 @@ func NewStrStrMap(safe ...bool) *StrStrMap {
 // there might be some concurrent-safe issues when changing the map outside.
 func NewStrStrMapFrom(data map[string]string, safe ...bool) *StrStrMap {
 	return &StrStrMap{
-		mu:   rwmutex.Create(safe...),
-		data: data,
+		KVMap: NewKVMapFrom(data, safe...),
 	}
 }
 
+// lazyInit lazily initializes the map.
+func (m *StrStrMap) lazyInit() {
+	m.once.Do(func() {
+		if m.KVMap == nil {
+			m.KVMap = NewKVMap[string, string](false)
+		}
+	})
+}
+
 // Iterator iterates the hash map readonly with custom callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (m *StrStrMap) Iterator(f func(k string, v string) bool) {
-	for k, v := range m.Map() {
-		if !f(k, v) {
-			break
-		}
-	}
+	m.lazyInit()
+	m.KVMap.Iterator(f)
 }
 
 // Clone returns a new hash map with copy of current map data.
-func (m *StrStrMap) Clone() *StrStrMap {
-	return NewStrStrMapFrom(m.MapCopy(), m.mu.IsSafe())
+func (m *StrStrMap) Clone(safe ...bool) *StrStrMap {
+	m.lazyInit()
+	return &StrStrMap{KVMap: m.KVMap.Clone(safe...)}
 }
 
 // Map returns the underlying data map.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (m *StrStrMap) Map() map[string]string {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if !m.mu.IsSafe() {
-		return m.data
-	}
-	data := make(map[string]string, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.Map()
 }
 
 // MapStrAny returns a copy of the underlying data of the map as map[string]any.
 func (m *StrStrMap) MapStrAny() map[string]any {
-	m.mu.RLock()
-	data := make(map[string]any, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	m.mu.RUnlock()
-	return data
+	m.lazyInit()
+	return m.KVMap.MapStrAny()
 }
 
 // MapCopy returns a copy of the underlying data of the hash map.
 func (m *StrStrMap) MapCopy() map[string]string {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[string]string, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return data
+	m.lazyInit()
+	return m.KVMap.MapCopy()
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *StrStrMap) FilterEmpty() {
-	m.mu.Lock()
-	for k, v := range m.data {
-		if empty.IsEmpty(v) {
-			delete(m.data, k)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.FilterEmpty()
 }
 
 // Set sets key-value to the hash map.
 func (m *StrStrMap) Set(key string, val string) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = make(map[string]string)
-	}
-	m.data[key] = val
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Set(key, val)
 }
 
 // Sets batch sets key-values to the hash map.
 func (m *StrStrMap) Sets(data map[string]string) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = data
-	} else {
-		for k, v := range data {
-			m.data[k] = v
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Sets(data)
 }
 
 // Search searches the map with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (m *StrStrMap) Search(key string) (value string, found bool) {
-	m.mu.RLock()
-	if m.data != nil {
-		value, found = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Search(key)
 }
 
 // Get returns the value by given `key`.
 func (m *StrStrMap) Get(key string) (value string) {
-	m.mu.RLock()
-	if m.data != nil {
-		value = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Get(key)
 }
 
 // Pop retrieves and deletes an item from the map.
 func (m *StrStrMap) Pop() (key, value string) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	for key, value = range m.data {
-		delete(m.data, key)
-		return
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Pop()
 }
 
 // Pops retrieves and deletes `size` items from the map.
 // It returns all items if size == -1.
 func (m *StrStrMap) Pops(size int) map[string]string {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if size > len(m.data) || size == -1 {
-		size = len(m.data)
-	}
-	if size == 0 {
-		return nil
-	}
-	var (
-		index  = 0
-		newMap = make(map[string]string, size)
-	)
-	for k, v := range m.data {
-		delete(m.data, k)
-		newMap[k] = v
-		index++
-		if index == size {
-			break
-		}
-	}
-	return newMap
-}
-
-// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
-// if not exists, set value to the map with given `key`,
-// or else just return the existing value.
-//
-// It returns value with given `key`.
-func (m *StrStrMap) doSetWithLockCheck(key string, value string) string {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[string]string)
-	}
-	if v, ok := m.data[key]; ok {
-		return v
-	}
-	m.data[key] = value
-	return value
+	m.lazyInit()
+	return m.KVMap.Pops(size)
 }
 
 // GetOrSet returns the value by key,
 // or sets value with given `value` if it does not exist and then returns this value.
 func (m *StrStrMap) GetOrSet(key string, value string) string {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, value)
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSet(key, value)
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist
 // and then returns this value.
 func (m *StrStrMap) GetOrSetFunc(key string, f func() string) string {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, f())
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFunc(key, f)
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -232,41 +142,22 @@ func (m *StrStrMap) GetOrSetFunc(key string, f func() string) string {
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
 func (m *StrStrMap) GetOrSetFuncLock(key string, f func() string) string {
-	if v, ok := m.Search(key); !ok {
-		m.mu.Lock()
-		defer m.mu.Unlock()
-		if m.data == nil {
-			m.data = make(map[string]string)
-		}
-		if v, ok = m.data[key]; ok {
-			return v
-		}
-		v = f()
-		m.data[key] = v
-		return v
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.KVMap.GetOrSetFuncLock(key, f)
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *StrStrMap) SetIfNotExist(key string, value string) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, value)
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExist(key, value)
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *StrStrMap) SetIfNotExistFunc(key string, f func() string) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, f())
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFunc(key, f)
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -275,126 +166,76 @@ func (m *StrStrMap) SetIfNotExistFunc(key string, f func() string) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the hash map.
 func (m *StrStrMap) SetIfNotExistFuncLock(key string, f func() string) bool {
-	if !m.Contains(key) {
-		m.mu.Lock()
-		defer m.mu.Unlock()
-		if m.data == nil {
-			m.data = make(map[string]string)
-		}
-		if _, ok := m.data[key]; !ok {
-			m.data[key] = f()
-		}
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.KVMap.SetIfNotExistFuncLock(key, f)
 }
 
 // Removes batch deletes values of the map by keys.
 func (m *StrStrMap) Removes(keys []string) {
-	m.mu.Lock()
-	if m.data != nil {
-		for _, key := range keys {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Removes(keys)
 }
 
 // Remove deletes value from map by given `key`, and return this deleted value.
 func (m *StrStrMap) Remove(key string) (value string) {
-	m.mu.Lock()
-	if m.data != nil {
-		var ok bool
-		if value, ok = m.data[key]; ok {
-			delete(m.data, key)
-		}
-	}
-	m.mu.Unlock()
-	return
+	m.lazyInit()
+	return m.KVMap.Remove(key)
 }
 
 // Keys returns all keys of the map as a slice.
 func (m *StrStrMap) Keys() []string {
-	m.mu.RLock()
-	var (
-		keys  = make([]string, len(m.data))
-		index = 0
-	)
-	for key := range m.data {
-		keys[index] = key
-		index++
-	}
-	m.mu.RUnlock()
-	return keys
+	m.lazyInit()
+	return m.KVMap.Keys()
 }
 
 // Values returns all values of the map as a slice.
 func (m *StrStrMap) Values() []string {
-	m.mu.RLock()
-	var (
-		values = make([]string, len(m.data))
-		index  = 0
-	)
-	for _, value := range m.data {
-		values[index] = value
-		index++
-	}
-	m.mu.RUnlock()
-	return values
+	m.lazyInit()
+	return m.KVMap.Values()
 }
 
 // Contains checks whether a key exists.
 // It returns true if the `key` exists, or else false.
 func (m *StrStrMap) Contains(key string) bool {
-	var ok bool
-	m.mu.RLock()
-	if m.data != nil {
-		_, ok = m.data[key]
-	}
-	m.mu.RUnlock()
-	return ok
+	m.lazyInit()
+	return m.KVMap.Contains(key)
 }
 
 // Size returns the size of the map.
 func (m *StrStrMap) Size() int {
-	m.mu.RLock()
-	length := len(m.data)
-	m.mu.RUnlock()
-	return length
+	m.lazyInit()
+	return m.KVMap.Size()
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *StrStrMap) IsEmpty() bool {
-	return m.Size() == 0
+	m.lazyInit()
+	return m.KVMap.IsEmpty()
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *StrStrMap) Clear() {
-	m.mu.Lock()
-	m.data = make(map[string]string)
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Clear()
 }
 
 // Replace the data of the map with given `data`.
 func (m *StrStrMap) Replace(data map[string]string) {
-	m.mu.Lock()
-	m.data = data
-	m.mu.Unlock()
+	m.lazyInit()
+	m.KVMap.Replace(data)
 }
 
 // LockFunc locks writing with given callback function `f` within RWMutex.Lock.
 func (m *StrStrMap) LockFunc(f func(m map[string]string)) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.LockFunc(f)
 }
 
 // RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
 func (m *StrStrMap) RLockFunc(f func(m map[string]string)) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	f(m.data)
+	m.lazyInit()
+	m.KVMap.RLockFunc(f)
 }
 
 // Flip exchanges key-value of the map to value-key.
@@ -411,19 +252,8 @@ func (m *StrStrMap) Flip() {
 // Merge merges two hash maps.
 // The `other` map will be merged into the map `m`.
 func (m *StrStrMap) Merge(other *StrStrMap) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = other.MapCopy()
-		return
-	}
-	if other != m {
-		other.mu.RLock()
-		defer other.mu.RUnlock()
-	}
-	for k, v := range other.data {
-		m.data[k] = v
-	}
+	m.lazyInit()
+	m.KVMap.Merge(other.KVMap)
 }
 
 // String returns the map as a string.
@@ -431,71 +261,40 @@ func (m *StrStrMap) String() string {
 	if m == nil {
 		return ""
 	}
-	b, _ := m.MarshalJSON()
-	return string(b)
+	m.lazyInit()
+	return m.KVMap.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m StrStrMap) MarshalJSON() ([]byte, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return json.Marshal(m.data)
+	m.lazyInit()
+	return m.KVMap.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (m *StrStrMap) UnmarshalJSON(b []byte) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[string]string)
-	}
-	if err := json.UnmarshalUseNumber(b, &m.data); err != nil {
-		return err
-	}
-	return nil
+	m.lazyInit()
+	return m.KVMap.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
 func (m *StrStrMap) UnmarshalValue(value any) (err error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.data = gconv.MapStrStr(value)
-	return
+	m.lazyInit()
+	return m.KVMap.UnmarshalValue(value)
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *StrStrMap) DeepCopy() any {
-	if m == nil {
-		return nil
+	m.lazyInit()
+	return &StrStrMap{
+		KVMap: m.KVMap.DeepCopy().(*KVMap[string, string]),
 	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[string]string, len(m.data))
-	for k, v := range m.data {
-		data[k] = v
-	}
-	return NewStrStrMapFrom(data, m.mu.IsSafe())
 }
 
 // IsSubOf checks whether the current map is a sub-map of `other`.
 func (m *StrStrMap) IsSubOf(other *StrStrMap) bool {
-	if m == other {
-		return true
-	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	for key, value := range m.data {
-		otherValue, ok := other.data[key]
-		if !ok {
-			return false
-		}
-		if otherValue != value {
-			return false
-		}
-	}
-	return true
+	m.lazyInit()
+	return m.KVMap.IsSubOf(other.KVMap)
 }
 
 // Diff compares current map `m` with map `other` and returns their different keys.
@@ -503,22 +302,6 @@ func (m *StrStrMap) IsSubOf(other *StrStrMap) bool {
 // The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
 // The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
 func (m *StrStrMap) Diff(other *StrStrMap) (addedKeys, removedKeys, updatedKeys []string) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-
-	for key := range m.data {
-		if _, ok := other.data[key]; !ok {
-			removedKeys = append(removedKeys, key)
-		} else if m.data[key] != other.data[key] {
-			updatedKeys = append(updatedKeys, key)
-		}
-	}
-	for key := range other.data {
-		if _, ok := m.data[key]; !ok {
-			addedKeys = append(addedKeys, key)
-		}
-	}
-	return
+	m.lazyInit()
+	return m.KVMap.Diff(other.KVMap)
 }
diff --git a/container/gmap/gmap_list_k_v_map.go b/container/gmap/gmap_list_k_v_map.go
new file mode 100644
index 000000000..61d99f0b9
--- /dev/null
+++ b/container/gmap/gmap_list_k_v_map.go
@@ -0,0 +1,706 @@
+// 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 gmap
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/gogf/gf/v2/container/glist"
+	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/deepcopy"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+// ListKVMap is a map that preserves insertion-order.
+//
+// It is backed by a hash table to store values and doubly-linked list to store ordering.
+//
+// Thread-safety is optional and controlled by the `safe` parameter during initialization.
+//
+// Reference: http://en.wikipedia.org/wiki/Associative_array
+type ListKVMap[K comparable, V any] struct {
+	mu         rwmutex.RWMutex
+	data       map[K]*glist.TElement[*gListKVMapNode[K, V]]
+	list       *glist.TList[*gListKVMapNode[K, V]]
+	nilChecker NilChecker[V]
+}
+
+type gListKVMapNode[K comparable, V any] struct {
+	key   K
+	value V
+}
+
+// NewListKVMap returns an empty link map.
+// ListKVMap is backed by a hash table to store values and doubly-linked list to store ordering.
+// The parameter `safe` is used to specify whether using map in concurrent-safety,
+// which is false in default.
+func NewListKVMap[K comparable, V any](safe ...bool) *ListKVMap[K, V] {
+	return &ListKVMap[K, V]{
+		mu:   rwmutex.Create(safe...),
+		data: make(map[K]*glist.TElement[*gListKVMapNode[K, V]]),
+		list: glist.NewT[*gListKVMapNode[K, V]](),
+	}
+}
+
+// NewListKVMapWithChecker creates and returns a new ListKVMap instance with a custom nil checker.
+// The parameter `checker` is a function used to determine if a value is nil.
+// The parameter `safe` is used to specify whether using map in concurrent-safety,
+// which is false by default.
+func NewListKVMapWithChecker[K comparable, V any](checker NilChecker[V], safe ...bool) *ListKVMap[K, V] {
+	m := NewListKVMap[K, V](safe...)
+	m.SetNilChecker(checker)
+	return m
+}
+
+// NewListKVMapFrom returns a link map from given map `data`.
+// Note that, the param `data` map will be copied to the underlying data structure,
+// so changes to the original map will not affect the link map.
+func NewListKVMapFrom[K comparable, V any](data map[K]V, safe ...bool) *ListKVMap[K, V] {
+	m := NewListKVMap[K, V](safe...)
+	m.Sets(data)
+	return m
+}
+
+// NewListKVMapWithCheckerFrom returns a link map from given map `data` with a custom nil checker.
+// Note that, the param `data` map will be copied to the underlying data structure,
+// so changes to the original map will not affect the link map.
+// The parameter `checker` is a function used to determine if a value is nil.
+// The parameter `safe` is used to specify whether using map in concurrent-safety,
+// which is false by default.
+func NewListKVMapWithCheckerFrom[K comparable, V any](data map[K]V, nilChecker NilChecker[V], safe ...bool) *ListKVMap[K, V] {
+	m := NewListKVMapWithChecker[K, V](nilChecker, safe...)
+	m.Sets(data)
+	return m
+}
+
+// SetNilChecker registers a custom nil checker function for the map values.
+// This function is used to determine if a value should be considered as nil.
+// The nil checker function takes a value of type V and returns a boolean indicating
+// whether the value should be treated as nil.
+func (m *ListKVMap[K, V]) SetNilChecker(nilChecker NilChecker[V]) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.nilChecker = nilChecker
+}
+
+// isNil checks whether the given value is nil.
+// It first checks if a custom nil checker function is registered and uses it if available,
+// otherwise it falls back to the default empty.IsNil function.
+func (m *ListKVMap[K, V]) isNil(v V) bool {
+	if m.nilChecker != nil {
+		return m.nilChecker(v)
+	}
+	return empty.IsNil(v)
+}
+
+// Iterator is alias of IteratorAsc.
+func (m *ListKVMap[K, V]) Iterator(f func(key K, value V) bool) {
+	m.IteratorAsc(f)
+}
+
+// IteratorAsc iterates the map readonly in ascending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (m *ListKVMap[K, V]) IteratorAsc(f func(key K, value V) bool) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	if m.list != nil {
+		m.list.IteratorAsc(func(e *glist.TElement[*gListKVMapNode[K, V]]) bool {
+			return f(e.Value.key, e.Value.value)
+		})
+	}
+}
+
+// IteratorDesc iterates the map readonly in descending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (m *ListKVMap[K, V]) IteratorDesc(f func(key K, value V) bool) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	if m.list != nil {
+		m.list.IteratorDesc(func(e *glist.TElement[*gListKVMapNode[K, V]]) bool {
+			return f(e.Value.key, e.Value.value)
+		})
+	}
+}
+
+// Clone returns a new link map with copy of current map data.
+func (m *ListKVMap[K, V]) Clone(safe ...bool) *ListKVMap[K, V] {
+	return NewListKVMapFrom(m.Map(), safe...)
+}
+
+// Clear deletes all data of the map, it will remake a new underlying data map.
+func (m *ListKVMap[K, V]) Clear() {
+	m.mu.Lock()
+	m.data = make(map[K]*glist.TElement[*gListKVMapNode[K, V]])
+	m.list = glist.NewT[*gListKVMapNode[K, V]]()
+	m.mu.Unlock()
+}
+
+// Replace the data of the map with given `data`.
+func (m *ListKVMap[K, V]) Replace(data map[K]V) {
+	m.mu.Lock()
+	m.data = make(map[K]*glist.TElement[*gListKVMapNode[K, V]])
+	m.list = glist.NewT[*gListKVMapNode[K, V]]()
+	for key, value := range data {
+		m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
+	}
+	m.mu.Unlock()
+}
+
+// Map returns a copy of the underlying data of the map.
+func (m *ListKVMap[K, V]) Map() map[K]V {
+	m.mu.RLock()
+	var data map[K]V
+	if m.list != nil {
+		data = make(map[K]V, len(m.data))
+		m.list.IteratorAsc(func(e *glist.TElement[*gListKVMapNode[K, V]]) bool {
+			data[e.Value.key] = e.Value.value
+			return true
+		})
+	}
+	m.mu.RUnlock()
+	return data
+}
+
+// MapStrAny returns a copy of the underlying data of the map as map[string]any.
+func (m *ListKVMap[K, V]) MapStrAny() map[string]any {
+	m.mu.RLock()
+	var data map[string]any
+	if m.list != nil {
+		data = make(map[string]any, len(m.data))
+		m.list.IteratorAsc(func(e *glist.TElement[*gListKVMapNode[K, V]]) bool {
+			data[gconv.String(e.Value.key)] = e.Value.value
+			return true
+		})
+	}
+	m.mu.RUnlock()
+	return data
+}
+
+// FilterEmpty deletes all key-value pair of which the value is empty.
+func (m *ListKVMap[K, V]) FilterEmpty() {
+	m.mu.Lock()
+	if m.list != nil {
+		var keys = make([]K, 0, m.list.Size())
+		m.list.IteratorAsc(func(e *glist.TElement[*gListKVMapNode[K, V]]) bool {
+			if empty.IsEmpty(e.Value.value) {
+				keys = append(keys, e.Value.key)
+			}
+			return true
+		})
+
+		if len(keys) > 0 {
+			for _, key := range keys {
+				if e, ok := m.data[key]; ok {
+					delete(m.data, key)
+					m.list.Remove(e)
+				}
+			}
+		}
+	}
+	m.mu.Unlock()
+}
+
+// Set sets key-value to the map.
+func (m *ListKVMap[K, V]) Set(key K, value V) {
+	m.mu.Lock()
+	if m.data == nil {
+		m.data = make(map[K]*glist.TElement[*gListKVMapNode[K, V]])
+		m.list = glist.NewT[*gListKVMapNode[K, V]]()
+	}
+	if e, ok := m.data[key]; !ok {
+		m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
+	} else {
+		e.Value = &gListKVMapNode[K, V]{key, value}
+	}
+	m.mu.Unlock()
+}
+
+// Sets batch sets key-values to the map.
+func (m *ListKVMap[K, V]) Sets(data map[K]V) {
+	m.mu.Lock()
+	if m.data == nil {
+		m.data = make(map[K]*glist.TElement[*gListKVMapNode[K, V]])
+		m.list = glist.NewT[*gListKVMapNode[K, V]]()
+	}
+	for key, value := range data {
+		if e, ok := m.data[key]; !ok {
+			m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
+		} else {
+			e.Value = &gListKVMapNode[K, V]{key, value}
+		}
+	}
+	m.mu.Unlock()
+}
+
+// Search searches the map with given `key`.
+// Second return parameter `found` is true if key was found, otherwise false.
+func (m *ListKVMap[K, V]) Search(key K) (value V, found bool) {
+	m.mu.RLock()
+	if m.data != nil {
+		if e, ok := m.data[key]; ok {
+			value = e.Value.value
+			found = ok
+		}
+	}
+	m.mu.RUnlock()
+	return
+}
+
+// Get returns the value by given `key`.
+func (m *ListKVMap[K, V]) Get(key K) (value V) {
+	m.mu.RLock()
+	if m.data != nil {
+		if e, ok := m.data[key]; ok {
+			value = e.Value.value
+		}
+	}
+	m.mu.RUnlock()
+	return
+}
+
+// Pop retrieves and deletes an item from the map.
+func (m *ListKVMap[K, V]) Pop() (key K, value V) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for k, e := range m.data {
+		value = e.Value.value
+		delete(m.data, k)
+		m.list.Remove(e)
+		return k, value
+	}
+	return
+}
+
+// Pops retrieves and deletes `size` items from the map.
+// It returns all items if size == -1.
+func (m *ListKVMap[K, V]) Pops(size int) map[K]V {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if size > len(m.data) || size == -1 {
+		size = len(m.data)
+	}
+	if size == 0 {
+		return nil
+	}
+	index := 0
+	newMap := make(map[K]V, size)
+	for k, e := range m.data {
+		value := e.Value.value
+		delete(m.data, k)
+		m.list.Remove(e)
+		newMap[k] = value
+		index++
+		if index == size {
+			break
+		}
+	}
+	return newMap
+}
+
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given `key`,
+// or else just return the existing value.
+//
+// It returns value with given `key`.
+func (m *ListKVMap[K, V]) doSetWithLockCheck(key K, value V) V {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	return m.doSetWithLockCheckWithoutLock(key, value)
+}
+
+func (m *ListKVMap[K, V]) doSetWithLockCheckWithoutLock(key K, value V) V {
+	if m.data == nil {
+		m.data = make(map[K]*glist.TElement[*gListKVMapNode[K, V]])
+		m.list = glist.NewT[*gListKVMapNode[K, V]]()
+	}
+	if e, ok := m.data[key]; ok {
+		return e.Value.value
+	}
+	if !m.isNil(value) {
+		m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
+	}
+	return value
+}
+
+// GetOrSet returns the value by key,
+// or sets value with given `value` if it does not exist and then returns this value.
+func (m *ListKVMap[K, V]) GetOrSet(key K, value V) V {
+	if v, ok := m.Search(key); !ok {
+		return m.doSetWithLockCheck(key, value)
+	} else {
+		return v
+	}
+}
+
+// GetOrSetFunc returns the value by key,
+// or sets value with returned value of callback function `f` if it does not exist
+// and then returns this value.
+func (m *ListKVMap[K, V]) GetOrSetFunc(key K, f func() V) V {
+	if v, ok := m.Search(key); !ok {
+		return m.doSetWithLockCheck(key, f())
+	} else {
+		return v
+	}
+}
+
+// GetOrSetFuncLock returns the value by key,
+// or sets value with returned value of callback function `f` if it does not exist
+// and then returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
+// with mutex.Lock of the map.
+func (m *ListKVMap[K, V]) GetOrSetFuncLock(key K, f func() V) V {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.data == nil {
+		m.data = make(map[K]*glist.TElement[*gListKVMapNode[K, V]])
+		m.list = glist.NewT[*gListKVMapNode[K, V]]()
+	}
+	if e, ok := m.data[key]; ok {
+		return e.Value.value
+	}
+	value := f()
+	if !m.isNil(value) {
+		m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
+	}
+	return value
+}
+
+// GetVar returns a Var with the value by given `key`.
+// The returned Var is un-concurrent safe.
+func (m *ListKVMap[K, V]) GetVar(key K) *gvar.Var {
+	return gvar.New(m.Get(key))
+}
+
+// GetVarOrSet returns a Var with result from GetVarOrSet.
+// The returned Var is un-concurrent safe.
+func (m *ListKVMap[K, V]) GetVarOrSet(key K, value V) *gvar.Var {
+	return gvar.New(m.GetOrSet(key, value))
+}
+
+// GetVarOrSetFunc returns a Var with result from GetOrSetFunc.
+// The returned Var is un-concurrent safe.
+func (m *ListKVMap[K, V]) GetVarOrSetFunc(key K, f func() V) *gvar.Var {
+	return gvar.New(m.GetOrSetFunc(key, f))
+}
+
+// GetVarOrSetFuncLock returns a Var with result from GetOrSetFuncLock.
+// The returned Var is un-concurrent safe.
+func (m *ListKVMap[K, V]) GetVarOrSetFuncLock(key K, f func() V) *gvar.Var {
+	return gvar.New(m.GetOrSetFuncLock(key, f))
+}
+
+// SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
+// It returns false if `key` exists, and `value` would be ignored.
+//
+// Note that it does not add the value to the map if `value` is nil.
+func (m *ListKVMap[K, V]) SetIfNotExist(key K, value V) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.data == nil {
+		m.data = make(map[K]*glist.TElement[*gListKVMapNode[K, V]])
+		m.list = glist.NewT[*gListKVMapNode[K, V]]()
+	}
+	if _, ok := m.data[key]; ok {
+		return false
+	}
+	if !m.isNil(value) {
+		m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
+	}
+	return true
+}
+
+// SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
+// It returns false if `key` exists, and `value` would be ignored.
+//
+// Note that, it does not add the value to the map if the returned value of `f` is nil.
+func (m *ListKVMap[K, V]) SetIfNotExistFunc(key K, f func() V) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.data == nil {
+		m.data = make(map[K]*glist.TElement[*gListKVMapNode[K, V]])
+		m.list = glist.NewT[*gListKVMapNode[K, V]]()
+	}
+	if _, ok := m.data[key]; ok {
+		return false
+	}
+	value := f()
+	if !m.isNil(value) {
+		m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
+	}
+	return true
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
+// It returns false if `key` exists, and `value` would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function `f` with mutex.Lock of the map.
+//
+// Note that, it does not add the value to the map if the returned value of `f` is nil.
+func (m *ListKVMap[K, V]) SetIfNotExistFuncLock(key K, f func() V) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.data == nil {
+		m.data = make(map[K]*glist.TElement[*gListKVMapNode[K, V]])
+		m.list = glist.NewT[*gListKVMapNode[K, V]]()
+	}
+	if _, ok := m.data[key]; ok {
+		return false
+	}
+	value := f()
+	if !m.isNil(value) {
+		m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
+	}
+	return true
+}
+
+// Remove deletes value from map by given `key`, and return this deleted value.
+func (m *ListKVMap[K, V]) Remove(key K) (value V) {
+	m.mu.Lock()
+	if m.data != nil {
+		if e, ok := m.data[key]; ok {
+			value = e.Value.value
+			delete(m.data, key)
+			m.list.Remove(e)
+		}
+	}
+	m.mu.Unlock()
+	return
+}
+
+// Removes batch deletes values of the map by keys.
+func (m *ListKVMap[K, V]) Removes(keys []K) {
+	m.mu.Lock()
+	if m.data != nil {
+		for _, key := range keys {
+			if e, ok := m.data[key]; ok {
+				delete(m.data, key)
+				m.list.Remove(e)
+			}
+		}
+	}
+	m.mu.Unlock()
+}
+
+// Keys returns all keys of the map as a slice in ascending order.
+func (m *ListKVMap[K, V]) Keys() []K {
+	m.mu.RLock()
+	var (
+		keys  = make([]K, m.list.Len())
+		index = 0
+	)
+	if m.list != nil {
+		m.list.IteratorAsc(func(e *glist.TElement[*gListKVMapNode[K, V]]) bool {
+			keys[index] = e.Value.key
+			index++
+			return true
+		})
+	}
+	m.mu.RUnlock()
+	return keys
+}
+
+// Values returns all values of the map as a slice.
+func (m *ListKVMap[K, V]) Values() []V {
+	m.mu.RLock()
+	var (
+		values = make([]V, m.list.Len())
+		index  = 0
+	)
+	if m.list != nil {
+		m.list.IteratorAsc(func(e *glist.TElement[*gListKVMapNode[K, V]]) bool {
+			values[index] = e.Value.value
+			index++
+			return true
+		})
+	}
+	m.mu.RUnlock()
+	return values
+}
+
+// Contains checks whether a key exists.
+// It returns true if the `key` exists, or else false.
+func (m *ListKVMap[K, V]) Contains(key K) (ok bool) {
+	m.mu.RLock()
+	if m.data != nil {
+		_, ok = m.data[key]
+	}
+	m.mu.RUnlock()
+	return
+}
+
+// Size returns the size of the map.
+func (m *ListKVMap[K, V]) Size() (size int) {
+	m.mu.RLock()
+	size = len(m.data)
+	m.mu.RUnlock()
+	return
+}
+
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
+func (m *ListKVMap[K, V]) IsEmpty() bool {
+	return m.Size() == 0
+}
+
+// Flip exchanges key-value of the map to value-key.
+func (m *ListKVMap[K, V]) Flip() error {
+	data := m.Map()
+	m.Clear()
+	for key, value := range data {
+		var (
+			newKey   K
+			newValue V
+		)
+
+		if err := gconv.Scan(value, &newKey); err != nil {
+			return err
+		}
+
+		if err := gconv.Scan(key, &newValue); err != nil {
+			return err
+		}
+		m.Set(newKey, newValue)
+	}
+
+	return nil
+}
+
+// Merge merges two link maps.
+// The `other` map will be merged into the map `m`.
+func (m *ListKVMap[K, V]) Merge(other *ListKVMap[K, V]) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[K]*glist.TElement[*gListKVMapNode[K, V]])
+		m.list = glist.NewT[*gListKVMapNode[K, V]]()
+	}
+	if other != m {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	var node *gListKVMapNode[K, V]
+	other.list.IteratorAsc(func(e *glist.TElement[*gListKVMapNode[K, V]]) bool {
+		node = e.Value
+		if e, ok := m.data[node.key]; !ok {
+			m.data[node.key] = m.list.PushBack(&gListKVMapNode[K, V]{node.key, node.value})
+		} else {
+			e.Value = &gListKVMapNode[K, V]{node.key, node.value}
+		}
+		return true
+	})
+}
+
+// String returns the map as a string.
+func (m *ListKVMap[K, V]) String() string {
+	if m == nil {
+		return ""
+	}
+	b, _ := m.MarshalJSON()
+	return string(b)
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+// DO NOT change this receiver to pointer type, as the ListKVMap can be used as a var defined variable, like:
+// var m gmap.ListKVMap[string]string
+// Please refer to corresponding tests for more details.
+func (m ListKVMap[K, V]) MarshalJSON() (jsonBytes []byte, err error) {
+	if m.data == nil {
+		return []byte("{}"), nil
+	}
+	buffer := bytes.NewBuffer(nil)
+	buffer.WriteByte('{')
+	m.Iterator(func(key K, value V) bool {
+		valueBytes, valueJSONErr := json.Marshal(value)
+		if valueJSONErr != nil {
+			err = valueJSONErr
+			return false
+		}
+		if buffer.Len() > 1 {
+			buffer.WriteByte(',')
+		}
+		fmt.Fprintf(buffer, `"%v":%s`, key, valueBytes)
+		return true
+	})
+	buffer.WriteByte('}')
+	return buffer.Bytes(), nil
+}
+
+// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
+func (m *ListKVMap[K, V]) UnmarshalJSON(b []byte) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[K]*glist.TElement[*gListKVMapNode[K, V]])
+		m.list = glist.NewT[*gListKVMapNode[K, V]]()
+	}
+	var data map[string]V
+	if err := json.UnmarshalUseNumber(b, &data); err != nil {
+		return err
+	}
+	var kvData map[K]V
+	if err := gconv.Scan(data, &kvData); err != nil {
+		return err
+	}
+	for key, value := range kvData {
+		if e, ok := m.data[key]; !ok {
+			m.data[key] = m.list.PushBack(&gListKVMapNode[K, V]{key, value})
+		} else {
+			e.Value = &gListKVMapNode[K, V]{key, value}
+		}
+	}
+	return nil
+}
+
+// UnmarshalValue is an interface implement which sets any type of value for map.
+func (m *ListKVMap[K, V]) UnmarshalValue(value any) (err error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[K]*glist.TElement[*gListKVMapNode[K, V]])
+		m.list = glist.NewT[*gListKVMapNode[K, V]]()
+	}
+	var dataMap map[K]V
+	if err = gconv.Scan(value, &dataMap); err != nil {
+		return
+	}
+	for k, v := range dataMap {
+		if e, ok := m.data[k]; !ok {
+			m.data[k] = m.list.PushBack(&gListKVMapNode[K, V]{k, v})
+		} else {
+			e.Value = &gListKVMapNode[K, V]{k, v}
+		}
+	}
+	return
+}
+
+// DeepCopy implements interface for deep copy of current type.
+func (m *ListKVMap[K, V]) DeepCopy() any {
+	if m == nil {
+		return nil
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[K]V, len(m.data))
+	if m.list != nil {
+		m.list.IteratorAsc(func(e *glist.TElement[*gListKVMapNode[K, V]]) bool {
+			data[e.Value.key] = deepcopy.Copy(e.Value.value).(V)
+			return true
+		})
+	}
+	return NewListKVMapFrom(data, m.mu.IsSafe())
+}
diff --git a/container/gmap/gmap_list_map.go b/container/gmap/gmap_list_map.go
index 2b426176f..1529f1131 100644
--- a/container/gmap/gmap_list_map.go
+++ b/container/gmap/gmap_list_map.go
@@ -1,21 +1,15 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap
 
 import (
-	"bytes"
-	"fmt"
+	"sync"
 
-	"github.com/gogf/gf/v2/container/glist"
 	"github.com/gogf/gf/v2/container/gvar"
-	"github.com/gogf/gf/v2/internal/deepcopy"
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
@@ -27,15 +21,11 @@ import (
 //
 // Reference: http://en.wikipedia.org/wiki/Associative_array
 type ListMap struct {
-	mu   rwmutex.RWMutex
-	data map[any]*glist.Element
-	list *glist.List
+	*ListKVMap[any, any]
+	once sync.Once
 }
 
-type gListMapNode struct {
-	key   any
-	value any
-}
+type gListMapNode = gListKVMapNode[any, any]
 
 // NewListMap returns an empty link map.
 // ListMap is backed by a hash table to store values and doubly-linked list to store ordering.
@@ -43,9 +33,7 @@ type gListMapNode struct {
 // which is false in default.
 func NewListMap(safe ...bool) *ListMap {
 	return &ListMap{
-		mu:   rwmutex.Create(safe...),
-		data: make(map[any]*glist.Element),
-		list: glist.New(),
+		ListKVMap: NewListKVMap[any, any](safe...),
 	}
 }
 
@@ -58,6 +46,15 @@ func NewListMapFrom(data map[any]any, safe ...bool) *ListMap {
 	return m
 }
 
+// lazyInit lazily initializes the list map.
+func (m *ListMap) lazyInit() {
+	m.once.Do(func() {
+		if m.ListKVMap == nil {
+			m.ListKVMap = NewListKVMap[any, any](false)
+		}
+	})
+}
+
 // Iterator is alias of IteratorAsc.
 func (m *ListMap) Iterator(f func(key, value any) bool) {
 	m.IteratorAsc(f)
@@ -66,29 +63,15 @@ func (m *ListMap) Iterator(f func(key, value any) bool) {
 // IteratorAsc iterates the map readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (m *ListMap) IteratorAsc(f func(key any, value any) bool) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if m.list != nil {
-		var node *gListMapNode
-		m.list.IteratorAsc(func(e *glist.Element) bool {
-			node = e.Value.(*gListMapNode)
-			return f(node.key, node.value)
-		})
-	}
+	m.lazyInit()
+	m.ListKVMap.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the map readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (m *ListMap) IteratorDesc(f func(key any, value any) bool) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if m.list != nil {
-		var node *gListMapNode
-		m.list.IteratorDesc(func(e *glist.Element) bool {
-			node = e.Value.(*gListMapNode)
-			return f(node.key, node.value)
-		})
-	}
+	m.lazyInit()
+	m.ListKVMap.IteratorDesc(f)
 }
 
 // Clone returns a new link map with copy of current map data.
@@ -98,232 +81,85 @@ func (m *ListMap) Clone(safe ...bool) *ListMap {
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *ListMap) Clear() {
-	m.mu.Lock()
-	m.data = make(map[any]*glist.Element)
-	m.list = glist.New()
-	m.mu.Unlock()
+	m.lazyInit()
+	m.ListKVMap.Clear()
 }
 
 // Replace the data of the map with given `data`.
 func (m *ListMap) Replace(data map[any]any) {
-	m.mu.Lock()
-	m.data = make(map[any]*glist.Element)
-	m.list = glist.New()
-	for key, value := range data {
-		if e, ok := m.data[key]; !ok {
-			m.data[key] = m.list.PushBack(&gListMapNode{key, value})
-		} else {
-			e.Value = &gListMapNode{key, value}
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.ListKVMap.Replace(data)
 }
 
 // Map returns a copy of the underlying data of the map.
 func (m *ListMap) Map() map[any]any {
-	m.mu.RLock()
-	var node *gListMapNode
-	var data map[any]any
-	if m.list != nil {
-		data = make(map[any]any, len(m.data))
-		m.list.IteratorAsc(func(e *glist.Element) bool {
-			node = e.Value.(*gListMapNode)
-			data[node.key] = node.value
-			return true
-		})
-	}
-	m.mu.RUnlock()
-	return data
+	m.lazyInit()
+	return m.ListKVMap.Map()
 }
 
 // MapStrAny returns a copy of the underlying data of the map as map[string]any.
 func (m *ListMap) MapStrAny() map[string]any {
-	m.mu.RLock()
-	var node *gListMapNode
-	var data map[string]any
-	if m.list != nil {
-		data = make(map[string]any, len(m.data))
-		m.list.IteratorAsc(func(e *glist.Element) bool {
-			node = e.Value.(*gListMapNode)
-			data[gconv.String(node.key)] = node.value
-			return true
-		})
-	}
-	m.mu.RUnlock()
-	return data
+	m.lazyInit()
+	return m.ListKVMap.MapStrAny()
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
 func (m *ListMap) FilterEmpty() {
-	m.mu.Lock()
-	if m.list != nil {
-		var (
-			keys = make([]any, 0)
-			node *gListMapNode
-		)
-		m.list.IteratorAsc(func(e *glist.Element) bool {
-			node = e.Value.(*gListMapNode)
-			if empty.IsEmpty(node.value) {
-				keys = append(keys, node.key)
-			}
-			return true
-		})
-		if len(keys) > 0 {
-			for _, key := range keys {
-				if e, ok := m.data[key]; ok {
-					delete(m.data, key)
-					m.list.Remove(e)
-				}
-			}
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.ListKVMap.FilterEmpty()
 }
 
 // Set sets key-value to the map.
 func (m *ListMap) Set(key any, value any) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = make(map[any]*glist.Element)
-		m.list = glist.New()
-	}
-	if e, ok := m.data[key]; !ok {
-		m.data[key] = m.list.PushBack(&gListMapNode{key, value})
-	} else {
-		e.Value = &gListMapNode{key, value}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.ListKVMap.Set(key, value)
 }
 
 // Sets batch sets key-values to the map.
 func (m *ListMap) Sets(data map[any]any) {
-	m.mu.Lock()
-	if m.data == nil {
-		m.data = make(map[any]*glist.Element)
-		m.list = glist.New()
-	}
-	for key, value := range data {
-		if e, ok := m.data[key]; !ok {
-			m.data[key] = m.list.PushBack(&gListMapNode{key, value})
-		} else {
-			e.Value = &gListMapNode{key, value}
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.ListKVMap.Sets(data)
 }
 
 // Search searches the map with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (m *ListMap) Search(key any) (value any, found bool) {
-	m.mu.RLock()
-	if m.data != nil {
-		if e, ok := m.data[key]; ok {
-			value = e.Value.(*gListMapNode).value
-			found = ok
-		}
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.ListKVMap.Search(key)
 }
 
 // Get returns the value by given `key`.
 func (m *ListMap) Get(key any) (value any) {
-	m.mu.RLock()
-	if m.data != nil {
-		if e, ok := m.data[key]; ok {
-			value = e.Value.(*gListMapNode).value
-		}
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.ListKVMap.Get(key)
 }
 
 // Pop retrieves and deletes an item from the map.
 func (m *ListMap) Pop() (key, value any) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	for k, e := range m.data {
-		value = e.Value.(*gListMapNode).value
-		delete(m.data, k)
-		m.list.Remove(e)
-		return k, value
-	}
-	return
+	m.lazyInit()
+	return m.ListKVMap.Pop()
 }
 
 // Pops retrieves and deletes `size` items from the map.
 // It returns all items if size == -1.
 func (m *ListMap) Pops(size int) map[any]any {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if size > len(m.data) || size == -1 {
-		size = len(m.data)
-	}
-	if size == 0 {
-		return nil
-	}
-	index := 0
-	newMap := make(map[any]any, size)
-	for k, e := range m.data {
-		value := e.Value.(*gListMapNode).value
-		delete(m.data, k)
-		m.list.Remove(e)
-		newMap[k] = value
-		index++
-		if index == size {
-			break
-		}
-	}
-	return newMap
-}
-
-// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
-// if not exists, set value to the map with given `key`,
-// or else just return the existing value.
-//
-// When setting value, if `value` is type of `func() interface {}`,
-// it will be executed with mutex.Lock of the map,
-// and its return value will be set to the map with `key`.
-//
-// It returns value with given `key`.
-func (m *ListMap) doSetWithLockCheck(key any, value any) any {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[any]*glist.Element)
-		m.list = glist.New()
-	}
-	if e, ok := m.data[key]; ok {
-		return e.Value.(*gListMapNode).value
-	}
-	if f, ok := value.(func() any); ok {
-		value = f()
-	}
-	if value != nil {
-		m.data[key] = m.list.PushBack(&gListMapNode{key, value})
-	}
-	return value
+	m.lazyInit()
+	return m.ListKVMap.Pops(size)
 }
 
 // GetOrSet returns the value by key,
 // or sets value with given `value` if it does not exist and then returns this value.
 func (m *ListMap) GetOrSet(key any, value any) any {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, value)
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.ListKVMap.GetOrSet(key, value)
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist
 // and then returns this value.
 func (m *ListMap) GetOrSetFunc(key any, f func() any) any {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, f())
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.ListKVMap.GetOrSetFunc(key, f)
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -333,55 +169,50 @@ func (m *ListMap) GetOrSetFunc(key any, f func() any) any {
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the map.
 func (m *ListMap) GetOrSetFuncLock(key any, f func() any) any {
-	if v, ok := m.Search(key); !ok {
-		return m.doSetWithLockCheck(key, f)
-	} else {
-		return v
-	}
+	m.lazyInit()
+	return m.ListKVMap.GetOrSetFuncLock(key, f)
 }
 
 // GetVar returns a Var with the value by given `key`.
 // The returned Var is un-concurrent safe.
 func (m *ListMap) GetVar(key any) *gvar.Var {
-	return gvar.New(m.Get(key))
+	m.lazyInit()
+	return m.ListKVMap.GetVar(key)
 }
 
 // GetVarOrSet returns a Var with result from GetVarOrSet.
 // The returned Var is un-concurrent safe.
 func (m *ListMap) GetVarOrSet(key any, value any) *gvar.Var {
-	return gvar.New(m.GetOrSet(key, value))
+	m.lazyInit()
+	return m.ListKVMap.GetVarOrSet(key, value)
 }
 
 // GetVarOrSetFunc returns a Var with result from GetOrSetFunc.
 // The returned Var is un-concurrent safe.
 func (m *ListMap) GetVarOrSetFunc(key any, f func() any) *gvar.Var {
-	return gvar.New(m.GetOrSetFunc(key, f))
+	m.lazyInit()
+	return m.ListKVMap.GetVarOrSetFunc(key, f)
 }
 
 // GetVarOrSetFuncLock returns a Var with result from GetOrSetFuncLock.
 // The returned Var is un-concurrent safe.
 func (m *ListMap) GetVarOrSetFuncLock(key any, f func() any) *gvar.Var {
-	return gvar.New(m.GetOrSetFuncLock(key, f))
+	m.lazyInit()
+	return m.ListKVMap.GetVarOrSetFuncLock(key, f)
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *ListMap) SetIfNotExist(key any, value any) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, value)
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.ListKVMap.SetIfNotExist(key, value)
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *ListMap) SetIfNotExistFunc(key any, f func() any) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, f())
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.ListKVMap.SetIfNotExistFunc(key, f)
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -390,100 +221,52 @@ func (m *ListMap) SetIfNotExistFunc(key any, f func() any) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the map.
 func (m *ListMap) SetIfNotExistFuncLock(key any, f func() any) bool {
-	if !m.Contains(key) {
-		m.doSetWithLockCheck(key, f)
-		return true
-	}
-	return false
+	m.lazyInit()
+	return m.ListKVMap.SetIfNotExistFuncLock(key, f)
 }
 
 // Remove deletes value from map by given `key`, and return this deleted value.
 func (m *ListMap) Remove(key any) (value any) {
-	m.mu.Lock()
-	if m.data != nil {
-		if e, ok := m.data[key]; ok {
-			value = e.Value.(*gListMapNode).value
-			delete(m.data, key)
-			m.list.Remove(e)
-		}
-	}
-	m.mu.Unlock()
-	return
+	m.lazyInit()
+	return m.ListKVMap.Remove(key)
 }
 
 // Removes batch deletes values of the map by keys.
 func (m *ListMap) Removes(keys []any) {
-	m.mu.Lock()
-	if m.data != nil {
-		for _, key := range keys {
-			if e, ok := m.data[key]; ok {
-				delete(m.data, key)
-				m.list.Remove(e)
-			}
-		}
-	}
-	m.mu.Unlock()
+	m.lazyInit()
+	m.ListKVMap.Removes(keys)
 }
 
 // Keys returns all keys of the map as a slice in ascending order.
 func (m *ListMap) Keys() []any {
-	m.mu.RLock()
-	var (
-		keys  = make([]any, m.list.Len())
-		index = 0
-	)
-	if m.list != nil {
-		m.list.IteratorAsc(func(e *glist.Element) bool {
-			keys[index] = e.Value.(*gListMapNode).key
-			index++
-			return true
-		})
-	}
-	m.mu.RUnlock()
-	return keys
+	m.lazyInit()
+	return m.ListKVMap.Keys()
 }
 
 // Values returns all values of the map as a slice.
 func (m *ListMap) Values() []any {
-	m.mu.RLock()
-	var (
-		values = make([]any, m.list.Len())
-		index  = 0
-	)
-	if m.list != nil {
-		m.list.IteratorAsc(func(e *glist.Element) bool {
-			values[index] = e.Value.(*gListMapNode).value
-			index++
-			return true
-		})
-	}
-	m.mu.RUnlock()
-	return values
+	m.lazyInit()
+	return m.ListKVMap.Values()
 }
 
 // Contains checks whether a key exists.
 // It returns true if the `key` exists, or else false.
 func (m *ListMap) Contains(key any) (ok bool) {
-	m.mu.RLock()
-	if m.data != nil {
-		_, ok = m.data[key]
-	}
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.ListKVMap.Contains(key)
 }
 
 // Size returns the size of the map.
 func (m *ListMap) Size() (size int) {
-	m.mu.RLock()
-	size = len(m.data)
-	m.mu.RUnlock()
-	return
+	m.lazyInit()
+	return m.ListKVMap.Size()
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *ListMap) IsEmpty() bool {
-	return m.Size() == 0
+	m.lazyInit()
+	return m.ListKVMap.IsEmpty()
 }
 
 // Flip exchanges key-value of the map to value-key.
@@ -498,90 +281,35 @@ func (m *ListMap) Flip() {
 // Merge merges two link maps.
 // The `other` map will be merged into the map `m`.
 func (m *ListMap) Merge(other *ListMap) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[any]*glist.Element)
-		m.list = glist.New()
-	}
-	if other != m {
-		other.mu.RLock()
-		defer other.mu.RUnlock()
-	}
-	var node *gListMapNode
-	other.list.IteratorAsc(func(e *glist.Element) bool {
-		node = e.Value.(*gListMapNode)
-		if e, ok := m.data[node.key]; !ok {
-			m.data[node.key] = m.list.PushBack(&gListMapNode{node.key, node.value})
-		} else {
-			e.Value = &gListMapNode{node.key, node.value}
-		}
-		return true
-	})
+	m.lazyInit()
+	other.lazyInit()
+	m.ListKVMap.Merge(other.ListKVMap)
 }
 
 // String returns the map as a string.
 func (m *ListMap) String() string {
-	if m == nil {
-		return ""
-	}
-	b, _ := m.MarshalJSON()
-	return string(b)
+	m.lazyInit()
+	return m.ListKVMap.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m ListMap) MarshalJSON() (jsonBytes []byte, err error) {
-	if m.data == nil {
-		return []byte("null"), nil
-	}
-	buffer := bytes.NewBuffer(nil)
-	buffer.WriteByte('{')
-	m.Iterator(func(key, value any) bool {
-		valueBytes, valueJSONErr := json.Marshal(value)
-		if valueJSONErr != nil {
-			err = valueJSONErr
-			return false
-		}
-		if buffer.Len() > 1 {
-			buffer.WriteByte(',')
-		}
-		fmt.Fprintf(buffer, `"%v":%s`, key, valueBytes)
-		return true
-	})
-	buffer.WriteByte('}')
-	return buffer.Bytes(), nil
+	return m.ListKVMap.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (m *ListMap) UnmarshalJSON(b []byte) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[any]*glist.Element)
-		m.list = glist.New()
-	}
-	var data map[string]any
-	if err := json.UnmarshalUseNumber(b, &data); err != nil {
-		return err
-	}
-	for key, value := range data {
-		if e, ok := m.data[key]; !ok {
-			m.data[key] = m.list.PushBack(&gListMapNode{key, value})
-		} else {
-			e.Value = &gListMapNode{key, value}
-		}
-	}
-	return nil
+	m.lazyInit()
+	return m.ListKVMap.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
 func (m *ListMap) UnmarshalValue(value any) (err error) {
+	m.lazyInit()
+
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	if m.data == nil {
-		m.data = make(map[any]*glist.Element)
-		m.list = glist.New()
-	}
+
 	for k, v := range gconv.Map(value) {
 		if e, ok := m.data[k]; !ok {
 			m.data[k] = m.list.PushBack(&gListMapNode{k, v})
@@ -597,16 +325,8 @@ func (m *ListMap) DeepCopy() any {
 	if m == nil {
 		return nil
 	}
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	data := make(map[any]any, len(m.data))
-	if m.list != nil {
-		var node *gListMapNode
-		m.list.IteratorAsc(func(e *glist.Element) bool {
-			node = e.Value.(*gListMapNode)
-			data[node.key] = deepcopy.Copy(node.value)
-			return true
-		})
+	m.lazyInit()
+	return &ListMap{
+		ListKVMap: m.ListKVMap.DeepCopy().(*ListKVMap[any, any]),
 	}
-	return NewListMapFrom(data, m.mu.IsSafe())
 }
diff --git a/container/gmap/gmap_tree_k_v_map.go b/container/gmap/gmap_tree_k_v_map.go
new file mode 100644
index 000000000..d59095132
--- /dev/null
+++ b/container/gmap/gmap_tree_k_v_map.go
@@ -0,0 +1,32 @@
+// 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.
+
+//go:build go1.24
+
+package gmap
+
+import (
+	"github.com/gogf/gf/v2/container/gtree"
+)
+
+// TreeKVMap based on red-black tree, alias of RedBlackKVTree.
+type TreeKVMap[K comparable, V any] = gtree.RedBlackKVTree[K, V]
+
+// NewTreeKVMap instantiates a tree map with the custom comparator.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety,
+// which is false in default.
+func NewTreeKVMap[K comparable, V any](comparator func(v1, v2 K) int, safe ...bool) *TreeKVMap[K, V] {
+	return gtree.NewRedBlackKVTree[K, V](comparator, safe...)
+}
+
+// NewTreeKVMapFrom instantiates a tree map with the custom comparator and `data` map.
+// Note that, the param `data` map will be set as the underlying data map(no deep copy),
+// there might be some concurrent-safe issues when changing the map outside.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety,
+// which is false in default.
+func NewTreeKVMapFrom[K comparable, V any](comparator func(v1, v2 K) int, data map[K]V, safe ...bool) *TreeKVMap[K, V] {
+	return gtree.NewRedBlackKVTreeFrom(comparator, data, safe...)
+}
diff --git a/container/gmap/gmap_tree_map.go b/container/gmap/gmap_tree_map.go
index 3e07d97ee..fde034b81 100644
--- a/container/gmap/gmap_tree_map.go
+++ b/container/gmap/gmap_tree_map.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap
diff --git a/container/gmap/gmap_z_basic_test.go b/container/gmap/gmap_z_basic_test.go
index b2675228a..da294499a 100644
--- a/container/gmap/gmap_z_basic_test.go
+++ b/container/gmap/gmap_z_basic_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_bench_maps_test.go b/container/gmap/gmap_z_bench_maps_test.go
index 62e56c6b6..857ca5c95 100644
--- a/container/gmap/gmap_z_bench_maps_test.go
+++ b/container/gmap/gmap_z_bench_maps_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem
diff --git a/container/gmap/gmap_z_bench_safe_test.go b/container/gmap/gmap_z_bench_safe_test.go
index 9700a66bb..d60e371db 100644
--- a/container/gmap/gmap_z_bench_safe_test.go
+++ b/container/gmap/gmap_z_bench_safe_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem
diff --git a/container/gmap/gmap_z_bench_syncmap_test.go b/container/gmap/gmap_z_bench_syncmap_test.go
index 20f814a85..515e0c862 100644
--- a/container/gmap/gmap_z_bench_syncmap_test.go
+++ b/container/gmap/gmap_z_bench_syncmap_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem
diff --git a/container/gmap/gmap_z_bench_unsafe_test.go b/container/gmap/gmap_z_bench_unsafe_test.go
index c7f971f22..4bd699396 100644
--- a/container/gmap/gmap_z_bench_unsafe_test.go
+++ b/container/gmap/gmap_z_bench_unsafe_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem
diff --git a/container/gmap/gmap_z_example_any_any_test.go b/container/gmap/gmap_z_example_any_any_test.go
index bb53bd776..5e6a5c31a 100644
--- a/container/gmap/gmap_z_example_any_any_test.go
+++ b/container/gmap/gmap_z_example_any_any_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_example_int_any_test.go b/container/gmap/gmap_z_example_int_any_test.go
index 14201c7a1..e9a668b8d 100644
--- a/container/gmap/gmap_z_example_int_any_test.go
+++ b/container/gmap/gmap_z_example_int_any_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_example_int_int_test.go b/container/gmap/gmap_z_example_int_int_test.go
index fff14d922..107ff5fcc 100644
--- a/container/gmap/gmap_z_example_int_int_test.go
+++ b/container/gmap/gmap_z_example_int_int_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_example_list_test.go b/container/gmap/gmap_z_example_list_test.go
index 36f57833a..98b59c252 100644
--- a/container/gmap/gmap_z_example_list_test.go
+++ b/container/gmap/gmap_z_example_list_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_example_str_any_test.go b/container/gmap/gmap_z_example_str_any_test.go
index 0571befa8..f1f8bc11e 100644
--- a/container/gmap/gmap_z_example_str_any_test.go
+++ b/container/gmap/gmap_z_example_str_any_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_example_str_int_test.go b/container/gmap/gmap_z_example_str_int_test.go
index 304e683c8..9f78a0d8c 100644
--- a/container/gmap/gmap_z_example_str_int_test.go
+++ b/container/gmap/gmap_z_example_str_int_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_example_str_str_test.go b/container/gmap/gmap_z_example_str_str_test.go
index e0849c1c4..fc7b8dec9 100644
--- a/container/gmap/gmap_z_example_str_str_test.go
+++ b/container/gmap/gmap_z_example_str_str_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_example_test.go b/container/gmap/gmap_z_example_test.go
index b88da67e9..fae970d26 100644
--- a/container/gmap/gmap_z_example_test.go
+++ b/container/gmap/gmap_z_example_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_unit_hash_any_any_test.go b/container/gmap/gmap_z_unit_hash_any_any_test.go
index 9665db1b8..36a312f55 100644
--- a/container/gmap/gmap_z_unit_hash_any_any_test.go
+++ b/container/gmap/gmap_z_unit_hash_any_any_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
@@ -443,3 +443,49 @@ func Test_AnyAnyMap_Diff(t *testing.T) {
 		t.Assert(updatedKeys, []any{3})
 	})
 }
+
+func Test_AnyAnyMap_DoSetWithLockCheck_FuncValue(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewAnyAnyMap(true)
+
+		// Test GetOrSetFuncLock with function value
+		// Function should be executed and its return value should be set
+		callCount := 0
+		result := m.GetOrSetFuncLock(1, func() any {
+			callCount++
+			return "value1"
+		})
+		t.Assert(result, "value1")
+		t.Assert(callCount, 1)
+		t.Assert(m.Get(1), "value1")
+
+		// Test GetOrSetFuncLock again with same key
+		// Function should NOT be called since key exists
+		result = m.GetOrSetFuncLock(1, func() any {
+			callCount++
+			return "value2"
+		})
+		t.Assert(result, "value1")
+		t.Assert(callCount, 1) // Should still be 1, function not called
+
+		// Test SetIfNotExistFuncLock with function value
+		callCount = 0
+		ok := m.SetIfNotExistFuncLock(2, func() any {
+			callCount++
+			return "value2"
+		})
+		t.Assert(ok, true)
+		t.Assert(callCount, 1)
+		t.Assert(m.Get(2), "value2")
+
+		// Test SetIfNotExistFuncLock again with same key
+		// Function should NOT be called since key exists
+		ok = m.SetIfNotExistFuncLock(2, func() any {
+			callCount++
+			return "value3"
+		})
+		t.Assert(ok, false)
+		t.Assert(callCount, 1)       // Should still be 1, function not called
+		t.Assert(m.Get(2), "value2") // Value should not change
+	})
+}
diff --git a/container/gmap/gmap_z_unit_hash_int_any_test.go b/container/gmap/gmap_z_unit_hash_int_any_test.go
index 7c2f17314..848c81530 100644
--- a/container/gmap/gmap_z_unit_hash_int_any_test.go
+++ b/container/gmap/gmap_z_unit_hash_int_any_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_unit_hash_int_int_test.go b/container/gmap/gmap_z_unit_hash_int_int_test.go
index 0d352725e..2765db03f 100644
--- a/container/gmap/gmap_z_unit_hash_int_int_test.go
+++ b/container/gmap/gmap_z_unit_hash_int_int_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_unit_hash_int_str_test.go b/container/gmap/gmap_z_unit_hash_int_str_test.go
index 36ae4de0a..6eed7eab2 100644
--- a/container/gmap/gmap_z_unit_hash_int_str_test.go
+++ b/container/gmap/gmap_z_unit_hash_int_str_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_unit_hash_str_any_test.go b/container/gmap/gmap_z_unit_hash_str_any_test.go
index dcf34aa37..8ee222153 100644
--- a/container/gmap/gmap_z_unit_hash_str_any_test.go
+++ b/container/gmap/gmap_z_unit_hash_str_any_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
@@ -96,6 +96,42 @@ func Test_StrAnyMap_Set_Fun(t *testing.T) {
 
 		t.Assert(m.SetIfNotExistFuncLock("b", getAny), false)
 		t.Assert(m.SetIfNotExistFuncLock("d", getAny), true)
+
+		type T struct {
+			A int
+		}
+
+		av := m.GetOrSetFunc("s1", func() any {
+			return &T{
+				A: 1,
+			}
+		})
+		ta, ok := av.(*T)
+		t.Assert(ok, true)
+		t.Assert(ta.A, 1)
+
+		av = m.GetOrSetFunc("s1", func() any {
+			return &T{
+				A: 2,
+			}
+		})
+		ta, ok = av.(*T)
+		t.Assert(ok, true)
+		t.Assert(ta.A, 1)
+
+		av = m.GetOrSet("s1", &T{
+			A: 3,
+		})
+		ta, ok = av.(*T)
+		t.Assert(ok, true)
+		t.Assert(ta.A, 1)
+
+		av = m.GetOrSet("s2", &T{
+			A: 4,
+		})
+		ta, ok = av.(*T)
+		t.Assert(ok, true)
+		t.Assert(ta.A, 4)
 	})
 }
 
diff --git a/container/gmap/gmap_z_unit_hash_str_int_test.go b/container/gmap/gmap_z_unit_hash_str_int_test.go
index 577eff1e1..365a5077f 100644
--- a/container/gmap/gmap_z_unit_hash_str_int_test.go
+++ b/container/gmap/gmap_z_unit_hash_str_int_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_unit_hash_str_str_test.go b/container/gmap/gmap_z_unit_hash_str_str_test.go
index 7cbd4fbb6..cbf0a22a8 100644
--- a/container/gmap/gmap_z_unit_hash_str_str_test.go
+++ b/container/gmap/gmap_z_unit_hash_str_str_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_unit_k_v_map_test.go b/container/gmap/gmap_z_unit_k_v_map_test.go
new file mode 100644
index 000000000..8d95f4fa8
--- /dev/null
+++ b/container/gmap/gmap_z_unit_k_v_map_test.go
@@ -0,0 +1,1705 @@
+// 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 gmap_test
+
+import (
+	"strconv"
+	"sync"
+	"testing"
+
+	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+func Test_KVMap_NewKVMap(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+		t.Assert(m.Size(), 0)
+		t.Assert(m.IsEmpty(), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string](true)
+		t.Assert(m.Size(), 0)
+		t.Assert(m.IsEmpty(), true)
+	})
+}
+
+func Test_KVMap_NewKVMapFrom(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		data := map[string]string{"a": "1", "b": "2"}
+		m := gmap.NewKVMapFrom(data)
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := map[int]int{1: 10, 2: 20}
+		m := gmap.NewKVMapFrom(data, true)
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Get(1), 10)
+		t.Assert(m.Get(2), 20)
+	})
+}
+
+func Test_KVMap_Set_Get(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+		m.Set("a", "1")
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Size(), 1)
+
+		m.Set("b", "2")
+		t.Assert(m.Get("b"), "2")
+		t.Assert(m.Size(), 2)
+
+		// Set existing key
+		m.Set("a", "10")
+		t.Assert(m.Get("a"), "10")
+		t.Assert(m.Size(), 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[int, int]()
+		m.Set(1, 100)
+		m.Set(2, 200)
+		t.Assert(m.Get(1), 100)
+		t.Assert(m.Get(2), 200)
+	})
+}
+
+func Test_KVMap_Sets(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+		m.Sets(map[string]string{"a": "1", "b": "2", "c": "3"})
+		t.Assert(m.Size(), 3)
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+		t.Assert(m.Get("c"), "3")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := map[string]string{"x": "10", "y": "20"}
+		m := gmap.NewKVMapFrom(data)
+		m.Sets(map[string]string{"a": "1", "b": "2"})
+		t.Assert(m.Size(), 4)
+		t.Assert(m.Get("x"), "10")
+		t.Assert(m.Get("a"), "1")
+	})
+}
+
+func Test_KVMap_Search(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+
+		v, found := m.Search("a")
+		t.Assert(found, true)
+		t.Assert(v, "1")
+
+		v, found = m.Search("c")
+		t.Assert(found, false)
+		t.Assert(v, "")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[int, string]()
+		v, found := m.Search(1)
+		t.Assert(found, false)
+		t.Assert(v, "")
+	})
+}
+
+func Test_KVMap_Contains(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		t.Assert(m.Contains("a"), true)
+		t.Assert(m.Contains("b"), true)
+		t.Assert(m.Contains("c"), false)
+	})
+}
+
+func Test_KVMap_Remove(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		t.Assert(m.Size(), 2)
+
+		v := m.Remove("a")
+		t.Assert(v, "1")
+		t.Assert(m.Contains("a"), false)
+		t.Assert(m.Size(), 1)
+
+		v = m.Remove("c")
+		t.Assert(v, "")
+		t.Assert(m.Size(), 1)
+	})
+}
+
+func Test_KVMap_Removes(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		t.Assert(m.Size(), 3)
+
+		m.Removes([]string{"a", "c"})
+		t.Assert(m.Size(), 1)
+		t.Assert(m.Contains("a"), false)
+		t.Assert(m.Contains("c"), false)
+		t.Assert(m.Contains("b"), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		m.Removes([]string{"x", "y"})
+		t.Assert(m.Size(), 2)
+	})
+}
+
+func Test_KVMap_Pop(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		t.Assert(m.Size(), 2)
+
+		k, v := m.Pop()
+		t.AssertIN(k, []string{"a", "b"})
+		t.AssertIN(v, []string{"1", "2"})
+		t.Assert(m.Size(), 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+		k, v := m.Pop()
+		t.Assert(k, "")
+		t.Assert(v, "")
+	})
+}
+
+func Test_KVMap_Pops(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		t.Assert(m.Size(), 3)
+
+		popped := m.Pops(2)
+		t.Assert(len(popped), 2)
+		t.Assert(m.Size(), 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		popped := m.Pops(-1)
+		t.Assert(len(popped), 3)
+		t.Assert(m.Size(), 0)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		popped := m.Pops(10)
+		t.Assert(len(popped), 2)
+		t.Assert(m.Size(), 0)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+		popped := m.Pops(1)
+		t.AssertNil(popped)
+	})
+}
+
+func Test_KVMap_Keys(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		keys := m.Keys()
+		t.Assert(len(keys), 3)
+		t.AssertIN("a", keys)
+		t.AssertIN("b", keys)
+		t.AssertIN("c", keys)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[int, string]()
+		keys := m.Keys()
+		t.Assert(len(keys), 0)
+	})
+}
+
+func Test_KVMap_Values(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		values := m.Values()
+		t.Assert(len(values), 3)
+		t.AssertIN("1", values)
+		t.AssertIN("2", values)
+		t.AssertIN("3", values)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+		values := m.Values()
+		t.Assert(len(values), 0)
+	})
+}
+
+func Test_KVMap_Size(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+		t.Assert(m.Size(), 0)
+
+		m.Set("a", "1")
+		t.Assert(m.Size(), 1)
+
+		m.Set("b", "2")
+		t.Assert(m.Size(), 2)
+
+		m.Remove("a")
+		t.Assert(m.Size(), 1)
+
+		m.Clear()
+		t.Assert(m.Size(), 0)
+	})
+}
+
+func Test_KVMap_IsEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+		t.Assert(m.IsEmpty(), true)
+
+		m.Set("a", "1")
+		t.Assert(m.IsEmpty(), false)
+
+		m.Remove("a")
+		t.Assert(m.IsEmpty(), true)
+	})
+}
+
+func Test_KVMap_Clear(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		t.Assert(m.Size(), 3)
+
+		m.Clear()
+		t.Assert(m.Size(), 0)
+		t.Assert(m.IsEmpty(), true)
+		t.Assert(m.Get("a"), "")
+	})
+}
+
+func Test_KVMap_Map(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		data := m.Map()
+		t.Assert(data["a"], "1")
+		t.Assert(data["b"], "2")
+		t.Assert(len(data), 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Unsafe map, modifying returned map affects original
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"}, false)
+		data := m.Map()
+		data["c"] = "3"
+		t.Assert(m.Get("c"), "3")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Safe map, modifying returned map doesn't affect original
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"}, true)
+		data := m.Map()
+		data["c"] = "3"
+		t.Assert(m.Get("c"), "")
+	})
+}
+
+func Test_KVMap_MapCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		data := m.MapCopy()
+		t.Assert(data["a"], "1")
+		t.Assert(data["b"], "2")
+
+		// Modifying copy doesn't affect original
+		data["c"] = "3"
+		t.Assert(m.Get("c"), "")
+
+		m.Set("d", "4")
+		t.Assert(data["d"], "")
+	})
+}
+
+func Test_KVMap_MapStrAny(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]int{"a": 1, "b": 2})
+		data := m.MapStrAny()
+		t.Assert(len(data), 2)
+		t.Assert(data["a"], 1)
+		t.Assert(data["b"], 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[int]string{1: "a", 2: "b"})
+		data := m.MapStrAny()
+		t.Assert(len(data), 2)
+		t.Assert(data["1"], "a")
+		t.Assert(data["2"], "b")
+	})
+}
+
+func Test_KVMap_FilterEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "", "b": "2", "c": "3"})
+		t.Assert(m.Size(), 3)
+
+		m.FilterEmpty()
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Contains("a"), false)
+		t.Assert(m.Contains("b"), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]int{"a": 0, "b": 1, "c": 2})
+		t.Assert(m.Size(), 3)
+
+		m.FilterEmpty()
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Contains("a"), false)
+	})
+}
+
+func Test_KVMap_FilterNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, *string]()
+		a := "a"
+		m.Set("key1", &a)
+		m.Set("key2", nil)
+		m.Set("key3", nil)
+		t.Assert(m.Size(), 3)
+
+		m.FilterNil()
+		t.Assert(m.Size(), 1)
+		t.Assert(m.Contains("key1"), true)
+		t.Assert(m.Contains("key2"), false)
+	})
+}
+
+func Test_KVMap_GetOrSet(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+
+		v := m.GetOrSet("a", "1")
+		t.Assert(v, "1")
+		t.Assert(m.Get("a"), "1")
+
+		v = m.GetOrSet("a", "10")
+		t.Assert(v, "1")
+		t.Assert(m.Get("a"), "1")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]int{"a": 10})
+
+		v := m.GetOrSet("a", 20)
+		t.Assert(v, 10)
+
+		v = m.GetOrSet("b", 30)
+		t.Assert(v, 30)
+		t.Assert(m.Get("b"), 30)
+	})
+}
+
+func Test_KVMap_GetOrSetFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+
+		v := m.GetOrSetFunc("a", func() string { return "1" })
+		t.Assert(v, "1")
+
+		v = m.GetOrSetFunc("a", func() string { return "10" })
+		t.Assert(v, "1")
+
+		v = m.GetOrSetFunc("b", func() string { return "2" })
+		t.Assert(v, "2")
+	})
+}
+
+func Test_KVMap_GetOrSetFuncLock(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+		counter := 0
+
+		v := m.GetOrSetFuncLock("a", func() int {
+			counter++
+			return 10
+		})
+		t.Assert(v, 10)
+		t.Assert(counter, 1)
+
+		v = m.GetOrSetFuncLock("a", func() int {
+			counter++
+			return 20
+		})
+		t.Assert(v, 10)
+		t.Assert(counter, 1)
+	})
+}
+
+func Test_KVMap_SetIfNotExist(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+
+		ok := m.SetIfNotExist("a", "1")
+		t.Assert(ok, true)
+		t.Assert(m.Get("a"), "1")
+
+		ok = m.SetIfNotExist("a", "10")
+		t.Assert(ok, false)
+		t.Assert(m.Get("a"), "1")
+	})
+}
+
+func Test_KVMap_SetIfNotExistFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+
+		ok := m.SetIfNotExistFunc("a", func() int { return 10 })
+		t.Assert(ok, true)
+		t.Assert(m.Get("a"), 10)
+
+		ok = m.SetIfNotExistFunc("a", func() int { return 20 })
+		t.Assert(ok, false)
+		t.Assert(m.Get("a"), 10)
+	})
+}
+
+func Test_KVMap_SetIfNotExistFuncLock(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+		counter := 0
+
+		ok := m.SetIfNotExistFuncLock("a", func() string {
+			counter++
+			return "1"
+		})
+		t.Assert(ok, true)
+		t.Assert(counter, 1)
+
+		ok = m.SetIfNotExistFuncLock("a", func() string {
+			counter++
+			return "2"
+		})
+		t.Assert(ok, false)
+		t.Assert(counter, 1)
+	})
+}
+
+func Test_KVMap_GetVar(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+
+		v := m.GetVar("a")
+		t.AssertNE(v, nil)
+		t.Assert(v.Val(), "1")
+
+		v = m.GetVar("c")
+		t.Assert(v.Val(), nil)
+	})
+}
+
+func Test_KVMap_GetVarOrSet(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+
+		v := m.GetVarOrSet("a", "1")
+		t.AssertNE(v, nil)
+		t.Assert(v.Val(), "1")
+
+		v = m.GetVarOrSet("a", "10")
+		t.Assert(v.Val(), "1")
+	})
+}
+
+func Test_KVMap_GetVarOrSetFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+
+		v := m.GetVarOrSetFunc("a", func() int { return 10 })
+		t.AssertNE(v, nil)
+		t.Assert(v.Val(), 10)
+
+		v = m.GetVarOrSetFunc("a", func() int { return 20 })
+		t.Assert(v.Val(), 10)
+	})
+}
+
+func Test_KVMap_GetVarOrSetFuncLock(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+
+		v := m.GetVarOrSetFuncLock("a", func() string { return "1" })
+		t.AssertNE(v, nil)
+		t.Assert(v.Val(), "1")
+
+		v = m.GetVarOrSetFuncLock("a", func() string { return "10" })
+		t.Assert(v.Val(), "1")
+	})
+}
+
+func Test_KVMap_Iterator(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		data := map[string]string{"a": "1", "b": "2", "c": "3"}
+		m := gmap.NewKVMapFrom(data)
+
+		count := 0
+		m.Iterator(func(k string, v string) bool {
+			t.Assert(data[k], v)
+			count++
+			return true
+		})
+		t.Assert(count, 3)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[int]string{1: "a", 2: "b", 3: "c"})
+
+		count := 0
+		m.Iterator(func(k int, v string) bool {
+			count++
+			return count < 2
+		})
+		t.Assert(count, 2)
+	})
+}
+
+func Test_KVMap_Iterator_Deadlock(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"1": "1", "2": "2", "3": "3", "4": "4"}, true)
+		m.Iterator(func(k string, _ string) bool {
+			kInt, _ := strconv.Atoi(k)
+			if kInt%2 == 0 {
+				m.Remove(k)
+			}
+			return true
+		})
+		t.Assert(m.Size(), 2)
+	})
+}
+
+func Test_KVMap_LockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+
+		m.LockFunc(func(data map[string]string) {
+			t.Assert(data["a"], "1")
+			t.Assert(data["b"], "2")
+			data["c"] = "3"
+		})
+
+		t.Assert(m.Get("c"), "3")
+	})
+}
+
+func Test_KVMap_RLockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		count := 0
+
+		m.RLockFunc(func(data map[string]string) {
+			count += len(data)
+		})
+
+		t.Assert(count, 2)
+	})
+}
+
+func Test_KVMap_Replace(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		t.Assert(m.Size(), 2)
+
+		m.Replace(map[string]string{"x": "10", "y": "20", "z": "30"})
+		t.Assert(m.Size(), 3)
+		t.Assert(m.Get("a"), "")
+		t.Assert(m.Get("x"), "10")
+	})
+}
+
+func Test_KVMap_Clone(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		m2 := m.Clone()
+
+		t.Assert(m2.Get("a"), "1")
+		t.Assert(m2.Get("b"), "2")
+		t.Assert(m2.Size(), 2)
+
+		m.Set("a", "10")
+		t.Assert(m2.Get("a"), "1")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]int{"a": 1, "b": 2}, false)
+		m2 := m.Clone(true)
+
+		t.Assert(m2.Size(), 2)
+	})
+}
+
+func Test_KVMap_Flip(t *testing.T) {
+	// Test with same type for key and value (string -> string)
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		m.Flip()
+
+		t.Assert(m.Get("1"), "a")
+		t.Assert(m.Get("2"), "b")
+		t.Assert(m.Get("3"), "c")
+	})
+
+	// Test with same type for key and value (int -> int)
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[int]int{1: 10, 2: 20})
+		m.Flip()
+
+		t.Assert(m.Get(10), 1)
+		t.Assert(m.Get(20), 2)
+	})
+}
+
+func Test_KVMap_Merge(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMapFrom(map[string]string{"a": "1"})
+		m2 := gmap.NewKVMapFrom(map[string]string{"b": "2", "c": "3"})
+
+		m1.Merge(m2)
+		t.Assert(m1.Size(), 3)
+		t.Assert(m1.Get("a"), "1")
+		t.Assert(m1.Get("b"), "2")
+		t.Assert(m1.Get("c"), "3")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMap[string, int]()
+		m2 := gmap.NewKVMapFrom(map[string]int{"a": 10, "b": 20})
+
+		m1.Merge(m2)
+		t.Assert(m1.Size(), 2)
+		t.Assert(m1.Get("a"), 10)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMapFrom(map[string]string{"a": "1"})
+		m2 := gmap.NewKVMapFrom(map[string]string{"a": "10", "b": "2"})
+
+		m1.Merge(m2)
+		t.Assert(m1.Get("a"), "10")
+	})
+}
+
+func Test_KVMap_IsSubOf(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		m2 := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+
+		t.Assert(m1.IsSubOf(m2), true)
+		t.Assert(m2.IsSubOf(m1), false)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		m2 := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "10"})
+
+		t.Assert(m1.IsSubOf(m2), false)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMapFrom(map[string]string{"a": "1"})
+		t.Assert(m1.IsSubOf(m1), true)
+	})
+}
+
+func Test_KVMap_Diff(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		m2 := gmap.NewKVMapFrom(map[string]string{"a": "1", "d": "4"})
+
+		added, removed, updated := m1.Diff(m2)
+		t.Assert(len(added), 1)
+		t.AssertIN("d", added)
+		t.Assert(len(removed), 2)
+		t.AssertIN("b", removed)
+		t.AssertIN("c", removed)
+		t.Assert(len(updated), 0)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		m2 := gmap.NewKVMapFrom(map[string]string{"a": "10", "b": "2"})
+
+		added, removed, updated := m1.Diff(m2)
+		t.Assert(len(added), 0)
+		t.Assert(len(removed), 0)
+		t.Assert(len(updated), 1)
+		t.AssertIN("a", updated)
+	})
+}
+
+func Test_KVMap_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1"})
+		s := m.String()
+		t.AssertNE(s, "")
+		t.AssertIN("a", s)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		var m *gmap.KVMap[string, string]
+		s := m.String()
+		t.Assert(s, "")
+	})
+}
+
+func Test_KVMap_MarshalJSON(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]int{"a": 1, "b": 2})
+		b, err := json.Marshal(m)
+		t.AssertNil(err)
+		t.AssertNE(b, nil)
+
+		var data map[string]int
+		err = json.Unmarshal(b, &data)
+		t.AssertNil(err)
+		t.Assert(data["a"], 1)
+		t.Assert(data["b"], 2)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		var m gmap.KVMap[int, int]
+		m.Set(1, 10)
+		b, err := json.Marshal(m)
+		t.AssertNil(err)
+		t.Assert(string(b), `{"1":10}`)
+	})
+}
+
+func Test_KVMap_UnmarshalJSON(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+		data := []byte(`{"a":1,"b":2,"c":3}`)
+
+		err := json.UnmarshalUseNumber(data, m)
+		t.AssertNil(err)
+		t.Assert(m.Get("a"), 1)
+		t.Assert(m.Get("b"), 2)
+		t.Assert(m.Get("c"), 3)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		var m gmap.KVMap[string, string]
+		data := []byte(`{"x":"10","y":"20"}`)
+
+		err := json.UnmarshalUseNumber(data, &m)
+		t.AssertNil(err)
+		t.Assert(m.Get("x"), "10")
+		t.Assert(m.Get("y"), "20")
+	})
+}
+
+func Test_KVMap_UnmarshalValue(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, string]()
+		err := m.UnmarshalValue(map[string]any{
+			"a": "1",
+			"b": "2",
+		})
+		t.AssertNil(err)
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+	})
+}
+
+func Test_KVMap_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string][]string{
+			"a": {"1", "2"},
+			"b": {"3", "4"},
+		})
+
+		n := m.DeepCopy().(*gmap.KVMap[string, []string])
+		t.Assert(n.Size(), 2)
+		t.Assert(n.Get("a"), []string{"1", "2"})
+
+		// Modifying original doesn't affect copy
+		m.Get("a")[0] = "10"
+		t.Assert(n.Get("a")[0], "1")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		var m *gmap.KVMap[string, int]
+		n := m.DeepCopy()
+		t.AssertNil(n)
+	})
+}
+
+// Test Set with nil data
+func Test_KVMap_Set_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create map with nil internal data
+		m := gmap.NewKVMapFrom[string, string](nil)
+		m.Set("a", "1")
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Size(), 1)
+	})
+}
+
+// Test Sets with nil data
+func Test_KVMap_Sets_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create map with nil internal data
+		m := gmap.NewKVMapFrom[string, string](nil)
+		m.Sets(map[string]string{"a": "1", "b": "2"})
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+		t.Assert(m.Size(), 2)
+	})
+}
+
+// Test doSetWithLockCheck - key exists and value is nil
+func Test_KVMap_GetOrSet_KeyExists(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom[string, string](nil)
+		// First call: key does not exist, set value
+		v := m.GetOrSet("a", "1")
+		t.Assert(v, "1")
+
+		// Second call: key exists, should return existing value
+		v = m.GetOrSet("a", "2")
+		t.Assert(v, "1")
+	})
+}
+
+// Test GetOrSet with nil value
+func Test_KVMap_GetOrSet_NilValue(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, *string]()
+		// Set nil value
+		v := m.GetOrSet("a", nil)
+		t.Assert(v, nil)
+		// Key is not stored when value is nil (based on implementation)
+		// The doSetWithLockCheck checks: if any(value) != nil
+		// For pointer type, nil is actually stored because any(nil pointer) is not nil interface
+		// Let's verify the actual behavior
+	})
+
+	// Test with interface type to trigger the nil check
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, any]()
+		v := m.GetOrSet("a", nil)
+		t.Assert(v, nil)
+		// nil interface value should not be stored
+		t.Assert(m.Contains("a"), false)
+	})
+}
+
+// Test GetOrSetFunc with nil value
+func Test_KVMap_GetOrSetFunc_NilValue(t *testing.T) {
+	// Test with interface type to trigger the nil check
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, any]()
+		v := m.GetOrSetFunc("a", func() any { return nil })
+		t.Assert(v, nil)
+		// nil interface value should not be stored
+		t.Assert(m.Contains("a"), false)
+	})
+}
+
+// Test GetOrSetFuncLock with nil data and nil value
+func Test_KVMap_GetOrSetFuncLock_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom[string, string](nil)
+		v := m.GetOrSetFuncLock("a", func() string { return "1" })
+		t.Assert(v, "1")
+		t.Assert(m.Get("a"), "1")
+	})
+
+	// Test with nil value (using any type)
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, any]()
+		v := m.GetOrSetFuncLock("a", func() any { return nil })
+		t.Assert(v, nil)
+		// nil interface value should not be stored
+		t.Assert(m.Contains("a"), false)
+	})
+}
+
+// Test SetIfNotExist with nil data
+func Test_KVMap_SetIfNotExist_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom[string, string](nil)
+		ok := m.SetIfNotExist("a", "1")
+		t.Assert(ok, true)
+		t.Assert(m.Get("a"), "1")
+	})
+}
+
+// Test SetIfNotExistFuncLock with nil data
+func Test_KVMap_SetIfNotExistFuncLock_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom[string, string](nil)
+		ok := m.SetIfNotExistFuncLock("a", func() string { return "1" })
+		t.Assert(ok, true)
+		t.Assert(m.Get("a"), "1")
+	})
+}
+
+// Test Flip with conversion errors
+func Test_KVMap_Flip_ConversionError(t *testing.T) {
+	// Test with incompatible types that will fail conversion
+	gtest.C(t, func(t *gtest.T) {
+		type customKey struct {
+			ID int
+		}
+		type customVal struct {
+			Name string
+		}
+		m := gmap.NewKVMapFrom(map[customKey]customVal{
+			{ID: 1}: {Name: "a"},
+			{ID: 2}: {Name: "b"},
+		})
+		// Flip will fail because customVal cannot be converted to customKey
+		m.Flip()
+		// After failed flip, map should be empty or unchanged depending on implementation
+		// Based on the code, items that fail conversion are skipped
+	})
+}
+
+// Test Merge with self
+func Test_KVMap_Merge_Self(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		m.Merge(m)
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+	})
+}
+
+// Test Merge with nil data
+func Test_KVMap_Merge_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom[string, string](nil)
+		m2 := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		m.Merge(m2)
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+	})
+}
+
+// Test UnmarshalJSON with invalid JSON
+func Test_KVMap_UnmarshalJSON_InvalidJSON(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+		err := m.UnmarshalJSON([]byte(`{invalid json}`))
+		t.AssertNE(err, nil)
+	})
+}
+
+// Test UnmarshalJSON with incompatible value types
+func Test_KVMap_UnmarshalJSON_TypeMismatch(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+		// Valid JSON but values are strings, not ints
+		err := m.UnmarshalJSON([]byte(`{"a":"not_a_number"}`))
+		// This may or may not error depending on gconv.Scan behavior
+		// The test verifies the code path is executed
+		_ = err
+	})
+}
+
+// Test UnmarshalValue with conversion error
+func Test_KVMap_UnmarshalValue_ConversionError(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+		// This tests the conversion path
+		err := m.UnmarshalValue(map[string]any{
+			"a": "1",
+			"b": "2",
+		})
+		// Even with string values, gconv.Scan should handle conversion
+		t.AssertNil(err)
+		t.Assert(m.Get("a"), 1)
+		t.Assert(m.Get("b"), 2)
+	})
+}
+
+// Test Search with nil data
+func Test_KVMap_Search_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom[string, string](nil)
+		v, found := m.Search("a")
+		t.Assert(found, false)
+		t.Assert(v, "")
+	})
+}
+
+// Test Get with nil data
+func Test_KVMap_Get_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom[string, int](nil)
+		v := m.Get("a")
+		t.Assert(v, 0)
+	})
+}
+
+// Test Contains with nil data
+func Test_KVMap_Contains_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom[string, string](nil)
+		t.Assert(m.Contains("a"), false)
+	})
+}
+
+// Test Remove with nil data
+func Test_KVMap_Remove_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom[string, string](nil)
+		v := m.Remove("a")
+		t.Assert(v, "")
+	})
+}
+
+// Test Removes with nil data
+func Test_KVMap_Removes_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom[string, string](nil)
+		m.Removes([]string{"a", "b"})
+		t.Assert(m.Size(), 0)
+	})
+}
+
+// Test Pop from empty map
+func Test_KVMap_Pop_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom[string, string](nil)
+		k, v := m.Pop()
+		t.Assert(k, "")
+		t.Assert(v, "")
+	})
+}
+
+// Test Pops with size 0
+func Test_KVMap_Pops_ZeroSize(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		popped := m.Pops(0)
+		t.AssertNil(popped)
+		t.Assert(m.Size(), 2)
+	})
+}
+
+// Test Iterator early break
+func Test_KVMap_Iterator_Break(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		count := 0
+		m.Iterator(func(k string, v string) bool {
+			count++
+			return false // Break immediately
+		})
+		t.Assert(count, 1)
+	})
+}
+
+// Test DeepCopy with safe mode
+func Test_KVMap_DeepCopy_Safe(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"a": "1", "b": "2"}, true)
+		n := m.DeepCopy().(*gmap.KVMap[string, string])
+		t.Assert(n.Size(), 2)
+		t.Assert(n.Get("a"), "1")
+	})
+}
+
+// Concurrent safety tests
+func Test_KVMap_Concurrent_Safe(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int](true)
+		ch := make(chan int, 10)
+
+		// Concurrent writes
+		for i := 0; i < 10; i++ {
+			go func(idx int) {
+				m.Set(gconv.String(idx), idx)
+				ch <- 1
+			}(i)
+		}
+
+		for i := 0; i < 10; i++ {
+			<-ch
+		}
+
+		t.Assert(m.Size(), 10)
+	})
+}
+
+func Test_KVMap_Concurrent_RW(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int](true)
+		m.Sets(map[string]int{"a": 1, "b": 2, "c": 3})
+
+		ch := make(chan int, 20)
+
+		// Concurrent reads and writes
+		for i := 0; i < 10; i++ {
+			go func() {
+				_ = m.Get("a")
+				ch <- 1
+			}()
+		}
+
+		for i := 0; i < 10; i++ {
+			go func(idx int) {
+				m.Set(gconv.String(idx), idx)
+				ch <- 1
+			}(i)
+		}
+
+		for i := 0; i < 20; i++ {
+			<-ch
+		}
+
+		t.Assert(m.Size(), 13)
+	})
+}
+
+// Test concurrent GetOrSet
+func Test_KVMap_Concurrent_GetOrSet(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int](true)
+		ch := make(chan int, 100)
+
+		for i := 0; i < 100; i++ {
+			go func(idx int) {
+				m.GetOrSet("key", idx)
+				ch <- 1
+			}(i)
+		}
+
+		for i := 0; i < 100; i++ {
+			<-ch
+		}
+
+		// Only one value should be set
+		t.Assert(m.Size(), 1)
+		t.Assert(m.Contains("key"), true)
+	})
+}
+
+// Test concurrent SetIfNotExist
+func Test_KVMap_Concurrent_SetIfNotExist(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int](true)
+		successCount := 0
+		ch := make(chan bool, 100)
+
+		for i := 0; i < 100; i++ {
+			go func(idx int) {
+				ok := m.SetIfNotExist("key", idx)
+				ch <- ok
+			}(i)
+		}
+
+		for i := 0; i < 100; i++ {
+			if <-ch {
+				successCount++
+			}
+		}
+
+		// Only one goroutine should succeed
+		t.Assert(successCount, 1)
+		t.Assert(m.Size(), 1)
+	})
+}
+
+// Test doSetWithLockCheck when key exists (race condition scenario)
+func Test_KVMap_DoSetWithLockCheck_KeyExists(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int](true)
+		// First, set the key using GetOrSet
+		v := m.GetOrSet("a", 1)
+		t.Assert(v, 1)
+
+		// Second call - key exists in doSetWithLockCheck
+		// This simulates the race condition where the key is set between Search and doSetWithLockCheck
+		v = m.GetOrSet("a", 2)
+		t.Assert(v, 1)
+	})
+}
+
+// Test Flip with key conversion error
+func Test_KVMap_Flip_KeyConversionError(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a map where key->value conversion will fail
+		// Using struct types that cannot be converted to each other
+		type Key struct {
+			ID int
+		}
+		type Value struct {
+			Name string
+		}
+		m := gmap.NewKVMapFrom(map[Key]Value{
+			{ID: 1}: {Name: "a"},
+		})
+		// This should not panic, but the conversion may succeed or fail
+		// depending on gconv.Scan implementation
+		m.Flip()
+		// Just verify it doesn't panic - size depends on conversion behavior
+	})
+}
+
+// Test Flip with value->key conversion success but key->value conversion failure
+func Test_KVMap_Flip_ValueKeyConversionError(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Use int -> int where one direction might fail
+		m := gmap.NewKVMapFrom(map[int]int{1: 10, 2: 20})
+		m.Flip()
+		// Should flip successfully
+		t.Assert(m.Contains(10), true)
+		t.Assert(m.Contains(20), true)
+		t.Assert(m.Get(10), 1)
+		t.Assert(m.Get(20), 2)
+	})
+}
+
+// Test UnmarshalJSON with Scan error
+func Test_KVMap_UnmarshalJSON_ScanError(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a map with int keys, but provide string keys in JSON
+		// that cannot be properly scanned to int
+		m := gmap.NewKVMap[int, string]()
+		// This JSON has string keys that need to be converted to int
+		err := m.UnmarshalJSON([]byte(`{"not_a_number":"value"}`))
+		// The error depends on gconv.Scan behavior
+		// Just verify the code path is executed
+		_ = err
+	})
+}
+
+// Test UnmarshalValue with Scan error
+func Test_KVMap_UnmarshalValue_ScanError(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a map where the value type conversion will fail
+		type CustomStruct struct {
+			Field int
+		}
+		m := gmap.NewKVMap[string, CustomStruct]()
+		// Try to unmarshal incompatible data
+		err := m.UnmarshalValue(map[string]any{
+			"a": "not_a_struct",
+		})
+		// The error depends on gconv.Scan behavior
+		_ = err
+	})
+}
+
+// Test concurrent GetOrSetFunc
+func Test_KVMap_Concurrent_GetOrSetFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int](true)
+		ch := make(chan int, 100)
+		counter := int32(0)
+
+		for i := 0; i < 100; i++ {
+			go func(idx int) {
+				m.GetOrSetFunc("key", func() int {
+					// Increment counter to track how many times the function is called
+					return idx
+				})
+				ch <- 1
+			}(i)
+		}
+
+		for i := 0; i < 100; i++ {
+			<-ch
+		}
+
+		t.Assert(m.Size(), 1)
+		_ = counter
+	})
+}
+
+// Test concurrent GetOrSetFuncLock
+func Test_KVMap_Concurrent_GetOrSetFuncLock(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int](true)
+		ch := make(chan int, 100)
+
+		for i := 0; i < 100; i++ {
+			go func(idx int) {
+				m.GetOrSetFuncLock("key", func() int {
+					return idx
+				})
+				ch <- 1
+			}(i)
+		}
+
+		for i := 0; i < 100; i++ {
+			<-ch
+		}
+
+		t.Assert(m.Size(), 1)
+	})
+}
+
+// Test concurrent LockFunc
+func Test_KVMap_Concurrent_LockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int](true)
+		m.Set("counter", 0)
+		ch := make(chan int, 100)
+
+		for i := 0; i < 100; i++ {
+			go func() {
+				m.LockFunc(func(data map[string]int) {
+					data["counter"]++
+				})
+				ch <- 1
+			}()
+		}
+
+		for i := 0; i < 100; i++ {
+			<-ch
+		}
+
+		t.Assert(m.Get("counter"), 100)
+	})
+}
+
+// Test empty map operations
+func Test_KVMap_EmptyMapOperations(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+
+		// Test Keys on empty map
+		keys := m.Keys()
+		t.Assert(len(keys), 0)
+
+		// Test Values on empty map
+		values := m.Values()
+		t.Assert(len(values), 0)
+
+		// Test MapCopy on empty map
+		copy := m.MapCopy()
+		t.Assert(len(copy), 0)
+
+		// Test MapStrAny on empty map
+		strAny := m.MapStrAny()
+		t.Assert(len(strAny), 0)
+	})
+}
+
+// Test FilterEmpty with various empty values
+func Test_KVMap_FilterEmpty_Various(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, any]()
+		m.Set("nil", nil)
+		m.Set("zero", 0)
+		m.Set("empty_string", "")
+		m.Set("false", false)
+		m.Set("valid", "value")
+		m.Set("empty_slice", []int{})
+		m.Set("empty_map", map[string]int{})
+
+		t.Assert(m.Size(), 7)
+		m.FilterEmpty()
+		t.Assert(m.Size(), 1)
+		t.Assert(m.Contains("valid"), true)
+	})
+}
+
+// Test FilterNil with various nil values
+func Test_KVMap_FilterNil_Various(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, any]()
+		m.Set("nil", nil)
+		m.Set("zero", 0)
+		m.Set("empty_string", "")
+		m.Set("valid", "value")
+
+		t.Assert(m.Size(), 4)
+		m.FilterNil()
+		t.Assert(m.Size(), 3)
+		t.Assert(m.Contains("nil"), false)
+	})
+}
+
+// Test Clone with different safe modes
+func Test_KVMap_Clone_SafeMode(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Clone unsafe map to safe
+		m := gmap.NewKVMapFrom(map[string]int{"a": 1}, false)
+		m2 := m.Clone(true)
+		t.Assert(m2.Get("a"), 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Clone safe map to unsafe
+		m := gmap.NewKVMapFrom(map[string]int{"a": 1}, true)
+		m2 := m.Clone(false)
+		t.Assert(m2.Get("a"), 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Clone with inherited safe mode
+		m := gmap.NewKVMapFrom(map[string]int{"a": 1}, true)
+		m2 := m.Clone()
+		t.Assert(m2.Get("a"), 1)
+	})
+}
+
+// Test Diff with empty maps
+func Test_KVMap_Diff_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMap[string, int]()
+		m2 := gmap.NewKVMap[string, int]()
+
+		added, removed, updated := m1.Diff(m2)
+		t.Assert(len(added), 0)
+		t.Assert(len(removed), 0)
+		t.Assert(len(updated), 0)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMap[string, int]()
+		m2 := gmap.NewKVMapFrom(map[string]int{"a": 1, "b": 2})
+
+		added, removed, updated := m1.Diff(m2)
+		t.Assert(len(added), 2)
+		t.Assert(len(removed), 0)
+		t.Assert(len(updated), 0)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMapFrom(map[string]int{"a": 1, "b": 2})
+		m2 := gmap.NewKVMap[string, int]()
+
+		added, removed, updated := m1.Diff(m2)
+		t.Assert(len(added), 0)
+		t.Assert(len(removed), 2)
+		t.Assert(len(updated), 0)
+	})
+}
+
+// Test IsSubOf with empty maps
+func Test_KVMap_IsSubOf_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMap[string, int]()
+		m2 := gmap.NewKVMapFrom(map[string]int{"a": 1})
+
+		// Empty map is always a subset
+		t.Assert(m1.IsSubOf(m2), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewKVMapFrom(map[string]int{"a": 1})
+		m2 := gmap.NewKVMap[string, int]()
+
+		// Non-empty map is not a subset of empty map
+		t.Assert(m1.IsSubOf(m2), false)
+	})
+}
+
+// Test concurrent access to doSetWithLockCheck
+func Test_KVMap_DoSetWithLockCheck_Concurrent(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// This test creates a race condition where multiple goroutines
+		// try to set the same key, triggering the "key exists" branch in doSetWithLockCheck
+		m := gmap.NewKVMap[string, int](true)
+		var wg sync.WaitGroup
+		results := make([]int, 100)
+
+		for i := 0; i < 100; i++ {
+			wg.Add(1)
+			go func(idx int) {
+				defer wg.Done()
+				// All goroutines try to set the same key
+				v := m.GetOrSet("key", idx)
+				results[idx] = v
+			}(i)
+		}
+		wg.Wait()
+
+		// All results should be the same (the first value that was set)
+		firstValue := results[0]
+		for _, v := range results {
+			t.Assert(v, firstValue)
+		}
+	})
+}
+
+// Test GetOrSetFunc concurrent to trigger doSetWithLockCheck key exists branch
+func Test_KVMap_GetOrSetFunc_Concurrent(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int](true)
+		var wg sync.WaitGroup
+
+		for i := 0; i < 100; i++ {
+			wg.Add(1)
+			go func(idx int) {
+				defer wg.Done()
+				m.GetOrSetFunc("key", func() int { return idx })
+			}(i)
+		}
+		wg.Wait()
+
+		t.Assert(m.Size(), 1)
+	})
+}
+
+// Test SetIfNotExistFunc returning false when key exists
+func Test_KVMap_SetIfNotExistFunc_KeyExists(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+		m.Set("a", 1)
+
+		called := false
+		ok := m.SetIfNotExistFunc("a", func() int {
+			called = true
+			return 2
+		})
+		t.Assert(ok, false)
+		t.Assert(called, false) // Function should not be called if key exists
+		t.Assert(m.Get("a"), 1)
+	})
+}
+
+// Test UnmarshalValue with nil input
+func Test_KVMap_UnmarshalValue_Nil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+		err := m.UnmarshalValue(nil)
+		t.AssertNil(err)
+		t.Assert(m.Size(), 0)
+	})
+}
+
+// Test MarshalJSON with empty map
+func Test_KVMap_MarshalJSON_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+		b, err := m.MarshalJSON()
+		t.AssertNil(err)
+		t.Assert(string(b), "{}")
+	})
+}
+
+// Test String with empty map
+func Test_KVMap_String_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMap[string, int]()
+		s := m.String()
+		t.Assert(s, "{}")
+	})
+}
+
+// Test RLockFunc with concurrent access
+func Test_KVMap_RLockFunc_Concurrent(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]int{"a": 1, "b": 2}, true)
+		var wg sync.WaitGroup
+		results := make([]int, 100)
+
+		for i := 0; i < 100; i++ {
+			wg.Add(1)
+			go func(idx int) {
+				defer wg.Done()
+				m.RLockFunc(func(data map[string]int) {
+					results[idx] = data["a"]
+				})
+			}(i)
+		}
+		wg.Wait()
+
+		for _, v := range results {
+			t.Assert(v, 1)
+		}
+	})
+}
+
+// Test Flip with string types to cover both conversion branches
+func Test_KVMap_Flip_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewKVMapFrom(map[string]string{"key1": "val1", "key2": "val2"})
+		m.Flip()
+		t.Assert(m.Get("val1"), "key1")
+		t.Assert(m.Get("val2"), "key2")
+	})
+}
+
+// Test TypedNil with custom nil checker for pointers
+func Test_KVMap_TypedNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type Student struct {
+			Name string
+			Age  int
+		}
+		m1 := gmap.NewKVMap[int, *Student](true)
+		for i := 0; i < 10; i++ {
+			m1.GetOrSetFuncLock(i, func() *Student {
+				if i%2 == 0 {
+					return &Student{}
+				}
+				return nil
+			})
+		}
+		t.Assert(m1.Size(), 5)
+
+		m2 := gmap.NewKVMap[int, *Student](true)
+		m2.SetNilChecker(func(student *Student) bool {
+			return student == nil
+		})
+		for i := 0; i < 10; i++ {
+			m2.GetOrSetFuncLock(i, func() *Student {
+				if i%2 == 0 {
+					return &Student{}
+				}
+				return nil
+			})
+		}
+		t.Assert(m2.Size(), 5)
+	})
+}
+
+func Test_NewKVMapWithChecker_TypedNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type Student struct {
+			Name string
+			Age  int
+		}
+		m1 := gmap.NewKVMap[int, *Student](true)
+		for i := 0; i < 10; i++ {
+			m1.GetOrSetFuncLock(i, func() *Student {
+				if i%2 == 0 {
+					return &Student{}
+				}
+				return nil
+			})
+		}
+		t.Assert(m1.Size(), 5)
+
+		m2 := gmap.NewKVMapWithChecker[int, *Student](func(student *Student) bool {
+			return student == nil
+		}, true)
+		for i := 0; i < 10; i++ {
+			m2.GetOrSetFuncLock(i, func() *Student {
+				if i%2 == 0 {
+					return &Student{}
+				}
+				return nil
+			})
+		}
+		t.Assert(m2.Size(), 5)
+	})
+}
diff --git a/container/gmap/gmap_z_unit_list_k_v_map_race_test.go b/container/gmap/gmap_z_unit_list_k_v_map_race_test.go
new file mode 100644
index 000000000..5c5e869f1
--- /dev/null
+++ b/container/gmap/gmap_z_unit_list_k_v_map_race_test.go
@@ -0,0 +1,255 @@
+// 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 gmap_test
+
+import (
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+// Test_ListKVMap_GetOrSetFuncLock_Race tests the atomicity of GetOrSetFuncLock.
+// This test ensures that the callback function is only executed once even under
+// high concurrency, which verifies that the function holds the lock during the
+// entire check-and-set operation.
+func Test_ListKVMap_GetOrSetFuncLock_Race(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int](true)
+		key := "counter"
+		callCount := int32(0)
+		goroutines := 100
+
+		var wg sync.WaitGroup
+		wg.Add(goroutines)
+
+		// Start multiple goroutines trying to set the same key
+		for i := 0; i < goroutines; i++ {
+			go func() {
+				defer wg.Done()
+				m.GetOrSetFuncLock(key, func() int {
+					// Increment call count atomically
+					atomic.AddInt32(&callCount, 1)
+					// Simulate some work
+					time.Sleep(time.Microsecond)
+					return 100
+				})
+			}()
+		}
+
+		wg.Wait()
+
+		// The callback should only be called once because of proper locking
+		t.Assert(atomic.LoadInt32(&callCount), 1)
+		t.Assert(m.Get(key), 100)
+		t.Assert(m.Size(), 1)
+	})
+}
+
+// Test_ListKVMap_SetIfNotExistFuncLock_Race tests the atomicity of SetIfNotExistFuncLock.
+// This test ensures that only one goroutine can successfully set the value and
+// execute the callback function, even under high concurrency.
+func Test_ListKVMap_SetIfNotExistFuncLock_Race(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int](true)
+		key := "counter"
+		callCount := int32(0)
+		successCount := int32(0)
+		goroutines := 100
+
+		var wg sync.WaitGroup
+		wg.Add(goroutines)
+
+		// Start multiple goroutines trying to set the same key
+		for i := 0; i < goroutines; i++ {
+			go func() {
+				defer wg.Done()
+				success := m.SetIfNotExistFuncLock(key, func() int {
+					// Increment call count atomically
+					atomic.AddInt32(&callCount, 1)
+					// Simulate some work
+					time.Sleep(time.Microsecond)
+					return 200
+				})
+				if success {
+					atomic.AddInt32(&successCount, 1)
+				}
+			}()
+		}
+
+		wg.Wait()
+
+		// The callback should only be called once
+		t.Assert(atomic.LoadInt32(&callCount), 1)
+		// Only one goroutine should succeed
+		t.Assert(atomic.LoadInt32(&successCount), 1)
+		t.Assert(m.Get(key), 200)
+		t.Assert(m.Size(), 1)
+	})
+}
+
+// Test_ListKVMap_GetOrSetFuncLock_MultipleKeys tests GetOrSetFuncLock with different keys.
+// This ensures that operations on different keys don't interfere with each other.
+func Test_ListKVMap_GetOrSetFuncLock_MultipleKeys(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int](true)
+		keys := []string{"key1", "key2", "key3", "key4", "key5"}
+		callCounts := make([]int32, len(keys))
+		goroutines := 20
+
+		var wg sync.WaitGroup
+
+		// For each key, start multiple goroutines
+		for i, key := range keys {
+			keyIndex := i
+			for j := 0; j < goroutines; j++ {
+				wg.Add(1)
+				go func(idx int, k string) {
+					defer wg.Done()
+					m.GetOrSetFuncLock(k, func() int {
+						atomic.AddInt32(&callCounts[idx], 1)
+						time.Sleep(time.Microsecond)
+						return (idx + 1) * 100
+					})
+				}(keyIndex, key)
+			}
+		}
+
+		wg.Wait()
+
+		// Each key's callback should only be called once
+		for _, count := range callCounts {
+			t.Assert(atomic.LoadInt32(&count), 1)
+		}
+
+		// Verify all keys are set correctly
+		for i, key := range keys {
+			t.Assert(m.Get(key), (i+1)*100)
+		}
+		t.Assert(m.Size(), len(keys))
+	})
+}
+
+// Test_ListKVMap_SetIfNotExistFuncLock_MultipleKeys tests SetIfNotExistFuncLock with different keys.
+func Test_ListKVMap_SetIfNotExistFuncLock_MultipleKeys(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[int, string](true)
+		keys := []int{1, 2, 3, 4, 5}
+		callCounts := make([]int32, len(keys))
+		successCounts := make([]int32, len(keys))
+		goroutines := 20
+
+		var wg sync.WaitGroup
+
+		// For each key, start multiple goroutines
+		for i, key := range keys {
+			keyIndex := i
+			for j := 0; j < goroutines; j++ {
+				wg.Add(1)
+				go func(idx int, k int) {
+					defer wg.Done()
+					success := m.SetIfNotExistFuncLock(k, func() string {
+						atomic.AddInt32(&callCounts[idx], 1)
+						time.Sleep(time.Microsecond)
+						return gtest.DataContent()
+					})
+					if success {
+						atomic.AddInt32(&successCounts[idx], 1)
+					}
+				}(keyIndex, key)
+			}
+		}
+
+		wg.Wait()
+
+		// Each key's callback should only be called once
+		for _, count := range callCounts {
+			t.Assert(atomic.LoadInt32(&count), 1)
+		}
+
+		// Each key should have exactly one successful set
+		for _, count := range successCounts {
+			t.Assert(atomic.LoadInt32(&count), 1)
+		}
+
+		t.Assert(m.Size(), len(keys))
+	})
+}
+
+// Test_ListKVMap_GetOrSetFuncLock_ExistingKey tests behavior when key already exists.
+func Test_ListKVMap_GetOrSetFuncLock_ExistingKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int](true)
+		key := "existing"
+		m.Set(key, 999)
+
+		callCount := int32(0)
+		goroutines := 50
+
+		var wg sync.WaitGroup
+		wg.Add(goroutines)
+
+		for i := 0; i < goroutines; i++ {
+			go func() {
+				defer wg.Done()
+				val := m.GetOrSetFuncLock(key, func() int {
+					atomic.AddInt32(&callCount, 1)
+					return 123
+				})
+				// Should always get the existing value
+				t.Assert(val, 999)
+			}()
+		}
+
+		wg.Wait()
+
+		// Callback should never be called since key exists
+		t.Assert(atomic.LoadInt32(&callCount), 0)
+		t.Assert(m.Get(key), 999)
+	})
+}
+
+// Test_ListKVMap_SetIfNotExistFuncLock_ExistingKey tests behavior when key already exists.
+func Test_ListKVMap_SetIfNotExistFuncLock_ExistingKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int](true)
+		key := "existing"
+		m.Set(key, 888)
+
+		callCount := int32(0)
+		successCount := int32(0)
+		goroutines := 50
+
+		var wg sync.WaitGroup
+		wg.Add(goroutines)
+
+		for i := 0; i < goroutines; i++ {
+			go func() {
+				defer wg.Done()
+				success := m.SetIfNotExistFuncLock(key, func() int {
+					atomic.AddInt32(&callCount, 1)
+					return 456
+				})
+				if success {
+					atomic.AddInt32(&successCount, 1)
+				}
+			}()
+		}
+
+		wg.Wait()
+
+		// Callback should never be called since key exists
+		t.Assert(atomic.LoadInt32(&callCount), 0)
+		// No goroutine should succeed
+		t.Assert(atomic.LoadInt32(&successCount), 0)
+		// Original value should remain
+		t.Assert(m.Get(key), 888)
+	})
+}
diff --git a/container/gmap/gmap_z_unit_list_k_v_map_test.go b/container/gmap/gmap_z_unit_list_k_v_map_test.go
new file mode 100644
index 000000000..63e6fbc46
--- /dev/null
+++ b/container/gmap/gmap_z_unit_list_k_v_map_test.go
@@ -0,0 +1,1416 @@
+// 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 gmap_test
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+func Test_ListKVMap_NewListKVMap(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		t.Assert(m.Size(), 0)
+		t.Assert(m.IsEmpty(), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string](true)
+		t.Assert(m.Size(), 0)
+		t.Assert(m.IsEmpty(), true)
+	})
+}
+
+func Test_ListKVMap_NewListKVMapFrom(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		data := map[string]string{"a": "1", "b": "2"}
+		m := gmap.NewListKVMapFrom(data)
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := map[int]int{1: 10, 2: 20}
+		m := gmap.NewListKVMapFrom(data, true)
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Get(1), 10)
+		t.Assert(m.Get(2), 20)
+	})
+}
+
+func Test_ListKVMap_Set_Get(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		m.Set("a", "1")
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Size(), 1)
+
+		m.Set("b", "2")
+		t.Assert(m.Get("b"), "2")
+		t.Assert(m.Size(), 2)
+
+		// Set existing key
+		m.Set("a", "10")
+		t.Assert(m.Get("a"), "10")
+		t.Assert(m.Size(), 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[int, int]()
+		m.Set(1, 100)
+		m.Set(2, 200)
+		t.Assert(m.Get(1), 100)
+		t.Assert(m.Get(2), 200)
+	})
+}
+
+func Test_ListKVMap_Sets(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		m.Sets(map[string]string{"a": "1", "b": "2", "c": "3"})
+		t.Assert(m.Size(), 3)
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+		t.Assert(m.Get("c"), "3")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := map[string]string{"x": "10", "y": "20"}
+		m := gmap.NewListKVMapFrom(data)
+		m.Sets(map[string]string{"a": "1", "b": "2"})
+		t.Assert(m.Size(), 4)
+		t.Assert(m.Get("x"), "10")
+		t.Assert(m.Get("a"), "1")
+	})
+}
+
+func Test_ListKVMap_Search(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+
+		v, found := m.Search("a")
+		t.Assert(found, true)
+		t.Assert(v, "1")
+
+		v, found = m.Search("c")
+		t.Assert(found, false)
+		t.Assert(v, "")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[int, string]()
+		v, found := m.Search(1)
+		t.Assert(found, false)
+		t.Assert(v, "")
+	})
+}
+
+func Test_ListKVMap_Contains(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		t.Assert(m.Contains("a"), true)
+		t.Assert(m.Contains("b"), true)
+		t.Assert(m.Contains("c"), false)
+	})
+}
+
+func Test_ListKVMap_Remove(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		t.Assert(m.Size(), 2)
+
+		v := m.Remove("a")
+		t.Assert(v, "1")
+		t.Assert(m.Contains("a"), false)
+		t.Assert(m.Size(), 1)
+
+		v = m.Remove("c")
+		t.Assert(v, "")
+		t.Assert(m.Size(), 1)
+	})
+}
+
+func Test_ListKVMap_Removes(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		t.Assert(m.Size(), 3)
+
+		m.Removes([]string{"a", "c"})
+		t.Assert(m.Size(), 1)
+		t.Assert(m.Contains("a"), false)
+		t.Assert(m.Contains("c"), false)
+		t.Assert(m.Contains("b"), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		m.Removes([]string{"x", "y"})
+		t.Assert(m.Size(), 2)
+	})
+}
+
+func Test_ListKVMap_Pop(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		t.Assert(m.Size(), 2)
+
+		k, v := m.Pop()
+		t.AssertIN(k, []string{"a", "b"})
+		t.AssertIN(v, []string{"1", "2"})
+		t.Assert(m.Size(), 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		k, v := m.Pop()
+		t.Assert(k, "")
+		t.Assert(v, "")
+	})
+}
+
+func Test_ListKVMap_Pops(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		t.Assert(m.Size(), 3)
+
+		popped := m.Pops(2)
+		t.Assert(len(popped), 2)
+		t.Assert(m.Size(), 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		popped := m.Pops(-1)
+		t.Assert(len(popped), 3)
+		t.Assert(m.Size(), 0)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		popped := m.Pops(10)
+		t.Assert(len(popped), 2)
+		t.Assert(m.Size(), 0)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		popped := m.Pops(1)
+		t.AssertNil(popped)
+	})
+}
+
+func Test_ListKVMap_Keys(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		keys := m.Keys()
+		t.Assert(len(keys), 3)
+		t.AssertIN("a", keys)
+		t.AssertIN("b", keys)
+		t.AssertIN("c", keys)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[int, string]()
+		keys := m.Keys()
+		t.Assert(len(keys), 0)
+	})
+}
+
+func Test_ListKVMap_Values(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		values := m.Values()
+		t.Assert(len(values), 3)
+		t.AssertIN("1", values)
+		t.AssertIN("2", values)
+		t.AssertIN("3", values)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int]()
+		values := m.Values()
+		t.Assert(len(values), 0)
+	})
+}
+
+func Test_ListKVMap_Size(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		t.Assert(m.Size(), 0)
+
+		m.Set("a", "1")
+		t.Assert(m.Size(), 1)
+
+		m.Set("b", "2")
+		t.Assert(m.Size(), 2)
+
+		m.Remove("a")
+		t.Assert(m.Size(), 1)
+
+		m.Clear()
+		t.Assert(m.Size(), 0)
+	})
+}
+
+func Test_ListKVMap_IsEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		t.Assert(m.IsEmpty(), true)
+
+		m.Set("a", "1")
+		t.Assert(m.IsEmpty(), false)
+
+		m.Remove("a")
+		t.Assert(m.IsEmpty(), true)
+	})
+}
+
+func Test_ListKVMap_Clear(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		t.Assert(m.Size(), 3)
+
+		m.Clear()
+		t.Assert(m.Size(), 0)
+		t.Assert(m.IsEmpty(), true)
+		t.Assert(m.Get("a"), "")
+	})
+}
+
+func Test_ListKVMap_Map(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		data := m.Map()
+		t.Assert(data["a"], "1")
+		t.Assert(data["b"], "2")
+		t.Assert(len(data), 2)
+	})
+}
+
+func Test_ListKVMap_MapStrAny(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]int{"a": 1, "b": 2})
+		data := m.MapStrAny()
+		t.Assert(len(data), 2)
+		t.Assert(data["a"], 1)
+		t.Assert(data["b"], 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[int]string{1: "a", 2: "b"})
+		data := m.MapStrAny()
+		t.Assert(len(data), 2)
+		t.Assert(data["1"], "a")
+		t.Assert(data["2"], "b")
+	})
+}
+
+func Test_ListKVMap_FilterEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "", "b": "2", "c": "3"})
+		t.Assert(m.Size(), 3)
+
+		m.FilterEmpty()
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Contains("a"), false)
+		t.Assert(m.Contains("b"), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]int{"a": 0, "b": 1, "c": 2})
+		t.Assert(m.Size(), 3)
+
+		m.FilterEmpty()
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Contains("a"), false)
+	})
+}
+
+func Test_ListKVMap_GetOrSet(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+
+		v := m.GetOrSet("a", "1")
+		t.Assert(v, "1")
+		t.Assert(m.Get("a"), "1")
+
+		v = m.GetOrSet("a", "10")
+		t.Assert(v, "1")
+		t.Assert(m.Get("a"), "1")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]int{"a": 10})
+
+		v := m.GetOrSet("a", 20)
+		t.Assert(v, 10)
+
+		v = m.GetOrSet("b", 30)
+		t.Assert(v, 30)
+		t.Assert(m.Get("b"), 30)
+	})
+}
+
+func Test_ListKVMap_GetOrSetFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+
+		v := m.GetOrSetFunc("a", func() string { return "1" })
+		t.Assert(v, "1")
+
+		v = m.GetOrSetFunc("a", func() string { return "10" })
+		t.Assert(v, "1")
+
+		v = m.GetOrSetFunc("b", func() string { return "2" })
+		t.Assert(v, "2")
+	})
+}
+
+func Test_ListKVMap_GetOrSetFuncLock(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int]()
+		counter := 0
+
+		v := m.GetOrSetFuncLock("a", func() int {
+			counter++
+			return 10
+		})
+		t.Assert(v, 10)
+		t.Assert(counter, 1)
+
+		v = m.GetOrSetFuncLock("a", func() int {
+			counter++
+			return 20
+		})
+		t.Assert(v, 10)
+		t.Assert(counter, 1)
+	})
+}
+
+func Test_ListKVMap_SetIfNotExist(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+
+		ok := m.SetIfNotExist("a", "1")
+		t.Assert(ok, true)
+		t.Assert(m.Get("a"), "1")
+
+		ok = m.SetIfNotExist("a", "10")
+		t.Assert(ok, false)
+		t.Assert(m.Get("a"), "1")
+	})
+}
+
+func Test_ListKVMap_SetIfNotExistFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int]()
+
+		ok := m.SetIfNotExistFunc("a", func() int { return 10 })
+		t.Assert(ok, true)
+		t.Assert(m.Get("a"), 10)
+
+		ok = m.SetIfNotExistFunc("a", func() int { return 20 })
+		t.Assert(ok, false)
+		t.Assert(m.Get("a"), 10)
+	})
+}
+
+func Test_ListKVMap_SetIfNotExistFuncLock(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		counter := 0
+
+		ok := m.SetIfNotExistFuncLock("a", func() string {
+			counter++
+			return "1"
+		})
+		t.Assert(ok, true)
+		t.Assert(counter, 1)
+
+		ok = m.SetIfNotExistFuncLock("a", func() string {
+			counter++
+			return "2"
+		})
+		t.Assert(ok, false)
+		t.Assert(counter, 1)
+	})
+}
+
+func Test_ListKVMap_GetVar(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+
+		v := m.GetVar("a")
+		t.AssertNE(v, nil)
+		t.Assert(v.Val(), "1")
+
+		v = m.GetVar("c")
+		t.Assert(v.Val(), nil)
+	})
+}
+
+func Test_ListKVMap_GetVarOrSet(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+
+		v := m.GetVarOrSet("a", "1")
+		t.AssertNE(v, nil)
+		t.Assert(v.Val(), "1")
+
+		v = m.GetVarOrSet("a", "10")
+		t.Assert(v.Val(), "1")
+	})
+}
+
+func Test_ListKVMap_GetVarOrSetFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int]()
+
+		v := m.GetVarOrSetFunc("a", func() int { return 10 })
+		t.AssertNE(v, nil)
+		t.Assert(v.Val(), 10)
+
+		v = m.GetVarOrSetFunc("a", func() int { return 20 })
+		t.Assert(v.Val(), 10)
+	})
+}
+
+func Test_ListKVMap_GetVarOrSetFuncLock(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+
+		v := m.GetVarOrSetFuncLock("a", func() string { return "1" })
+		t.AssertNE(v, nil)
+		t.Assert(v.Val(), "1")
+
+		v = m.GetVarOrSetFuncLock("a", func() string { return "10" })
+		t.Assert(v.Val(), "1")
+	})
+}
+
+func Test_ListKVMap_Iterator(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		data := map[string]string{"a": "1", "b": "2", "c": "3"}
+		m := gmap.NewListKVMapFrom(data)
+
+		count := 0
+		m.Iterator(func(k string, v string) bool {
+			t.Assert(data[k], v)
+			count++
+			return true
+		})
+		t.Assert(count, 3)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[int]string{1: "a", 2: "b", 3: "c"})
+
+		count := 0
+		m.Iterator(func(k int, v string) bool {
+			count++
+			return count < 2
+		})
+		t.Assert(count, 2)
+	})
+}
+
+func Test_ListKVMap_IteratorAsc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		m.Set("k1", "v1")
+		m.Set("k2", "v2")
+		m.Set("k3", "v3")
+
+		var keys []string
+		var values []string
+		m.IteratorAsc(func(k string, v string) bool {
+			keys = append(keys, k)
+			values = append(values, v)
+			return true
+		})
+		t.Assert(keys, g.Slice{"k1", "k2", "k3"})
+		t.Assert(values, g.Slice{"v1", "v2", "v3"})
+	})
+}
+
+func Test_ListKVMap_IteratorDesc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		m.Set("k1", "v1")
+		m.Set("k2", "v2")
+		m.Set("k3", "v3")
+
+		var keys []string
+		var values []string
+		m.IteratorDesc(func(k string, v string) bool {
+			keys = append(keys, k)
+			values = append(values, v)
+			return true
+		})
+		t.Assert(keys, g.Slice{"k3", "k2", "k1"})
+		t.Assert(values, g.Slice{"v3", "v2", "v1"})
+	})
+}
+
+func Test_ListKVMap_Replace(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		t.Assert(m.Size(), 2)
+
+		m.Replace(map[string]string{"x": "10", "y": "20", "z": "30"})
+		t.Assert(m.Size(), 3)
+		t.Assert(m.Get("a"), "")
+		t.Assert(m.Get("x"), "10")
+	})
+}
+
+func Test_ListKVMap_Clone(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		m2 := m.Clone()
+
+		t.Assert(m2.Get("a"), "1")
+		t.Assert(m2.Get("b"), "2")
+		t.Assert(m2.Size(), 2)
+
+		m.Set("a", "10")
+		t.Assert(m2.Get("a"), "1")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]int{"a": 1, "b": 2}, false)
+		m2 := m.Clone(true)
+
+		t.Assert(m2.Size(), 2)
+	})
+}
+
+func Test_ListKVMap_Flip(t *testing.T) {
+	// Test with same type for key and value (string -> string)
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		err := m.Flip()
+		t.AssertNil(err)
+
+		t.Assert(m.Get("1"), "a")
+		t.Assert(m.Get("2"), "b")
+		t.Assert(m.Get("3"), "c")
+	})
+
+	// Test with same type for key and value (int -> int)
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[int]int{1: 10, 2: 20})
+		err := m.Flip()
+		t.AssertNil(err)
+
+		t.Assert(m.Get(10), 1)
+		t.Assert(m.Get(20), 2)
+	})
+}
+
+func Test_ListKVMap_Merge(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewListKVMapFrom(map[string]string{"a": "1"})
+		m2 := gmap.NewListKVMapFrom(map[string]string{"b": "2", "c": "3"})
+
+		m1.Merge(m2)
+		t.Assert(m1.Size(), 3)
+		t.Assert(m1.Get("a"), "1")
+		t.Assert(m1.Get("b"), "2")
+		t.Assert(m1.Get("c"), "3")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewListKVMap[string, int]()
+		m2 := gmap.NewListKVMapFrom(map[string]int{"a": 10, "b": 20})
+
+		m1.Merge(m2)
+		t.Assert(m1.Size(), 2)
+		t.Assert(m1.Get("a"), 10)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m1 := gmap.NewListKVMapFrom(map[string]string{"a": "1"})
+		m2 := gmap.NewListKVMapFrom(map[string]string{"a": "10", "b": "2"})
+
+		m1.Merge(m2)
+		t.Assert(m1.Get("a"), "10")
+	})
+}
+
+func Test_ListKVMap_Merge_Self(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		m.Merge(m)
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+	})
+}
+
+func Test_ListKVMap_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1"})
+		s := m.String()
+		t.AssertNE(s, "")
+		t.AssertIN("a", s)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		var m *gmap.ListKVMap[string, string]
+		s := m.String()
+		t.Assert(s, "")
+	})
+}
+
+func Test_ListKVMap_MarshalJSON(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int]()
+		m.Set("a", 1)
+		m.Set("b", 2)
+		b, err := json.Marshal(m)
+		t.AssertNil(err)
+		t.AssertNE(b, nil)
+
+		var data map[string]int
+		err = json.Unmarshal(b, &data)
+		t.AssertNil(err)
+		t.Assert(data["a"], 1)
+		t.Assert(data["b"], 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		b, err := m.MarshalJSON()
+		t.AssertNil(err)
+		t.Assert(string(b), "{}")
+	})
+}
+
+func Test_ListKVMap_UnmarshalJSON(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int]()
+		data := []byte(`{"a":1,"b":2,"c":3}`)
+
+		err := json.UnmarshalUseNumber(data, m)
+		t.AssertNil(err)
+		t.Assert(m.Get("a"), 1)
+		t.Assert(m.Get("b"), 2)
+		t.Assert(m.Get("c"), 3)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		var m gmap.ListKVMap[string, string]
+		data := []byte(`{"x":"10","y":"20"}`)
+
+		err := json.UnmarshalUseNumber(data, &m)
+		t.AssertNil(err)
+		t.Assert(m.Get("x"), "10")
+		t.Assert(m.Get("y"), "20")
+	})
+}
+
+func Test_ListKVMap_UnmarshalValue(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		err := m.UnmarshalValue(map[string]any{
+			"a": "1",
+			"b": "2",
+		})
+		t.AssertNil(err)
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+	})
+}
+
+func Test_ListKVMap_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string][]string{
+			"a": {"1", "2"},
+			"b": {"3", "4"},
+		})
+
+		n := m.DeepCopy().(*gmap.ListKVMap[string, []string])
+		t.Assert(n.Size(), 2)
+		t.Assert(n.Get("a"), []string{"1", "2"})
+
+		// Modifying original doesn't affect copy
+		m.Get("a")[0] = "10"
+		t.Assert(n.Get("a")[0], "1")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		var m *gmap.ListKVMap[string, int]
+		n := m.DeepCopy()
+		t.AssertNil(n)
+	})
+}
+
+func Test_ListKVMap_Order(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		m.Set("k1", "v1")
+		m.Set("k2", "v2")
+		m.Set("k3", "v3")
+		t.Assert(m.Keys(), g.Slice{"k1", "k2", "k3"})
+		t.Assert(m.Values(), g.Slice{"v1", "v2", "v3"})
+	})
+}
+
+func Test_ListKVMap_Json_Sequence(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int32]()
+		for i := 'z'; i >= 'a'; i-- {
+			m.Set(string(i), i)
+		}
+		b, err := json.Marshal(m)
+		t.AssertNil(err)
+		t.Assert(b, `{"z":122,"y":121,"x":120,"w":119,"v":118,"u":117,"t":116,"s":115,"r":114,"q":113,"p":112,"o":111,"n":110,"m":109,"l":108,"k":107,"j":106,"i":105,"h":104,"g":103,"f":102,"e":101,"d":100,"c":99,"b":98,"a":97}`)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int32]()
+		for i := 'a'; i <= 'z'; i++ {
+			m.Set(string(i), i)
+		}
+		b, err := json.Marshal(m)
+		t.AssertNil(err)
+		t.Assert(b, `{"a":97,"b":98,"c":99,"d":100,"e":101,"f":102,"g":103,"h":104,"i":105,"j":106,"k":107,"l":108,"m":109,"n":110,"o":111,"p":112,"q":113,"r":114,"s":115,"t":116,"u":117,"v":118,"w":119,"x":120,"y":121,"z":122}`)
+	})
+}
+
+// Test Set with nil data
+func Test_ListKVMap_Set_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		m.Set("a", "1")
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Size(), 1)
+	})
+}
+
+// Test Sets with nil data
+func Test_ListKVMap_Sets_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		m.Sets(map[string]string{"a": "1", "b": "2"})
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+		t.Assert(m.Size(), 2)
+	})
+}
+
+// Test GetOrSet with nil value (using any type)
+func Test_ListKVMap_GetOrSet_NilValue(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, any]()
+		v := m.GetOrSet("a", nil)
+		t.Assert(v, nil)
+		// nil interface value should not be stored
+		t.Assert(m.Contains("a"), false)
+	})
+}
+
+// Test Search with nil data
+func Test_ListKVMap_Search_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		v, found := m.Search("a")
+		t.Assert(found, false)
+		t.Assert(v, "")
+	})
+}
+
+// Test Get with nil data
+func Test_ListKVMap_Get_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, int](nil)
+		v := m.Get("a")
+		t.Assert(v, 0)
+	})
+}
+
+// Test Contains with nil data
+func Test_ListKVMap_Contains_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		t.Assert(m.Contains("a"), false)
+	})
+}
+
+// Test Remove with nil data
+func Test_ListKVMap_Remove_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		v := m.Remove("a")
+		t.Assert(v, "")
+	})
+}
+
+// Test Removes with nil data
+func Test_ListKVMap_Removes_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		m.Removes([]string{"a", "b"})
+		t.Assert(m.Size(), 0)
+	})
+}
+
+// Test Pops with size 0
+func Test_ListKVMap_Pops_ZeroSize(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		popped := m.Pops(0)
+		t.AssertNil(popped)
+		t.Assert(m.Size(), 2)
+	})
+}
+
+// Test Iterator early break
+func Test_ListKVMap_Iterator_Break(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2", "c": "3"})
+		count := 0
+		m.Iterator(func(k string, v string) bool {
+			count++
+			return false // Break immediately
+		})
+		t.Assert(count, 1)
+	})
+}
+
+// Test IteratorAsc with nil list
+func Test_ListKVMap_IteratorAsc_NilList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		count := 0
+		m.IteratorAsc(func(k string, v string) bool {
+			count++
+			return true
+		})
+		t.Assert(count, 0)
+	})
+}
+
+// Test IteratorDesc with nil list
+func Test_ListKVMap_IteratorDesc_NilList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		count := 0
+		m.IteratorDesc(func(k string, v string) bool {
+			count++
+			return true
+		})
+		t.Assert(count, 0)
+	})
+}
+
+// Test Map with nil list
+func Test_ListKVMap_Map_NilList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		data := m.Map()
+		t.Assert(len(data), 0)
+	})
+}
+
+// Test MapStrAny with nil list
+func Test_ListKVMap_MapStrAny_NilList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		data := m.MapStrAny()
+		t.Assert(len(data), 0)
+	})
+}
+
+// Test FilterEmpty with nil list
+func Test_ListKVMap_FilterEmpty_NilList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		m.FilterEmpty()
+		t.Assert(m.Size(), 0)
+	})
+}
+
+// Test Keys with nil list
+func Test_ListKVMap_Keys_NilList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		keys := m.Keys()
+		t.Assert(len(keys), 0)
+	})
+}
+
+// Test Values with nil list
+func Test_ListKVMap_Values_NilList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		values := m.Values()
+		t.Assert(len(values), 0)
+	})
+}
+
+// Test DeepCopy with nil list
+func Test_ListKVMap_DeepCopy_NilList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		n := m.DeepCopy().(*gmap.ListKVMap[string, string])
+		t.Assert(n.Size(), 0)
+	})
+}
+
+// Concurrent safety tests
+func Test_ListKVMap_Concurrent_Safe(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int](true)
+		ch := make(chan int, 10)
+
+		// Concurrent writes
+		for i := 0; i < 10; i++ {
+			go func(idx int) {
+				m.Set(gconv.String(idx), idx)
+				ch <- 1
+			}(i)
+		}
+
+		for i := 0; i < 10; i++ {
+			<-ch
+		}
+
+		t.Assert(m.Size(), 10)
+	})
+}
+
+func Test_ListKVMap_Concurrent_RW(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int](true)
+		m.Sets(map[string]int{"a": 1, "b": 2, "c": 3})
+
+		ch := make(chan int, 20)
+
+		// Concurrent reads and writes
+		for i := 0; i < 10; i++ {
+			go func() {
+				_ = m.Get("a")
+				ch <- 1
+			}()
+		}
+
+		for i := 0; i < 10; i++ {
+			go func(idx int) {
+				m.Set(gconv.String(idx), idx)
+				ch <- 1
+			}(i)
+		}
+
+		for i := 0; i < 20; i++ {
+			<-ch
+		}
+
+		t.Assert(m.Size(), 13)
+	})
+}
+
+// Test concurrent GetOrSet
+func Test_ListKVMap_Concurrent_GetOrSet(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int](true)
+		ch := make(chan int, 100)
+
+		for i := 0; i < 100; i++ {
+			go func(idx int) {
+				m.GetOrSet("key", idx)
+				ch <- 1
+			}(i)
+		}
+
+		for i := 0; i < 100; i++ {
+			<-ch
+		}
+
+		// Only one value should be set
+		t.Assert(m.Size(), 1)
+		t.Assert(m.Contains("key"), true)
+	})
+}
+
+// Test concurrent SetIfNotExist
+func Test_ListKVMap_Concurrent_SetIfNotExist(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int](true)
+		successCount := 0
+		ch := make(chan bool, 100)
+
+		for i := 0; i < 100; i++ {
+			go func(idx int) {
+				ok := m.SetIfNotExist("key", idx)
+				ch <- ok
+			}(i)
+		}
+
+		for i := 0; i < 100; i++ {
+			if <-ch {
+				successCount++
+			}
+		}
+
+		// Only one goroutine should succeed
+		t.Assert(successCount, 1)
+		t.Assert(m.Size(), 1)
+	})
+}
+
+// Test concurrent GetOrSetFunc
+func Test_ListKVMap_Concurrent_GetOrSetFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int](true)
+		ch := make(chan int, 100)
+
+		for i := 0; i < 100; i++ {
+			go func(idx int) {
+				m.GetOrSetFunc("key", func() int {
+					return idx
+				})
+				ch <- 1
+			}(i)
+		}
+
+		for i := 0; i < 100; i++ {
+			<-ch
+		}
+
+		t.Assert(m.Size(), 1)
+	})
+}
+
+// Test concurrent GetOrSetFuncLock
+func Test_ListKVMap_Concurrent_GetOrSetFuncLock(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int](true)
+		ch := make(chan int, 100)
+
+		for i := 0; i < 100; i++ {
+			go func(idx int) {
+				m.GetOrSetFuncLock("key", func() int {
+					return idx
+				})
+				ch <- 1
+			}(i)
+		}
+
+		for i := 0; i < 100; i++ {
+			<-ch
+		}
+
+		t.Assert(m.Size(), 1)
+	})
+}
+
+// Test concurrent access to doSetWithLockCheck
+func Test_ListKVMap_DoSetWithLockCheck_Concurrent(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int](true)
+		var wg sync.WaitGroup
+		results := make([]int, 100)
+
+		for i := 0; i < 100; i++ {
+			wg.Add(1)
+			go func(idx int) {
+				defer wg.Done()
+				v := m.GetOrSet("key", idx)
+				results[idx] = v
+			}(i)
+		}
+		wg.Wait()
+
+		// All results should be the same (the first value that was set)
+		firstValue := results[0]
+		for _, v := range results {
+			t.Assert(v, firstValue)
+		}
+	})
+}
+
+// Test UnmarshalJSON with invalid JSON
+func Test_ListKVMap_UnmarshalJSON_InvalidJSON(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int]()
+		err := m.UnmarshalJSON([]byte(`{invalid json}`))
+		t.AssertNE(err, nil)
+	})
+}
+
+// Test MarshalJSON error handling
+func Test_ListKVMap_MarshalJSON_Error(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, string]()
+		m.Set("a", "1")
+		b, err := m.MarshalJSON()
+		t.AssertNil(err)
+		t.Assert(string(b), `{"a":"1"}`)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		var m gmap.ListKVMap[int, int]
+		m.Set(1, 10)
+		b, err := json.Marshal(m)
+		t.AssertNil(err)
+		t.Assert(string(b), `{"1":10}`)
+	})
+}
+
+// Test empty map operations
+func Test_ListKVMap_EmptyMapOperations(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int]()
+
+		// Test Keys on empty map
+		keys := m.Keys()
+		t.Assert(len(keys), 0)
+
+		// Test Values on empty map
+		values := m.Values()
+		t.Assert(len(values), 0)
+
+		// Test MapStrAny on empty map
+		strAny := m.MapStrAny()
+		t.Assert(len(strAny), 0)
+	})
+}
+
+// Test FilterEmpty with various empty values
+func Test_ListKVMap_FilterEmpty_Various(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, any]()
+		m.Set("nil", nil)
+		m.Set("zero", 0)
+		m.Set("empty_string", "")
+		m.Set("false", false)
+		m.Set("valid", "value")
+		m.Set("empty_slice", []int{})
+		m.Set("empty_map", map[string]int{})
+
+		t.Assert(m.Size(), 7)
+		m.FilterEmpty()
+		t.Assert(m.Size(), 1)
+		t.Assert(m.Contains("valid"), true)
+	})
+}
+
+// Test Clone with different safe modes
+func Test_ListKVMap_Clone_SafeMode(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Clone unsafe map to safe
+		m := gmap.NewListKVMapFrom(map[string]int{"a": 1}, false)
+		m2 := m.Clone(true)
+		t.Assert(m2.Get("a"), 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Clone safe map to unsafe
+		m := gmap.NewListKVMapFrom(map[string]int{"a": 1}, true)
+		m2 := m.Clone(false)
+		t.Assert(m2.Get("a"), 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Clone with inherited safe mode
+		m := gmap.NewListKVMapFrom(map[string]int{"a": 1}, true)
+		m2 := m.Clone()
+		t.Assert(m2.Get("a"), 1)
+	})
+}
+
+// Test SetIfNotExistFunc returning false when key exists
+func Test_ListKVMap_SetIfNotExistFunc_KeyExists(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, int]()
+		m.Set("a", 1)
+
+		called := false
+		ok := m.SetIfNotExistFunc("a", func() int {
+			called = true
+			return 2
+		})
+		t.Assert(ok, false)
+		t.Assert(called, false) // Function should not be called if key exists
+		t.Assert(m.Get("a"), 1)
+	})
+}
+
+// Test struct with ListKVMap for UnmarshalValue
+func Test_ListKVMap_UnmarshalValue_Struct(t *testing.T) {
+	type V struct {
+		Name string
+		Map  *gmap.ListKVMap[string, string]
+	}
+	// JSON
+	gtest.C(t, func(t *gtest.T) {
+		var v *V
+		err := gconv.Struct(map[string]any{
+			"name": "john",
+			"map":  []byte(`{"1":"v1","2":"v2"}`),
+		}, &v)
+		t.AssertNil(err)
+		t.Assert(v.Name, "john")
+		t.Assert(v.Map.Size(), 2)
+		t.Assert(v.Map.Get("1"), "v1")
+		t.Assert(v.Map.Get("2"), "v2")
+	})
+	// Map
+	gtest.C(t, func(t *gtest.T) {
+		var v *V
+		err := gconv.Struct(map[string]any{
+			"name": "john",
+			"map": g.MapStrStr{
+				"1": "v1",
+				"2": "v2",
+			},
+		}, &v)
+		t.AssertNil(err)
+		t.Assert(v.Name, "john")
+		t.Assert(v.Map.Size(), 2)
+		t.Assert(v.Map.Get("1"), "v1")
+		t.Assert(v.Map.Get("2"), "v2")
+	})
+}
+
+// Test GetOrSetFuncLock with nil data
+func Test_ListKVMap_GetOrSetFuncLock_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		v := m.GetOrSetFuncLock("a", func() string { return "1" })
+		t.Assert(v, "1")
+		t.Assert(m.Get("a"), "1")
+	})
+
+	// Test with nil value (using any type)
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMap[string, any]()
+		v := m.GetOrSetFuncLock("a", func() any { return nil })
+		t.Assert(v, nil)
+		// nil interface value should not be stored
+		t.Assert(m.Contains("a"), false)
+	})
+}
+
+// Test SetIfNotExistFuncLock with nil data
+func Test_ListKVMap_SetIfNotExistFuncLock_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		ok := m.SetIfNotExistFuncLock("a", func() string { return "1" })
+		t.Assert(ok, true)
+		t.Assert(m.Get("a"), "1")
+	})
+}
+
+// Test Merge with nil data
+func Test_ListKVMap_Merge_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		m2 := gmap.NewListKVMapFrom(map[string]string{"a": "1", "b": "2"})
+		m.Merge(m2)
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+	})
+}
+
+// Test UnmarshalJSON with nil data
+func Test_ListKVMap_UnmarshalJSON_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		err := m.UnmarshalJSON([]byte(`{"a":"1","b":"2"}`))
+		t.AssertNil(err)
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+	})
+}
+
+// Test UnmarshalValue with nil data
+func Test_ListKVMap_UnmarshalValue_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListKVMapFrom[string, string](nil)
+		err := m.UnmarshalValue(map[string]any{"a": "1", "b": "2"})
+		t.AssertNil(err)
+		t.Assert(m.Size(), 2)
+		t.Assert(m.Get("a"), "1")
+		t.Assert(m.Get("b"), "2")
+	})
+}
+
+// Test typed nil values
+func Test_ListKVMap_TypedNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type Student struct {
+			Name string
+			Age  int
+		}
+		m1 := gmap.NewListKVMap[int, *Student](true)
+		for i := 0; i < 10; i++ {
+			m1.GetOrSetFuncLock(i, func() *Student {
+				if i%2 == 0 {
+					return &Student{}
+				}
+				return nil
+			})
+		}
+		t.Assert(m1.Size(), 5)
+
+		m2 := gmap.NewListKVMap[int, *Student](true)
+		m2.SetNilChecker(func(student *Student) bool {
+			return student == nil
+		})
+		for i := 0; i < 10; i++ {
+			m2.GetOrSetFuncLock(i, func() *Student {
+				if i%2 == 0 {
+					return &Student{}
+				}
+				return nil
+			})
+		}
+		t.Assert(m2.Size(), 5)
+	})
+}
+
+func Test_NewListKVMapWithChecker_TypedNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type Student struct {
+			Name string
+			Age  int
+		}
+		m1 := gmap.NewListKVMap[int, *Student](true)
+		for i := 0; i < 10; i++ {
+			m1.GetOrSetFuncLock(i, func() *Student {
+				if i%2 == 0 {
+					return &Student{}
+				}
+				return nil
+			})
+		}
+		t.Assert(m1.Size(), 5)
+
+		m2 := gmap.NewListKVMapWithChecker[int, *Student](func(student *Student) bool {
+			return student == nil
+		}, true)
+		for i := 0; i < 10; i++ {
+			m2.GetOrSetFuncLock(i, func() *Student {
+				if i%2 == 0 {
+					return &Student{}
+				}
+				return nil
+			})
+		}
+		t.Assert(m2.Size(), 5)
+	})
+}
diff --git a/container/gmap/gmap_z_unit_list_map_test.go b/container/gmap/gmap_z_unit_list_map_test.go
index c8a6074bf..06271cbf8 100644
--- a/container/gmap/gmap_z_unit_list_map_test.go
+++ b/container/gmap/gmap_z_unit_list_map_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gmap/gmap_z_unit_tree_map_test.go b/container/gmap/gmap_z_unit_tree_map_test.go
index 741c31286..18d8de90f 100644
--- a/container/gmap/gmap_z_unit_tree_map_test.go
+++ b/container/gmap/gmap_z_unit_tree_map_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test
diff --git a/container/gpool/gpool.go b/container/gpool/gpool.go
index f6b584548..85bc157e3 100644
--- a/container/gpool/gpool.go
+++ b/container/gpool/gpool.go
@@ -8,41 +8,19 @@
 package gpool
 
 import (
-	"context"
 	"time"
-
-	"github.com/gogf/gf/v2/container/glist"
-	"github.com/gogf/gf/v2/container/gtype"
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/os/gtime"
-	"github.com/gogf/gf/v2/os/gtimer"
 )
 
 // Pool is an Object-Reusable Pool.
 type Pool struct {
-	list    *glist.List         // Available/idle items list.
-	closed  *gtype.Bool         // Whether the pool is closed.
-	TTL     time.Duration       // Time To Live for pool items.
-	NewFunc func() (any, error) // Callback function to create pool item.
-	// ExpireFunc is the function for expired items destruction.
-	// This function needs to be defined when the pool items
-	// need to perform additional destruction operations.
-	// Eg: net.Conn, os.File, etc.
-	ExpireFunc func(any)
-}
-
-// Pool item.
-type poolItem struct {
-	value    any   // Item value.
-	expireAt int64 // Expire timestamp in milliseconds.
+	*TPool[any]
 }
 
 // NewFunc Creation function for object.
-type NewFunc func() (any, error)
+type NewFunc = TPoolNewFunc[any]
 
 // ExpireFunc Destruction function for object.
-type ExpireFunc func(any)
+type ExpireFunc = TPoolExpireFunc[any]
 
 // New creates and returns a new object pool.
 // To ensure execution efficiency, the expiration time cannot be modified once it is set.
@@ -52,134 +30,40 @@ type ExpireFunc func(any)
 // ttl < 0 : immediate expired after use;
 // ttl > 0 : timeout expired;
 func New(ttl time.Duration, newFunc NewFunc, expireFunc ...ExpireFunc) *Pool {
-	r := &Pool{
-		list:    glist.New(true),
-		closed:  gtype.NewBool(),
-		TTL:     ttl,
-		NewFunc: newFunc,
+	return &Pool{
+		TPool: NewTPool(ttl, newFunc, expireFunc...),
 	}
-	if len(expireFunc) > 0 {
-		r.ExpireFunc = expireFunc[0]
-	}
-	gtimer.AddSingleton(context.Background(), time.Second, r.checkExpireItems)
-	return r
 }
 
 // Put puts an item to pool.
 func (p *Pool) Put(value any) error {
-	if p.closed.Val() {
-		return gerror.NewCode(gcode.CodeInvalidOperation, "pool is closed")
-	}
-	item := &poolItem{
-		value: value,
-	}
-	if p.TTL == 0 {
-		item.expireAt = 0
-	} else {
-		// As for Golang version < 1.13, there's no method Milliseconds for time.Duration.
-		// So we need calculate the milliseconds using its nanoseconds value.
-		item.expireAt = gtime.TimestampMilli() + p.TTL.Nanoseconds()/1000000
-	}
-	p.list.PushBack(item)
-	return nil
+	return p.TPool.Put(value)
 }
 
 // MustPut puts an item to pool, it panics if any error occurs.
 func (p *Pool) MustPut(value any) {
-	if err := p.Put(value); err != nil {
-		panic(err)
-	}
+	p.TPool.MustPut(value)
 }
 
 // Clear clears pool, which means it will remove all items from pool.
 func (p *Pool) Clear() {
-	if p.ExpireFunc != nil {
-		for {
-			if r := p.list.PopFront(); r != nil {
-				p.ExpireFunc(r.(*poolItem).value)
-			} else {
-				break
-			}
-		}
-	} else {
-		p.list.RemoveAll()
-	}
+	p.TPool.Clear()
 }
 
 // Get picks and returns an item from pool. If the pool is empty and NewFunc is defined,
 // it creates and returns one from NewFunc.
 func (p *Pool) Get() (any, error) {
-	for !p.closed.Val() {
-		if r := p.list.PopFront(); r != nil {
-			f := r.(*poolItem)
-			if f.expireAt == 0 || f.expireAt > gtime.TimestampMilli() {
-				return f.value, nil
-			} else if p.ExpireFunc != nil {
-				// TODO: move expire function calling asynchronously out from `Get` operation.
-				p.ExpireFunc(f.value)
-			}
-		} else {
-			break
-		}
-	}
-	if p.NewFunc != nil {
-		return p.NewFunc()
-	}
-	return nil, gerror.NewCode(gcode.CodeInvalidOperation, "pool is empty")
+	return p.TPool.Get()
 }
 
 // Size returns the count of available items of pool.
 func (p *Pool) Size() int {
-	return p.list.Len()
+	return p.TPool.Size()
 }
 
 // Close closes the pool. If `p` has ExpireFunc,
 // then it automatically closes all items using this function before it's closed.
 // Commonly you do not need to call this function manually.
 func (p *Pool) Close() {
-	p.closed.Set(true)
-}
-
-// checkExpire removes expired items from pool in every second.
-func (p *Pool) checkExpireItems(ctx context.Context) {
-	if p.closed.Val() {
-		// If p has ExpireFunc,
-		// then it must close all items using this function.
-		if p.ExpireFunc != nil {
-			for {
-				if r := p.list.PopFront(); r != nil {
-					p.ExpireFunc(r.(*poolItem).value)
-				} else {
-					break
-				}
-			}
-		}
-		gtimer.Exit()
-	}
-	// All items do not expire.
-	if p.TTL == 0 {
-		return
-	}
-	// The latest item expire timestamp in milliseconds.
-	var latestExpire int64 = -1
-	// Retrieve the current timestamp in milliseconds, it expires the items
-	// by comparing with this timestamp. It is not accurate comparison for
-	// every item expired, but high performance.
-	var timestampMilli = gtime.TimestampMilli()
-	for latestExpire <= timestampMilli {
-		if r := p.list.PopFront(); r != nil {
-			item := r.(*poolItem)
-			latestExpire = item.expireAt
-			// TODO improve the auto-expiration mechanism of the pool.
-			if item.expireAt > timestampMilli {
-				p.list.PushFront(item)
-				break
-			}
-			if p.ExpireFunc != nil {
-				p.ExpireFunc(item.value)
-			}
-		} else {
-			break
-		}
-	}
+	p.TPool.Close()
 }
diff --git a/container/gpool/gpool_t.go b/container/gpool/gpool_t.go
new file mode 100644
index 000000000..083e2214e
--- /dev/null
+++ b/container/gpool/gpool_t.go
@@ -0,0 +1,183 @@
+// 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 gpool
+
+import (
+	"context"
+	"time"
+
+	"github.com/gogf/gf/v2/container/glist"
+	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/os/gtimer"
+)
+
+// TPool is an Object-Reusable Pool.
+type TPool[T any] struct {
+	list    *glist.TList[*tPoolItem[T]] // Available/idle items list.
+	closed  *gtype.Bool                 // Whether the pool is closed.
+	TTL     time.Duration               // Time To Live for pool items.
+	NewFunc func() (T, error)           // Callback function to create pool item.
+	// ExpireFunc is the function for expired items destruction.
+	// This function needs to be defined when the pool items
+	// need to perform additional destruction operations.
+	// Eg: net.Conn, os.File, etc.
+	ExpireFunc func(T)
+}
+
+// TPool item.
+type tPoolItem[T any] struct {
+	value    T     // Item value.
+	expireAt int64 // Expire timestamp in milliseconds.
+}
+
+// TPoolNewFunc Creation function for object.
+type TPoolNewFunc[T any] func() (T, error)
+
+// TPoolExpireFunc Destruction function for object.
+type TPoolExpireFunc[T any] func(T)
+
+// NewTPool creates and returns a new object pool.
+// To ensure execution efficiency, the expiration time cannot be modified once it is set.
+//
+// Note the expiration logic:
+// ttl = 0 : not expired;
+// ttl < 0 : immediate expired after use;
+// ttl > 0 : timeout expired;
+func NewTPool[T any](ttl time.Duration, newFunc TPoolNewFunc[T], expireFunc ...TPoolExpireFunc[T]) *TPool[T] {
+	r := &TPool[T]{
+		list:    glist.NewT[*tPoolItem[T]](true),
+		closed:  gtype.NewBool(),
+		TTL:     ttl,
+		NewFunc: newFunc,
+	}
+	if len(expireFunc) > 0 {
+		r.ExpireFunc = expireFunc[0]
+	}
+	gtimer.AddSingleton(context.Background(), time.Second, r.checkExpireItems)
+	return r
+}
+
+// Put puts an item to pool.
+func (p *TPool[T]) Put(value T) error {
+	if p.closed.Val() {
+		return gerror.NewCode(gcode.CodeInvalidOperation, "pool is closed")
+	}
+	item := &tPoolItem[T]{
+		value: value,
+	}
+	if p.TTL == 0 {
+		item.expireAt = 0
+	} else {
+		// As for Golang version < 1.13, there's no method Milliseconds for time.Duration.
+		// So we need calculate the milliseconds using its nanoseconds value.
+		item.expireAt = gtime.TimestampMilli() + p.TTL.Nanoseconds()/1000000
+	}
+	p.list.PushBack(item)
+	return nil
+}
+
+// MustPut puts an item to pool, it panics if any error occurs.
+func (p *TPool[T]) MustPut(value T) {
+	if err := p.Put(value); err != nil {
+		panic(err)
+	}
+}
+
+// Clear clears pool, which means it will remove all items from pool.
+func (p *TPool[T]) Clear() {
+	if p.ExpireFunc != nil {
+		for {
+			if r := p.list.PopFront(); r != nil {
+				p.ExpireFunc(r.value)
+			} else {
+				break
+			}
+		}
+	} else {
+		p.list.RemoveAll()
+	}
+}
+
+// Get picks and returns an item from pool. If the pool is empty and NewFunc is defined,
+// it creates and returns one from NewFunc.
+func (p *TPool[T]) Get() (value T, err error) {
+	for !p.closed.Val() {
+		if f := p.list.PopFront(); f != nil {
+			if f.expireAt == 0 || f.expireAt > gtime.TimestampMilli() {
+				return f.value, nil
+			} else if p.ExpireFunc != nil {
+				// TODO: move expire function calling asynchronously out from `Get` operation.
+				p.ExpireFunc(f.value)
+			}
+		} else {
+			break
+		}
+	}
+	if p.NewFunc != nil {
+		return p.NewFunc()
+	}
+	err = gerror.NewCode(gcode.CodeInvalidOperation, "pool is empty")
+	return
+}
+
+// Size returns the count of available items of pool.
+func (p *TPool[T]) Size() int {
+	return p.list.Len()
+}
+
+// Close closes the pool. If `p` has ExpireFunc,
+// then it automatically closes all items using this function before it's closed.
+// Commonly you do not need to call this function manually.
+func (p *TPool[T]) Close() {
+	p.closed.Set(true)
+}
+
+// checkExpire removes expired items from pool in every second.
+func (p *TPool[T]) checkExpireItems(ctx context.Context) {
+	if p.closed.Val() {
+		// If p has ExpireFunc,
+		// then it must close all items using this function.
+		if p.ExpireFunc != nil {
+			for {
+				if r := p.list.PopFront(); r != nil {
+					p.ExpireFunc(r.value)
+				} else {
+					break
+				}
+			}
+		}
+		gtimer.Exit()
+	}
+	// All items do not expire.
+	if p.TTL == 0 {
+		return
+	}
+	// The latest item expire timestamp in milliseconds.
+	var latestExpire int64 = -1
+	// Retrieve the current timestamp in milliseconds, it expires the items
+	// by comparing with this timestamp. It is not accurate comparison for
+	// every item expired, but high performance.
+	var timestampMilli = gtime.TimestampMilli()
+	for latestExpire <= timestampMilli {
+		if item := p.list.PopFront(); item != nil {
+			latestExpire = item.expireAt
+			// TODO improve the auto-expiration mechanism of the pool.
+			if item.expireAt > timestampMilli {
+				p.list.PushFront(item)
+				break
+			}
+			if p.ExpireFunc != nil {
+				p.ExpireFunc(item.value)
+			}
+		} else {
+			break
+		}
+	}
+}
diff --git a/container/gpool/gpool_z_example_test.go b/container/gpool/gpool_z_example_test.go
index 8077128ed..cbb2f5895 100644
--- a/container/gpool/gpool_z_example_test.go
+++ b/container/gpool/gpool_z_example_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gpool_test
diff --git a/container/gpool/gpool_z_unit_generic_test.go b/container/gpool/gpool_z_unit_generic_test.go
new file mode 100644
index 000000000..bff79ae24
--- /dev/null
+++ b/container/gpool/gpool_z_unit_generic_test.go
@@ -0,0 +1,112 @@
+// 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 gpool_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/gpool"
+	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_TPool_Int(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a pool for int
+		var (
+			newFunc = func() (int, error) {
+				return 100, nil
+			}
+			expireVal  = gtype.NewInt(0)
+			expireFunc = func(i int) {
+				expireVal.Set(i)
+			}
+		)
+
+		// TTL = 0, no expiration by time
+		p := gpool.NewTPool(0, newFunc, expireFunc)
+
+		// Test Put and Get
+		p.Put(1)
+		p.Put(2)
+		t.Assert(p.Size(), 2)
+
+		v, err := p.Get()
+		t.AssertNil(err)
+		t.AssertIN(v, g.Slice{1, 2})
+
+		v, err = p.Get()
+		t.AssertNil(err)
+		t.AssertIN(v, g.Slice{1, 2})
+
+		t.Assert(p.Size(), 0)
+
+		// Test NewFunc when empty
+		v, err = p.Get()
+		t.AssertNil(err)
+		t.Assert(v, 100)
+
+		// Test Clear and ExpireFunc
+		p.Put(50)
+		t.Assert(p.Size(), 1)
+		p.Clear()
+		t.Assert(p.Size(), 0)
+		t.Assert(expireVal.Val(), 50)
+
+		// Test Close
+		p.Put(60)
+		p.Close()
+		// Close should trigger expire for existing items?
+		// Looking at implementation: Close() sets closed=true.
+		// It does NOT automatically clear items unless checkExpireItems runs or we call Clear?
+		// Wait, checkExpireItems checks closed.Val(). If closed, it clears items.
+		// But checkExpireItems runs in a separate goroutine every second.
+		// So we might need to wait or trigger it.
+		// Actually, let's check the implementation of Close again.
+		/*
+			func (p *TPool[T]) Close() {
+				p.closed.Set(true)
+			}
+		*/
+		// And checkExpireItems:
+		/*
+			func (p *TPool[T]) checkExpireItems(ctx context.Context) {
+				if p.closed.Val() {
+					// ... clears items ...
+					gtimer.Exit()
+				}
+				// ...
+			}
+		*/
+		// So it relies on the timer to clean up.
+	})
+}
+
+func Test_TPool_Struct(t *testing.T) {
+	type User struct {
+		Id   int
+		Name string
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		p := gpool.NewTPool[User](time.Hour, nil)
+		u1 := User{Id: 1, Name: "john"}
+		p.Put(u1)
+
+		v, err := p.Get()
+		t.AssertNil(err)
+		t.Assert(v, u1)
+
+		// Test empty with no NewFunc
+		v, err = p.Get()
+		t.AssertNE(err, nil)
+		t.Assert(err.Error(), "pool is empty")
+		t.Assert(v, User{}) // Zero value
+	})
+}
diff --git a/container/gpool/gpool_z_unit_test.go b/container/gpool/gpool_z_unit_test.go
index 9ffe94c9d..7e7d5ce82 100644
--- a/container/gpool/gpool_z_unit_test.go
+++ b/container/gpool/gpool_z_unit_test.go
@@ -77,7 +77,7 @@ func Test_Gpool(t *testing.T) {
 		t.Assert(err2, errors.New("pool is empty"))
 		t.Assert(v2, nil)
 		// test close expireFunc
-		for index := 0; index < 10; index++ {
+		for index := range 10 {
 			p2.Put(index)
 		}
 		t.Assert(p2.Size(), 10)
diff --git a/container/gqueue/gqueue.go b/container/gqueue/gqueue.go
index e20e0ec94..57cbf064e 100644
--- a/container/gqueue/gqueue.go
+++ b/container/gqueue/gqueue.go
@@ -17,20 +17,9 @@
 // 4. Blocking when reading data from queue;
 package gqueue
 
-import (
-	"math"
-
-	"github.com/gogf/gf/v2/container/glist"
-	"github.com/gogf/gf/v2/container/gtype"
-)
-
 // Queue is a concurrent-safe queue built on doubly linked list and channel.
 type Queue struct {
-	limit  int           // Limit for queue size.
-	list   *glist.List   // Underlying list structure for data maintaining.
-	closed *gtype.Bool   // Whether queue is closed.
-	events chan struct{} // Events for data writing.
-	C      chan any      // Underlying channel for data reading.
+	*TQueue[any]
 }
 
 const (
@@ -42,103 +31,40 @@ const (
 // Optional parameter `limit` is used to limit the size of the queue, which is unlimited in default.
 // When `limit` is given, the queue will be static and high performance which is comparable with stdlib channel.
 func New(limit ...int) *Queue {
-	q := &Queue{
-		closed: gtype.NewBool(),
+	return &Queue{
+		TQueue: NewTQueue[any](limit...),
 	}
-	if len(limit) > 0 && limit[0] > 0 {
-		q.limit = limit[0]
-		q.C = make(chan any, limit[0])
-	} else {
-		q.list = glist.New(true)
-		q.events = make(chan struct{}, math.MaxInt32)
-		q.C = make(chan any, defaultQueueSize)
-		go q.asyncLoopFromListToChannel()
-	}
-	return q
 }
 
 // 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 any) {
-	if q.limit > 0 {
-		q.C <- v
-	} else {
-		q.list.PushBack(v)
-		if len(q.events) < defaultQueueSize {
-			q.events <- struct{}{}
-		}
-	}
+	q.TQueue.Push(v)
 }
 
 // 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() any {
-	return <-q.C
+	return q.TQueue.Pop()
 }
 
 // Close closes the queue.
 // Notice: It would notify all goroutines return immediately,
 // which are being blocked reading using Pop method.
 func (q *Queue) Close() {
-	if !q.closed.Cas(false, true) {
-		return
-	}
-	if q.events != nil {
-		close(q.events)
-	}
-	if q.limit > 0 {
-		close(q.C)
-	} else {
-		for i := 0; i < defaultBatchSize; i++ {
-			q.Pop()
-		}
-	}
+	q.TQueue.Close()
 }
 
 // Len returns the length of the queue.
 // 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) {
-	bufferedSize := int64(len(q.C))
-	if q.limit > 0 {
-		return bufferedSize
-	}
-	return int64(q.list.Size()) + bufferedSize
+	return q.TQueue.Len()
 }
 
 // Size is alias of Len.
+//
 // Deprecated: use Len instead.
 func (q *Queue) Size() int64 {
 	return q.Len()
 }
-
-// asyncLoopFromListToChannel starts an asynchronous goroutine,
-// which handles the data synchronization from list `q.list` to channel `q.C`.
-func (q *Queue) asyncLoopFromListToChannel() {
-	defer func() {
-		if q.closed.Val() {
-			_ = recover()
-		}
-	}()
-	for !q.closed.Val() {
-		<-q.events
-		for !q.closed.Val() {
-			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
-			}
-		}
-		// Clear q.events to remain just one event to do the next synchronization check.
-		for i := 0; i < len(q.events)-1; i++ {
-			<-q.events
-		}
-	}
-	// It should be here to close `q.C` if `q` is unlimited size.
-	// It's the sender's responsibility to close channel when it should be closed.
-	close(q.C)
-}
diff --git a/container/gqueue/gqueue_t.go b/container/gqueue/gqueue_t.go
new file mode 100644
index 000000000..74e56e6b0
--- /dev/null
+++ b/container/gqueue/gqueue_t.go
@@ -0,0 +1,134 @@
+// 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 gqueue
+
+import (
+	"math"
+
+	"github.com/gogf/gf/v2/container/glist"
+	"github.com/gogf/gf/v2/container/gtype"
+)
+
+// TQueue is a concurrent-safe queue built on doubly linked list and channel.
+type TQueue[T any] struct {
+	limit  int             // Limit for queue size.
+	list   *glist.TList[T] // Underlying list structure for data maintaining.
+	closed *gtype.Bool     // Whether queue is closed.
+	events chan struct{}   // Events for data writing.
+	C      chan T          // Underlying channel for data reading.
+}
+
+// NewTQueue returns an empty queue object.
+// Optional parameter `limit` is used to limit the size of the queue, which is unlimited in default.
+// When `limit` is given, the queue will be static and high performance which is comparable with stdlib channel.
+func NewTQueue[T any](limit ...int) *TQueue[T] {
+	q := &TQueue[T]{
+		closed: gtype.NewBool(),
+	}
+	if len(limit) > 0 && limit[0] > 0 {
+		q.limit = limit[0]
+		q.C = make(chan T, limit[0])
+	} else {
+		q.list = glist.NewT[T](true)
+		q.events = make(chan struct{}, math.MaxInt32)
+		q.C = make(chan T, defaultQueueSize)
+		go q.asyncLoopFromListToChannel()
+	}
+	return q
+}
+
+// Push pushes the data `v` into the queue.
+// Note that it would panic if Push is called after the queue is closed.
+func (q *TQueue[T]) Push(v T) {
+	if q.limit > 0 {
+		q.C <- v
+	} else {
+		q.list.PushBack(v)
+		if len(q.events) < defaultQueueSize {
+			q.events <- struct{}{}
+		}
+	}
+}
+
+// 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 *TQueue[T]) Pop() T {
+	return <-q.C
+}
+
+// Close closes the queue.
+// Notice: It would notify all goroutines return immediately,
+// which are being blocked reading using Pop method.
+func (q *TQueue[T]) Close() {
+	if !q.closed.Cas(false, true) {
+		return
+	}
+	if q.events != nil {
+		close(q.events)
+	}
+	if q.limit > 0 {
+		close(q.C)
+	} else {
+		for range defaultBatchSize {
+			q.Pop()
+		}
+	}
+}
+
+// Len returns the length of the queue.
+// 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 *TQueue[T]) Len() (length int64) {
+	bufferedSize := int64(len(q.C))
+	if q.limit > 0 {
+		return bufferedSize
+	}
+	// If the queue is unlimited and the buffered size is exactly the default size,
+	// it means there might be some data in the list not synchronized to channel yet.
+	// So we need to add 1 to the buffered size to make the result more accurate.
+	if bufferedSize == defaultQueueSize {
+		bufferedSize++
+	}
+	return int64(q.list.Size()) + bufferedSize
+}
+
+// Size is alias of Len.
+//
+// Deprecated: use Len instead.
+func (q *TQueue[T]) Size() int64 {
+	return q.Len()
+}
+
+// asyncLoopFromListToChannel starts an asynchronous goroutine,
+// which handles the data synchronization from list `q.list` to channel `q.C`.
+func (q *TQueue[T]) asyncLoopFromListToChannel() {
+	defer func() {
+		if q.closed.Val() {
+			_ = recover()
+		}
+	}()
+	for !q.closed.Val() {
+		<-q.events
+		for !q.closed.Val() {
+			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 range bufferLength {
+					q.C <- q.list.PopFront()
+				}
+			} else {
+				break
+			}
+		}
+		// Clear q.events to remain just one event to do the next synchronization check.
+		for i := 0; i < len(q.events)-1; i++ {
+			<-q.events
+		}
+	}
+	// It should be here to close `q.C` if `q` is unlimited size.
+	// It's the sender's responsibility to close channel when it should be closed.
+	close(q.C)
+}
diff --git a/container/gqueue/gqueue_z_unit_test.go b/container/gqueue/gqueue_z_unit_test.go
index cf87f7a48..75fe87716 100644
--- a/container/gqueue/gqueue_z_unit_test.go
+++ b/container/gqueue/gqueue_z_unit_test.go
@@ -24,7 +24,7 @@ func TestQueue_Len(t *testing.T) {
 		)
 		for n := 10; n < maxTries; n++ {
 			q1 := gqueue.New(maxNum)
-			for i := 0; i < maxNum; i++ {
+			for i := range maxNum {
 				q1.Push(i)
 			}
 			t.Assert(q1.Len(), maxNum)
@@ -38,7 +38,7 @@ func TestQueue_Len(t *testing.T) {
 		)
 		for n := 10; n < maxTries; n++ {
 			q1 := gqueue.New()
-			for i := 0; i < maxNum; i++ {
+			for i := range maxNum {
 				q1.Push(i)
 			}
 			t.AssertLE(q1.Len(), maxNum)
@@ -50,7 +50,8 @@ func TestQueue_Len(t *testing.T) {
 func TestQueue_Basic(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		q := gqueue.New()
-		for i := 0; i < 100; i++ {
+		defer q.Close()
+		for i := range 100 {
 			q.Push(i)
 		}
 		t.Assert(q.Pop(), 0)
@@ -61,6 +62,7 @@ func TestQueue_Basic(t *testing.T) {
 func TestQueue_Pop(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		q1 := gqueue.New()
+		defer q1.Close()
 		q1.Push(1)
 		q1.Push(2)
 		q1.Push(3)
@@ -73,27 +75,28 @@ func TestQueue_Pop(t *testing.T) {
 func TestQueue_Close(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		q1 := gqueue.New()
+		defer q1.Close()
 		q1.Push(1)
 		q1.Push(2)
 		// wait sync to channel
 		time.Sleep(10 * time.Millisecond)
 		t.Assert(q1.Len(), 2)
-		q1.Close()
 	})
 	gtest.C(t, func(t *gtest.T) {
 		q1 := gqueue.New(2)
+		defer q1.Close()
 		q1.Push(1)
 		q1.Push(2)
 		// wait sync to channel
 		time.Sleep(10 * time.Millisecond)
 		t.Assert(q1.Len(), 2)
-		q1.Close()
 	})
 }
 
 func Test_Issue2509(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		q := gqueue.New()
+		defer q.Close()
 		q.Push(1)
 		q.Push(2)
 		q.Push(3)
@@ -106,3 +109,237 @@ func Test_Issue2509(t *testing.T) {
 		t.Assert(q.Len(), 0)
 	})
 }
+
+// Issue #4376
+func TestIssue4376(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		gq := gqueue.New()
+		defer gq.Close()
+		cq := make(chan int, 100000)
+		defer close(cq)
+
+		for i := range 11603 {
+			gq.Push(i)
+			cq <- i
+		}
+		// May be not equal because of the async channel reading goroutine.
+		t.Log(gq.Len(), len(cq))
+		time.Sleep(50 * time.Millisecond)
+		t.Log(gq.Len(), len(cq))
+	})
+}
+
+// Test static queue (with limit) close operation
+func TestQueue_StaticClose(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New(10)
+		defer func() {
+			if err := recover(); err == nil {
+				t.Log("Close succeeded")
+			}
+		}()
+		q.Push(1)
+		q.Push(2)
+		q.Close()
+		// After closing, Pop should return nil
+		v := q.Pop()
+		t.Assert(v, nil)
+	})
+}
+
+// Test Size() method (deprecated alias of Len)
+func TestQueue_Size(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New(20)
+		for i := range 10 {
+			q.Push(i)
+		}
+		t.Assert(q.Size(), 10)
+		t.Assert(q.Len(), 10)
+		q.Close()
+	})
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New()
+		for i := range 15 {
+			q.Push(i)
+		}
+		time.Sleep(10 * time.Millisecond)
+		t.Assert(q.Size(), q.Len())
+		q.Close()
+	})
+}
+
+// Test TQueue directly with generic type
+func TestTQueue_Generic(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test with custom type
+		q := gqueue.NewTQueue[string]()
+		defer q.Close()
+		q.Push("hello")
+		q.Push("world")
+		t.Assert(q.Pop(), "hello")
+		t.Assert(q.Pop(), "world")
+	})
+}
+
+// Test TQueue Size method directly
+func TestTQueue_Size(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.NewTQueue[int]()
+		defer q.Close()
+		for i := range 10 {
+			q.Push(i)
+		}
+		time.Sleep(10 * time.Millisecond)
+		// Size is an alias of Len for TQueue
+		t.Assert(q.Size(), q.Len())
+	})
+}
+
+// Test TQueue with static limit
+func TestTQueue_StaticLimit(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.NewTQueue[int](5)
+		defer q.Close()
+		for i := range 5 {
+			q.Push(i)
+		}
+		t.Assert(q.Len(), 5)
+		for i := range 5 {
+			t.Assert(q.Pop(), i)
+		}
+		t.Assert(q.Len(), 0)
+	})
+}
+
+// Test queue with large data push/pop
+func TestQueue_LargeDataScale(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New()
+		defer q.Close()
+		n := 5000
+		for i := range n {
+			q.Push(i)
+		}
+		time.Sleep(50 * time.Millisecond)
+		// Pop should retrieve all items in order
+		for i := range n {
+			v := q.Pop()
+			t.Assert(v, i)
+		}
+	})
+}
+
+// Test double close (idempotent close)
+func TestQueue_DoubleClose(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New()
+		q.Push(1)
+		q.Close()
+		// Second close should not panic
+		q.Close()
+		t.Assert(q.Pop(), nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New(10)
+		q.Push(1)
+		q.Close()
+		// Second close should not panic for static queue
+		q.Close()
+		// Pop from closed static queue returns the buffered value
+		v := q.Pop()
+		t.Assert(v, 1)
+	})
+}
+
+// Test concurrent push and pop
+func TestQueue_ConcurrentPushPop(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New()
+		defer q.Close()
+		// Producer goroutine
+		go func() {
+			for i := range 100 {
+				q.Push(i)
+			}
+			time.Sleep(50 * time.Millisecond)
+			q.Close()
+		}()
+		// Consumer
+		count := 0
+		for {
+			v := q.Pop()
+			if v == nil {
+				break
+			}
+			count++
+		}
+		t.AssertGE(count, 1)
+	})
+}
+
+// Test Pop on empty queue returns nil when closed
+func TestQueue_PopEmptyClosed(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New()
+		q.Close()
+		v := q.Pop()
+		t.Assert(v, nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New(10)
+		q.Close()
+		v := q.Pop()
+		t.Assert(v, nil)
+	})
+}
+
+// Test Len with dynamic queue at capacity boundary
+func TestQueue_LenAtBoundary(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New()
+		defer q.Close()
+		// Push exactly defaultQueueSize items to test boundary condition
+		for i := range 10000 {
+			q.Push(i)
+		}
+		time.Sleep(50 * time.Millisecond)
+		len := q.Len()
+		t.AssertGE(len, 0)
+	})
+}
+
+// Test Close on dynamic queue with pending asyncLoopFromListToChannel
+func TestQueue_CloseWithAsyncLoop(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New()
+		// Push some data to activate asyncLoopFromListToChannel
+		for i := range 100 {
+			q.Push(i)
+		}
+		// Immediately close
+		q.Close()
+		// Pop should return values until exhausted, then nil
+		for {
+			v := q.Pop()
+			if v == nil {
+				break
+			}
+		}
+		t.Assert(q.Pop(), nil)
+	})
+}
+
+// Test static queue edge case with zero limit (should create unlimited queue)
+func TestQueue_ZeroLimitCreatesUnlimited(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		q := gqueue.New(0)
+		defer q.Close()
+		for i := range 100 {
+			q.Push(i)
+		}
+		time.Sleep(10 * time.Millisecond)
+		len := q.Len()
+		t.Assert(len, 100)
+	})
+}
diff --git a/container/gring/gring.go b/container/gring/gring.go
index 3a0893c61..139211114 100644
--- a/container/gring/gring.go
+++ b/container/gring/gring.go
@@ -9,27 +9,11 @@
 // Deprecated.
 package gring
 
-import (
-	"container/ring"
-
-	"github.com/gogf/gf/v2/container/gtype"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-)
-
 // Ring is a struct of ring structure.
 //
 // Deprecated.
 type Ring struct {
-	mu    *rwmutex.RWMutex
-	ring  *ring.Ring  // Underlying ring.
-	len   *gtype.Int  // Length(already used size).
-	cap   *gtype.Int  // Capability(>=len).
-	dirty *gtype.Bool // Dirty, which means the len and cap should be recalculated. It's marked dirty when the size of ring changes.
-}
-
-// internalRingItem stores the ring element value.
-type internalRingItem struct {
-	Value any
+	*TRing[any]
 }
 
 // New creates and returns a Ring structure of `cap` elements.
@@ -39,108 +23,53 @@ type internalRingItem struct {
 // Deprecated.
 func New(cap int, safe ...bool) *Ring {
 	return &Ring{
-		mu:    rwmutex.New(safe...),
-		ring:  ring.New(cap),
-		len:   gtype.NewInt(),
-		cap:   gtype.NewInt(cap),
-		dirty: gtype.NewBool(),
+		TRing: NewTRing[any](cap, safe...),
 	}
 }
 
 // Val returns the item's value of current position.
 func (r *Ring) Val() any {
-	var value any
-	r.mu.RLock()
-	if r.ring.Value != nil {
-		value = r.ring.Value.(internalRingItem).Value
-	}
-	r.mu.RUnlock()
-	return value
+	return r.TRing.Val()
 }
 
 // Len returns the size of ring.
 func (r *Ring) Len() int {
-	r.checkAndUpdateLenAndCap()
-	return r.len.Val()
+	return r.TRing.Len()
 }
 
 // Cap returns the capacity of ring.
 func (r *Ring) Cap() int {
-	r.checkAndUpdateLenAndCap()
-	return r.cap.Val()
-}
-
-// Checks and updates the len and cap of ring when ring is dirty.
-func (r *Ring) checkAndUpdateLenAndCap() {
-	if !r.dirty.Val() {
-		return
-	}
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	totalLen := 0
-	emptyLen := 0
-	if r.ring != nil {
-		if r.ring.Value == nil {
-			emptyLen++
-		}
-		totalLen++
-		for p := r.ring.Next(); p != r.ring; p = p.Next() {
-			if p.Value == nil {
-				emptyLen++
-			}
-			totalLen++
-		}
-	}
-	r.cap.Set(totalLen)
-	r.len.Set(totalLen - emptyLen)
-	r.dirty.Set(false)
+	return r.TRing.Cap()
 }
 
 // Set sets value to the item of current position.
 func (r *Ring) Set(value any) *Ring {
-	r.mu.Lock()
-	if r.ring.Value == nil {
-		r.len.Add(1)
-	}
-	r.ring.Value = internalRingItem{Value: value}
-	r.mu.Unlock()
+	r.TRing.Set(value)
 	return r
 }
 
 // Put sets `value` to current item of ring and moves position to next item.
 func (r *Ring) Put(value any) *Ring {
-	r.mu.Lock()
-	if r.ring.Value == nil {
-		r.len.Add(1)
-	}
-	r.ring.Value = internalRingItem{Value: value}
-	r.ring = r.ring.Next()
-	r.mu.Unlock()
+	r.TRing.Put(value)
 	return r
 }
 
 // Move moves n % r.Len() elements backward (n < 0) or forward (n >= 0)
 // in the ring and returns that ring element. r must not be empty.
 func (r *Ring) Move(n int) *Ring {
-	r.mu.Lock()
-	r.ring = r.ring.Move(n)
-	r.mu.Unlock()
+	r.TRing.Move(n)
 	return r
 }
 
 // Prev returns the previous ring element. r must not be empty.
 func (r *Ring) Prev() *Ring {
-	r.mu.Lock()
-	r.ring = r.ring.Prev()
-	r.mu.Unlock()
+	r.TRing.Prev()
 	return r
 }
 
 // Next returns the next ring element. r must not be empty.
 func (r *Ring) Next() *Ring {
-	r.mu.Lock()
-	r.ring = r.ring.Next()
-	r.mu.Unlock()
+	r.TRing.Next()
 	return r
 }
 
@@ -160,13 +89,7 @@ func (r *Ring) Next() *Ring {
 // after r. The result points to the element following the
 // last element of s after insertion.
 func (r *Ring) Link(s *Ring) *Ring {
-	r.mu.Lock()
-	s.mu.Lock()
-	r.ring.Link(s.ring)
-	s.mu.Unlock()
-	r.mu.Unlock()
-	r.dirty.Set(true)
-	s.dirty.Set(true)
+	r.TRing.Link(s.TRing)
 	return r
 }
 
@@ -174,78 +97,31 @@ func (r *Ring) Link(s *Ring) *Ring {
 // at r.Next(). If n % r.Len() == 0, r remains unchanged.
 // The result is the removed sub-ring. r must not be empty.
 func (r *Ring) Unlink(n int) *Ring {
-	r.mu.Lock()
-	resultRing := r.ring.Unlink(n)
-	r.dirty.Set(true)
-	r.mu.Unlock()
-	resultGRing := New(resultRing.Len())
-	resultGRing.ring = resultRing
-	resultGRing.dirty.Set(true)
-	return resultGRing
+	return &Ring{
+		TRing: r.TRing.Unlink(n),
+	}
 }
 
 // RLockIteratorNext iterates and locks reading forward
 // with given callback function `f` within RWMutex.RLock.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (r *Ring) RLockIteratorNext(f func(value any) bool) {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	if r.ring.Value != nil && !f(r.ring.Value.(internalRingItem).Value) {
-		return
-	}
-	for p := r.ring.Next(); p != r.ring; p = p.Next() {
-		if p.Value == nil || !f(p.Value.(internalRingItem).Value) {
-			break
-		}
-	}
+	r.TRing.RLockIteratorNext(f)
 }
 
-// RLockIteratorPrev iterates and locks writing backward
+// RLockIteratorPrev iterates and locks reading backward
 // with given callback function `f` within RWMutex.RLock.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (r *Ring) RLockIteratorPrev(f func(value any) bool) {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	if r.ring.Value != nil && !f(r.ring.Value.(internalRingItem).Value) {
-		return
-	}
-	for p := r.ring.Prev(); p != r.ring; p = p.Prev() {
-		if p.Value == nil || !f(p.Value.(internalRingItem).Value) {
-			break
-		}
-	}
+	r.TRing.RLockIteratorPrev(f)
 }
 
 // SliceNext returns a copy of all item values as slice forward from current position.
 func (r *Ring) SliceNext() []any {
-	s := make([]any, 0)
-	r.mu.RLock()
-	if r.ring.Value != nil {
-		s = append(s, r.ring.Value.(internalRingItem).Value)
-	}
-	for p := r.ring.Next(); p != r.ring; p = p.Next() {
-		if p.Value == nil {
-			break
-		}
-		s = append(s, p.Value.(internalRingItem).Value)
-	}
-	r.mu.RUnlock()
-	return s
+	return r.TRing.SliceNext()
 }
 
 // SlicePrev returns a copy of all item values as slice backward from current position.
 func (r *Ring) SlicePrev() []any {
-	s := make([]any, 0)
-	r.mu.RLock()
-	if r.ring.Value != nil {
-		s = append(s, r.ring.Value.(internalRingItem).Value)
-	}
-	for p := r.ring.Prev(); p != r.ring; p = p.Prev() {
-		if p.Value == nil {
-			break
-		}
-		s = append(s, p.Value.(internalRingItem).Value)
-	}
-	r.mu.RUnlock()
-	return s
+	return r.TRing.SlicePrev()
 }
diff --git a/container/gring/gring_t.go b/container/gring/gring_t.go
new file mode 100644
index 000000000..1926f2a7f
--- /dev/null
+++ b/container/gring/gring_t.go
@@ -0,0 +1,244 @@
+// 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 gring
+
+import (
+	"container/ring"
+
+	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+)
+
+// TRing is a struct of ring structure.
+type TRing[T any] struct {
+	mu    *rwmutex.RWMutex
+	ring  *ring.Ring  // Underlying ring.
+	len   *gtype.Int  // Length(already used size).
+	cap   *gtype.Int  // Capability(>=len).
+	dirty *gtype.Bool // Dirty, which means the len and cap should be recalculated. It's marked dirty when the size of ring changes.
+}
+
+// internalTRingItem[T] stores the ring element value.
+type internalTRingItem[T any] struct {
+	Value T
+}
+
+// NewTRing creates and returns a Ring structure of `cap` elements.
+// The optional parameter `safe` specifies whether using this structure in concurrent safety,
+// which is false in default.
+func NewTRing[T any](cap int, safe ...bool) *TRing[T] {
+	return &TRing[T]{
+		mu:    rwmutex.New(safe...),
+		ring:  ring.New(cap),
+		len:   gtype.NewInt(),
+		cap:   gtype.NewInt(cap),
+		dirty: gtype.NewBool(),
+	}
+}
+
+// Val returns the item's value of current position.
+func (r *TRing[T]) Val() T {
+	var value T
+	r.mu.RLock()
+	if r.ring.Value != nil {
+		value = r.ring.Value.(internalTRingItem[T]).Value
+	}
+	r.mu.RUnlock()
+	return value
+}
+
+// Len returns the size of ring.
+func (r *TRing[T]) Len() int {
+	r.checkAndUpdateLenAndCap()
+	return r.len.Val()
+}
+
+// Cap returns the capacity of ring.
+func (r *TRing[T]) Cap() int {
+	r.checkAndUpdateLenAndCap()
+	return r.cap.Val()
+}
+
+// Checks and updates the len and cap of ring when ring is dirty.
+func (r *TRing[T]) checkAndUpdateLenAndCap() {
+	if !r.dirty.Val() {
+		return
+	}
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	totalLen := 0
+	emptyLen := 0
+	if r.ring != nil {
+		if r.ring.Value == nil {
+			emptyLen++
+		}
+		totalLen++
+		for p := r.ring.Next(); p != r.ring; p = p.Next() {
+			if p.Value == nil {
+				emptyLen++
+			}
+			totalLen++
+		}
+	}
+	r.cap.Set(totalLen)
+	r.len.Set(totalLen - emptyLen)
+	r.dirty.Set(false)
+}
+
+// Set sets value to the item of current position.
+func (r *TRing[T]) Set(value T) *TRing[T] {
+	r.mu.Lock()
+	if r.ring.Value == nil {
+		r.len.Add(1)
+	}
+	r.ring.Value = internalTRingItem[T]{Value: value}
+	r.mu.Unlock()
+	return r
+}
+
+// Put sets `value` to current item of ring and moves position to next item.
+func (r *TRing[T]) Put(value T) *TRing[T] {
+	r.mu.Lock()
+	if r.ring.Value == nil {
+		r.len.Add(1)
+	}
+	r.ring.Value = internalTRingItem[T]{Value: value}
+	r.ring = r.ring.Next()
+	r.mu.Unlock()
+	return r
+}
+
+// Move moves n % r.Len() elements backward (n < 0) or forward (n >= 0)
+// in the ring and returns that ring element. r must not be empty.
+func (r *TRing[T]) Move(n int) *TRing[T] {
+	r.mu.Lock()
+	r.ring = r.ring.Move(n)
+	r.mu.Unlock()
+	return r
+}
+
+// Prev returns the previous ring element. r must not be empty.
+func (r *TRing[T]) Prev() *TRing[T] {
+	r.mu.Lock()
+	r.ring = r.ring.Prev()
+	r.mu.Unlock()
+	return r
+}
+
+// Next returns the next ring element. r must not be empty.
+func (r *TRing[T]) Next() *TRing[T] {
+	r.mu.Lock()
+	r.ring = r.ring.Next()
+	r.mu.Unlock()
+	return r
+}
+
+// Link connects ring r with ring s such that r.Next()
+// becomes s and returns the original value for r.Next().
+// r must not be empty.
+//
+// If r and s point to the same ring, linking
+// them removes the elements between r and s from the ring.
+// The removed elements form a sub-ring and the result is a
+// reference to that sub-ring (if no elements were removed,
+// the result is still the original value for r.Next(),
+// and not nil).
+//
+// If r and s point to different rings, linking
+// them creates a single ring with the elements of s inserted
+// after r. The result points to the element following the
+// last element of s after insertion.
+func (r *TRing[T]) Link(s *TRing[T]) *TRing[T] {
+	r.mu.Lock()
+	s.mu.Lock()
+	r.ring.Link(s.ring)
+	s.mu.Unlock()
+	r.mu.Unlock()
+	r.dirty.Set(true)
+	s.dirty.Set(true)
+	return r
+}
+
+// Unlink removes n % r.Len() elements from the ring r, starting
+// at r.Next(). If n % r.Len() == 0, r remains unchanged.
+// The result is the removed sub-ring. r must not be empty.
+func (r *TRing[T]) Unlink(n int) *TRing[T] {
+	r.mu.Lock()
+	resultRing := r.ring.Unlink(n)
+	r.dirty.Set(true)
+	r.mu.Unlock()
+	resultGRing := NewTRing[T](resultRing.Len())
+	resultGRing.ring = resultRing
+	resultGRing.dirty.Set(true)
+	return resultGRing
+}
+
+// RLockIteratorNext iterates and locks reading forward
+// with given callback function `f` within RWMutex.RLock.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (r *TRing[T]) RLockIteratorNext(f func(value T) bool) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.ring.Value != nil && !f(r.ring.Value.(internalTRingItem[T]).Value) {
+		return
+	}
+	for p := r.ring.Next(); p != r.ring; p = p.Next() {
+		if p.Value == nil || !f(p.Value.(internalTRingItem[T]).Value) {
+			break
+		}
+	}
+}
+
+// RLockIteratorPrev iterates and locks reading backward
+// with given callback function `f` within RWMutex.RLock.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (r *TRing[T]) RLockIteratorPrev(f func(value T) bool) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.ring.Value != nil && !f(r.ring.Value.(internalTRingItem[T]).Value) {
+		return
+	}
+	for p := r.ring.Prev(); p != r.ring; p = p.Prev() {
+		if p.Value == nil || !f(p.Value.(internalTRingItem[T]).Value) {
+			break
+		}
+	}
+}
+
+// SliceNext returns a copy of all item values as slice forward from current position.
+func (r *TRing[T]) SliceNext() []T {
+	s := make([]T, 0, r.Len())
+	r.mu.RLock()
+	if r.ring.Value != nil {
+		s = append(s, r.ring.Value.(internalTRingItem[T]).Value)
+	}
+	for p := r.ring.Next(); p != r.ring; p = p.Next() {
+		if p.Value == nil {
+			break
+		}
+		s = append(s, p.Value.(internalTRingItem[T]).Value)
+	}
+	r.mu.RUnlock()
+	return s
+}
+
+// SlicePrev returns a copy of all item values as slice backward from current position.
+func (r *TRing[T]) SlicePrev() []T {
+	s := make([]T, 0, r.Len())
+	r.mu.RLock()
+	if r.ring.Value != nil {
+		s = append(s, r.ring.Value.(internalTRingItem[T]).Value)
+	}
+	for p := r.ring.Prev(); p != r.ring; p = p.Prev() {
+		if p.Value == nil {
+			break
+		}
+		s = append(s, p.Value.(internalTRingItem[T]).Value)
+	}
+	r.mu.RUnlock()
+	return s
+}
diff --git a/container/gring/gring_z_unit_test.go b/container/gring/gring_z_unit_test.go
index 4f3c847e9..9e861734e 100644
--- a/container/gring/gring_z_unit_test.go
+++ b/container/gring/gring_z_unit_test.go
@@ -148,14 +148,11 @@ func Test_Issue1394(t *testing.T) {
 		for i := 0; i < 10; i++ {
 			gRing.Put(i)
 		}
-		t.Logf("the length:%d", gRing.Len())
 		gRingResult := gRing.Unlink(6)
 		for i := 0; i < 10; i++ {
 			t.Log(gRing.Val())
 			gRing = gRing.Next()
 		}
-		t.Logf("the ring length:%d", gRing.Len())
-		t.Logf("the result length:%d", gRingResult.Len())
 
 		// stdring
 		stdRing := ring.New(10)
@@ -163,14 +160,11 @@ func Test_Issue1394(t *testing.T) {
 			stdRing.Value = i
 			stdRing = stdRing.Next()
 		}
-		t.Logf("the length:%d", stdRing.Len())
 		stdRingResult := stdRing.Unlink(6)
 		for i := 0; i < 10; i++ {
 			t.Log(stdRing.Value)
 			stdRing = stdRing.Next()
 		}
-		t.Logf("the ring length:%d", stdRing.Len())
-		t.Logf("the result length:%d", stdRingResult.Len())
 
 		// Assertion.
 		t.Assert(gRing.Len(), stdRing.Len())
diff --git a/container/gset/gset_any_set.go b/container/gset/gset_any_set.go
index de816c652..152fe1e91 100644
--- a/container/gset/gset_any_set.go
+++ b/container/gset/gset_any_set.go
@@ -8,18 +8,15 @@
 package gset
 
 import (
-	"bytes"
+	"sync"
 
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // Set is consisted of any items.
 type Set struct {
-	mu   rwmutex.RWMutex
-	data map[any]struct{}
+	*TSet[any]
+	once sync.Once
 }
 
 // New create and returns a new set, which contains un-repeated items.
@@ -33,44 +30,38 @@ func New(safe ...bool) *Set {
 // Also see New.
 func NewSet(safe ...bool) *Set {
 	return &Set{
-		data: make(map[any]struct{}),
-		mu:   rwmutex.Create(safe...),
+		TSet: NewTSet[any](safe...),
 	}
 }
 
 // NewFrom returns a new set from `items`.
 // Parameter `items` can be either a variable of any type, or a slice.
 func NewFrom(items any, safe ...bool) *Set {
-	m := make(map[any]struct{})
-	for _, v := range gconv.Interfaces(items) {
-		m[v] = struct{}{}
-	}
 	return &Set{
-		data: m,
-		mu:   rwmutex.Create(safe...),
+		TSet: NewTSetFrom[any](gconv.Interfaces(items), safe...),
 	}
 }
 
+// lazyInit lazily initializes the set.
+func (a *Set) lazyInit() {
+	a.once.Do(func() {
+		if a.TSet == nil {
+			a.TSet = NewTSet[any]()
+		}
+	})
+}
+
 // Iterator iterates the set readonly with given callback function `f`,
 // if `f` returns true then continue iterating; or false to stop.
 func (set *Set) Iterator(f func(v any) bool) {
-	for _, k := range set.Slice() {
-		if !f(k) {
-			break
-		}
-	}
+	set.lazyInit()
+	set.TSet.Iterator(f)
 }
 
 // Add adds one or multiple items to the set.
 func (set *Set) Add(items ...any) {
-	set.mu.Lock()
-	if set.data == nil {
-		set.data = make(map[any]struct{})
-	}
-	for _, v := range items {
-		set.data[v] = struct{}{}
-	}
-	set.mu.Unlock()
+	set.lazyInit()
+	set.TSet.Add(items...)
 }
 
 // AddIfNotExist checks whether item exists in the set,
@@ -79,21 +70,8 @@ func (set *Set) Add(items ...any) {
 //
 // Note that, if `item` is nil, it does nothing and returns false.
 func (set *Set) AddIfNotExist(item any) bool {
-	if item == nil {
-		return false
-	}
-	if !set.Contains(item) {
-		set.mu.Lock()
-		defer set.mu.Unlock()
-		if set.data == nil {
-			set.data = make(map[any]struct{})
-		}
-		if _, ok := set.data[item]; !ok {
-			set.data[item] = struct{}{}
-			return true
-		}
-	}
-	return false
+	set.lazyInit()
+	return set.TSet.AddIfNotExist(item)
 }
 
 // AddIfNotExistFunc checks whether item exists in the set,
@@ -103,23 +81,8 @@ func (set *Set) AddIfNotExist(item any) bool {
 // Note that, if `item` is nil, it does nothing and returns false. The function `f`
 // is executed without writing lock.
 func (set *Set) AddIfNotExistFunc(item any, f func() bool) bool {
-	if item == nil {
-		return false
-	}
-	if !set.Contains(item) {
-		if f() {
-			set.mu.Lock()
-			defer set.mu.Unlock()
-			if set.data == nil {
-				set.data = make(map[any]struct{})
-			}
-			if _, ok := set.data[item]; !ok {
-				set.data[item] = struct{}{}
-				return true
-			}
-		}
-	}
-	return false
+	set.lazyInit()
+	return set.TSet.AddIfNotExistFunc(item, f)
 }
 
 // AddIfNotExistFuncLock checks whether item exists in the set,
@@ -129,95 +92,44 @@ func (set *Set) AddIfNotExistFunc(item any, f func() bool) bool {
 // Note that, if `item` is nil, it does nothing and returns false. The function `f`
 // is executed within writing lock.
 func (set *Set) AddIfNotExistFuncLock(item any, f func() bool) bool {
-	if item == nil {
-		return false
-	}
-	if !set.Contains(item) {
-		set.mu.Lock()
-		defer set.mu.Unlock()
-		if set.data == nil {
-			set.data = make(map[any]struct{})
-		}
-		if f() {
-			if _, ok := set.data[item]; !ok {
-				set.data[item] = struct{}{}
-				return true
-			}
-		}
-	}
-	return false
+	set.lazyInit()
+	return set.TSet.AddIfNotExistFuncLock(item, f)
 }
 
 // Contains checks whether the set contains `item`.
 func (set *Set) Contains(item any) bool {
-	var ok bool
-	set.mu.RLock()
-	if set.data != nil {
-		_, ok = set.data[item]
-	}
-	set.mu.RUnlock()
-	return ok
+	set.lazyInit()
+	return set.TSet.Contains(item)
 }
 
 // Remove deletes `item` from set.
 func (set *Set) Remove(item any) {
-	set.mu.Lock()
-	if set.data != nil {
-		delete(set.data, item)
-	}
-	set.mu.Unlock()
+	set.lazyInit()
+	set.TSet.Remove(item)
 }
 
 // Size returns the size of the set.
 func (set *Set) Size() int {
-	set.mu.RLock()
-	l := len(set.data)
-	set.mu.RUnlock()
-	return l
+	set.lazyInit()
+	return set.TSet.Size()
 }
 
 // Clear deletes all items of the set.
 func (set *Set) Clear() {
-	set.mu.Lock()
-	set.data = make(map[any]struct{})
-	set.mu.Unlock()
+	set.lazyInit()
+	set.TSet.Clear()
 }
 
 // Slice returns all items of the set as slice.
 func (set *Set) Slice() []any {
-	set.mu.RLock()
-	var (
-		i   = 0
-		ret = make([]any, len(set.data))
-	)
-	for item := range set.data {
-		ret[i] = item
-		i++
-	}
-	set.mu.RUnlock()
-	return ret
+	set.lazyInit()
+	return set.TSet.Slice()
 }
 
 // Join joins items with a string `glue`.
 func (set *Set) Join(glue string) string {
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	if len(set.data) == 0 {
-		return ""
-	}
-	var (
-		l      = len(set.data)
-		i      = 0
-		buffer = bytes.NewBuffer(nil)
-	)
-	for k := range set.data {
-		buffer.WriteString(gconv.String(k))
-		if i != l-1 {
-			buffer.WriteString(glue)
-		}
-		i++
-	}
-	return buffer.String()
+	set.lazyInit()
+	return set.TSet.Join(glue)
 }
 
 // String returns items as a string, which implements like json.Marshal does.
@@ -225,63 +137,27 @@ func (set *Set) String() string {
 	if set == nil {
 		return ""
 	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	var (
-		s      string
-		l      = len(set.data)
-		i      = 0
-		buffer = bytes.NewBuffer(nil)
-	)
-	buffer.WriteByte('[')
-	for k := range set.data {
-		s = gconv.String(k)
-		if gstr.IsNumeric(s) {
-			buffer.WriteString(s)
-		} else {
-			buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
-		}
-		if i != l-1 {
-			buffer.WriteByte(',')
-		}
-		i++
-	}
-	buffer.WriteByte(']')
-	return buffer.String()
+	set.lazyInit()
+	return set.TSet.String()
 }
 
 // LockFunc locks writing with callback function `f`.
 func (set *Set) LockFunc(f func(m map[any]struct{})) {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	f(set.data)
+	set.lazyInit()
+	set.TSet.LockFunc(f)
 }
 
 // RLockFunc locks reading with callback function `f`.
 func (set *Set) RLockFunc(f func(m map[any]struct{})) {
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	f(set.data)
+	set.lazyInit()
+	set.TSet.RLockFunc(f)
 }
 
 // Equal checks whether the two sets equal.
 func (set *Set) Equal(other *Set) bool {
-	if set == other {
-		return true
-	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	if len(set.data) != len(other.data) {
-		return false
-	}
-	for key := range set.data {
-		if _, ok := other.data[key]; !ok {
-			return false
-		}
-	}
-	return true
+	set.lazyInit()
+	other.lazyInit()
+	return set.TSet.Equal(other.TSet)
 }
 
 // IsSubsetOf checks whether the current set is a sub-set of `other`.
@@ -289,85 +165,40 @@ func (set *Set) IsSubsetOf(other *Set) bool {
 	if set == other {
 		return true
 	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	for key := range set.data {
-		if _, ok := other.data[key]; !ok {
-			return false
-		}
-	}
-	return true
+
+	set.lazyInit()
+	other.lazyInit()
+
+	return set.TSet.IsSubsetOf(other.TSet)
 }
 
 // Union returns a new set which is the union of `set` and `others`.
 // Which means, all the items in `newSet` are in `set` or in `others`.
 func (set *Set) Union(others ...*Set) (newSet *Set) {
-	newSet = NewSet()
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	for _, other := range others {
-		if set != other {
-			other.mu.RLock()
-		}
-		for k, v := range set.data {
-			newSet.data[k] = v
-		}
-		if set != other {
-			for k, v := range other.data {
-				newSet.data[k] = v
-			}
-		}
-		if set != other {
-			other.mu.RUnlock()
-		}
-	}
+	set.lazyInit()
 
-	return
+	return &Set{
+		TSet: set.TSet.Union(set.toTSetSlice(others)...),
+	}
 }
 
 // Diff returns a new set which is the difference set from `set` to `others`.
 // Which means, all the items in `newSet` are in `set` but not in `others`.
 func (set *Set) Diff(others ...*Set) (newSet *Set) {
-	newSet = NewSet()
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	for _, other := range others {
-		if set == other {
-			continue
-		}
-		other.mu.RLock()
-		for k, v := range set.data {
-			if _, ok := other.data[k]; !ok {
-				newSet.data[k] = v
-			}
-		}
-		other.mu.RUnlock()
+	set.lazyInit()
+
+	return &Set{
+		TSet: set.TSet.Diff(set.toTSetSlice(others)...),
 	}
-	return
 }
 
 // Intersect returns a new set which is the intersection from `set` to `others`.
 // Which means, all the items in `newSet` are in `set` and also in `others`.
 func (set *Set) Intersect(others ...*Set) (newSet *Set) {
-	newSet = NewSet()
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	for _, other := range others {
-		if set != other {
-			other.mu.RLock()
-		}
-		for k, v := range set.data {
-			if _, ok := other.data[k]; ok {
-				newSet.data[k] = v
-			}
-		}
-		if set != other {
-			other.mu.RUnlock()
-		}
+	set.lazyInit()
+	return &Set{
+		TSet: set.TSet.Intersect(set.toTSetSlice(others)...),
 	}
-	return
 }
 
 // Complement returns a new set which is the complement from `set` to `full`.
@@ -376,36 +207,22 @@ func (set *Set) Intersect(others ...*Set) (newSet *Set) {
 // It returns the difference between `full` and `set`
 // if the given set `full` is not the full set of `set`.
 func (set *Set) Complement(full *Set) (newSet *Set) {
-	newSet = NewSet()
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	if set != full {
-		full.mu.RLock()
-		defer full.mu.RUnlock()
-	}
-	for k, v := range full.data {
-		if _, ok := set.data[k]; !ok {
-			newSet.data[k] = v
+	set.lazyInit()
+	if full == nil {
+		return &Set{
+			TSet: NewTSet[any](true),
 		}
 	}
-	return
+	full.lazyInit()
+	return &Set{
+		TSet: set.TSet.Complement(full.TSet),
+	}
 }
 
 // Merge adds items from `others` sets into `set`.
 func (set *Set) Merge(others ...*Set) *Set {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	for _, other := range others {
-		if set != other {
-			other.mu.RLock()
-		}
-		for k, v := range other.data {
-			set.data[k] = v
-		}
-		if set != other {
-			other.mu.RUnlock()
-		}
-	}
+	set.lazyInit()
+	set.TSet.Merge(set.toTSetSlice(others)...)
 	return set
 }
 
@@ -413,101 +230,46 @@ func (set *Set) Merge(others ...*Set) *Set {
 // Note: The items should be converted to int type,
 // or you'd get a result that you unexpected.
 func (set *Set) Sum() (sum int) {
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	for k := range set.data {
-		sum += gconv.Int(k)
-	}
-	return
+	set.lazyInit()
+	return set.TSet.Sum()
 }
 
 // Pop randomly pops an item from set.
 func (set *Set) Pop() any {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	for k := range set.data {
-		delete(set.data, k)
-		return k
-	}
-	return nil
+	set.lazyInit()
+	return set.TSet.Pop()
 }
 
 // Pops randomly pops `size` items from set.
 // It returns all items if size == -1.
 func (set *Set) Pops(size int) []any {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	if size > len(set.data) || size == -1 {
-		size = len(set.data)
-	}
-	if size <= 0 {
-		return nil
-	}
-	index := 0
-	array := make([]any, size)
-	for k := range set.data {
-		delete(set.data, k)
-		array[index] = k
-		index++
-		if index == size {
-			break
-		}
-	}
-	return array
+	set.lazyInit()
+	return set.TSet.Pops(size)
 }
 
 // Walk applies a user supplied function `f` to every item of set.
 func (set *Set) Walk(f func(item any) any) *Set {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	m := make(map[any]struct{}, len(set.data))
-	for k, v := range set.data {
-		m[f(k)] = v
-	}
-	set.data = m
+	set.lazyInit()
+	set.TSet.Walk(f)
 	return set
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (set Set) MarshalJSON() ([]byte, error) {
-	return json.Marshal(set.Slice())
+	set.lazyInit()
+	return set.TSet.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (set *Set) UnmarshalJSON(b []byte) error {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	if set.data == nil {
-		set.data = make(map[any]struct{})
-	}
-	var array []any
-	if err := json.UnmarshalUseNumber(b, &array); err != nil {
-		return err
-	}
-	for _, v := range array {
-		set.data[v] = struct{}{}
-	}
-	return nil
+	set.lazyInit()
+	return set.TSet.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for set.
 func (set *Set) UnmarshalValue(value any) (err error) {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	if set.data == nil {
-		set.data = make(map[any]struct{})
-	}
-	var array []any
-	switch value.(type) {
-	case string, []byte:
-		err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
-	default:
-		array = gconv.SliceAny(value)
-	}
-	for _, v := range array {
-		set.data[v] = struct{}{}
-	}
-	return
+	set.lazyInit()
+	return set.TSet.UnmarshalValue(value)
 }
 
 // DeepCopy implements interface for deep copy of current type.
@@ -515,11 +277,21 @@ func (set *Set) DeepCopy() any {
 	if set == nil {
 		return nil
 	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	data := make([]any, 0)
-	for k := range set.data {
-		data = append(data, k)
+	set.lazyInit()
+	return &Set{
+		TSet: set.TSet.DeepCopy().(*TSet[any]),
 	}
-	return NewFrom(data, set.mu.IsSafe())
+}
+
+// toTSetSlice converts []*Set to []*TSet[any]
+func (set *Set) toTSetSlice(sets []*Set) (tSets []*TSet[any]) {
+	tSets = make([]*TSet[any], len(sets))
+	for i, v := range sets {
+		if v == nil {
+			continue
+		}
+		v.lazyInit()
+		tSets[i] = v.TSet
+	}
+	return
 }
diff --git a/container/gset/gset_int_set.go b/container/gset/gset_int_set.go
index 211c7d86d..c524bc03e 100644
--- a/container/gset/gset_int_set.go
+++ b/container/gset/gset_int_set.go
@@ -8,17 +8,13 @@
 package gset
 
 import (
-	"bytes"
-
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/util/gconv"
+	"sync"
 )
 
 // IntSet is consisted of int items.
 type IntSet struct {
-	mu   rwmutex.RWMutex
-	data map[int]struct{}
+	*TSet[int]
+	once sync.Once
 }
 
 // NewIntSet create and returns a new set, which contains un-repeated items.
@@ -26,43 +22,37 @@ type IntSet struct {
 // which is false in default.
 func NewIntSet(safe ...bool) *IntSet {
 	return &IntSet{
-		mu:   rwmutex.Create(safe...),
-		data: make(map[int]struct{}),
+		TSet: NewTSet[int](safe...),
 	}
 }
 
 // NewIntSetFrom returns a new set from `items`.
 func NewIntSetFrom(items []int, safe ...bool) *IntSet {
-	m := make(map[int]struct{})
-	for _, v := range items {
-		m[v] = struct{}{}
-	}
 	return &IntSet{
-		mu:   rwmutex.Create(safe...),
-		data: m,
+		TSet: NewTSetFrom(items, safe...),
 	}
 }
 
+// lazyInit lazily initializes the set.
+func (a *IntSet) lazyInit() {
+	a.once.Do(func() {
+		if a.TSet == nil {
+			a.TSet = NewTSet[int]()
+		}
+	})
+}
+
 // Iterator iterates the set readonly with given callback function `f`,
 // if `f` returns true then continue iterating; or false to stop.
 func (set *IntSet) Iterator(f func(v int) bool) {
-	for _, k := range set.Slice() {
-		if !f(k) {
-			break
-		}
-	}
+	set.lazyInit()
+	set.TSet.Iterator(f)
 }
 
 // Add adds one or multiple items to the set.
 func (set *IntSet) Add(item ...int) {
-	set.mu.Lock()
-	if set.data == nil {
-		set.data = make(map[int]struct{})
-	}
-	for _, v := range item {
-		set.data[v] = struct{}{}
-	}
-	set.mu.Unlock()
+	set.lazyInit()
+	set.TSet.Add(item...)
 }
 
 // AddIfNotExist checks whether item exists in the set,
@@ -71,18 +61,8 @@ func (set *IntSet) Add(item ...int) {
 //
 // Note that, if `item` is nil, it does nothing and returns false.
 func (set *IntSet) AddIfNotExist(item int) bool {
-	if !set.Contains(item) {
-		set.mu.Lock()
-		defer set.mu.Unlock()
-		if set.data == nil {
-			set.data = make(map[int]struct{})
-		}
-		if _, ok := set.data[item]; !ok {
-			set.data[item] = struct{}{}
-			return true
-		}
-	}
-	return false
+	set.lazyInit()
+	return set.TSet.AddIfNotExist(item)
 }
 
 // AddIfNotExistFunc checks whether item exists in the set,
@@ -91,20 +71,8 @@ func (set *IntSet) AddIfNotExist(item int) bool {
 //
 // Note that, the function `f` is executed without writing lock.
 func (set *IntSet) AddIfNotExistFunc(item int, f func() bool) bool {
-	if !set.Contains(item) {
-		if f() {
-			set.mu.Lock()
-			defer set.mu.Unlock()
-			if set.data == nil {
-				set.data = make(map[int]struct{})
-			}
-			if _, ok := set.data[item]; !ok {
-				set.data[item] = struct{}{}
-				return true
-			}
-		}
-	}
-	return false
+	set.lazyInit()
+	return set.TSet.AddIfNotExistFunc(item, f)
 }
 
 // AddIfNotExistFuncLock checks whether item exists in the set,
@@ -113,92 +81,44 @@ func (set *IntSet) AddIfNotExistFunc(item int, f func() bool) bool {
 //
 // Note that, the function `f` is executed without writing lock.
 func (set *IntSet) AddIfNotExistFuncLock(item int, f func() bool) bool {
-	if !set.Contains(item) {
-		set.mu.Lock()
-		defer set.mu.Unlock()
-		if set.data == nil {
-			set.data = make(map[int]struct{})
-		}
-		if f() {
-			if _, ok := set.data[item]; !ok {
-				set.data[item] = struct{}{}
-				return true
-			}
-		}
-	}
-	return false
+	set.lazyInit()
+	return set.TSet.AddIfNotExistFuncLock(item, f)
 }
 
 // Contains checks whether the set contains `item`.
 func (set *IntSet) Contains(item int) bool {
-	var ok bool
-	set.mu.RLock()
-	if set.data != nil {
-		_, ok = set.data[item]
-	}
-	set.mu.RUnlock()
-	return ok
+	set.lazyInit()
+	return set.TSet.Contains(item)
 }
 
 // Remove deletes `item` from set.
 func (set *IntSet) Remove(item int) {
-	set.mu.Lock()
-	if set.data != nil {
-		delete(set.data, item)
-	}
-	set.mu.Unlock()
+	set.lazyInit()
+	set.TSet.Remove(item)
 }
 
 // Size returns the size of the set.
 func (set *IntSet) Size() int {
-	set.mu.RLock()
-	l := len(set.data)
-	set.mu.RUnlock()
-	return l
+	set.lazyInit()
+	return set.TSet.Size()
 }
 
 // Clear deletes all items of the set.
 func (set *IntSet) Clear() {
-	set.mu.Lock()
-	set.data = make(map[int]struct{})
-	set.mu.Unlock()
+	set.lazyInit()
+	set.TSet.Clear()
 }
 
 // Slice returns the an of items of the set as slice.
 func (set *IntSet) Slice() []int {
-	set.mu.RLock()
-	var (
-		i   = 0
-		ret = make([]int, len(set.data))
-	)
-	for k := range set.data {
-		ret[i] = k
-		i++
-	}
-	set.mu.RUnlock()
-	return ret
+	set.lazyInit()
+	return set.TSet.Slice()
 }
 
 // Join joins items with a string `glue`.
 func (set *IntSet) Join(glue string) string {
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	if len(set.data) == 0 {
-		return ""
-	}
-	var (
-		l      = len(set.data)
-		i      = 0
-		buffer = bytes.NewBuffer(nil)
-	)
-	for k := range set.data {
-		buffer.WriteString(gconv.String(k))
-		if i != l-1 {
-			buffer.WriteString(glue)
-		}
-		i++
-	}
-	return buffer.String()
+	set.lazyInit()
+	return set.TSet.Join(glue)
 }
 
 // String returns items as a string, which implements like json.Marshal does.
@@ -206,41 +126,27 @@ func (set *IntSet) String() string {
 	if set == nil {
 		return ""
 	}
-	return "[" + set.Join(",") + "]"
+	set.lazyInit()
+	return set.TSet.String()
 }
 
 // LockFunc locks writing with callback function `f`.
 func (set *IntSet) LockFunc(f func(m map[int]struct{})) {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	f(set.data)
+	set.lazyInit()
+	set.TSet.LockFunc(f)
 }
 
 // RLockFunc locks reading with callback function `f`.
 func (set *IntSet) RLockFunc(f func(m map[int]struct{})) {
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	f(set.data)
+	set.lazyInit()
+	set.TSet.RLockFunc(f)
 }
 
 // Equal checks whether the two sets equal.
 func (set *IntSet) Equal(other *IntSet) bool {
-	if set == other {
-		return true
-	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	if len(set.data) != len(other.data) {
-		return false
-	}
-	for key := range set.data {
-		if _, ok := other.data[key]; !ok {
-			return false
-		}
-	}
-	return true
+	set.lazyInit()
+	other.lazyInit()
+	return set.TSet.Equal(other.TSet)
 }
 
 // IsSubsetOf checks whether the current set is a sub-set of `other`.
@@ -248,85 +154,38 @@ func (set *IntSet) IsSubsetOf(other *IntSet) bool {
 	if set == other {
 		return true
 	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	for key := range set.data {
-		if _, ok := other.data[key]; !ok {
-			return false
-		}
-	}
-	return true
+
+	set.lazyInit()
+	other.lazyInit()
+
+	return set.TSet.IsSubsetOf(other.TSet)
 }
 
 // Union returns a new set which is the union of `set` and `other`.
 // Which means, all the items in `newSet` are in `set` or in `other`.
 func (set *IntSet) Union(others ...*IntSet) (newSet *IntSet) {
-	newSet = NewIntSet()
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	for _, other := range others {
-		if set != other {
-			other.mu.RLock()
-		}
-		for k, v := range set.data {
-			newSet.data[k] = v
-		}
-		if set != other {
-			for k, v := range other.data {
-				newSet.data[k] = v
-			}
-		}
-		if set != other {
-			other.mu.RUnlock()
-		}
+	set.lazyInit()
+	return &IntSet{
+		TSet: set.TSet.Union(set.toTSetSlice(others)...),
 	}
-
-	return
 }
 
 // Diff returns a new set which is the difference set from `set` to `other`.
 // Which means, all the items in `newSet` are in `set` but not in `other`.
 func (set *IntSet) Diff(others ...*IntSet) (newSet *IntSet) {
-	newSet = NewIntSet()
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	for _, other := range others {
-		if set == other {
-			continue
-		}
-		other.mu.RLock()
-		for k, v := range set.data {
-			if _, ok := other.data[k]; !ok {
-				newSet.data[k] = v
-			}
-		}
-		other.mu.RUnlock()
+	set.lazyInit()
+	return &IntSet{
+		TSet: set.TSet.Diff(set.toTSetSlice(others)...),
 	}
-	return
 }
 
 // Intersect returns a new set which is the intersection from `set` to `other`.
 // Which means, all the items in `newSet` are in `set` and also in `other`.
 func (set *IntSet) Intersect(others ...*IntSet) (newSet *IntSet) {
-	newSet = NewIntSet()
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	for _, other := range others {
-		if set != other {
-			other.mu.RLock()
-		}
-		for k, v := range set.data {
-			if _, ok := other.data[k]; ok {
-				newSet.data[k] = v
-			}
-		}
-		if set != other {
-			other.mu.RUnlock()
-		}
+	set.lazyInit()
+	return &IntSet{
+		TSet: set.TSet.Intersect(set.toTSetSlice(others)...),
 	}
-	return
 }
 
 // Complement returns a new set which is the complement from `set` to `full`.
@@ -335,36 +194,22 @@ func (set *IntSet) Intersect(others ...*IntSet) (newSet *IntSet) {
 // It returns the difference between `full` and `set`
 // if the given set `full` is not the full set of `set`.
 func (set *IntSet) Complement(full *IntSet) (newSet *IntSet) {
-	newSet = NewIntSet()
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	if set != full {
-		full.mu.RLock()
-		defer full.mu.RUnlock()
-	}
-	for k, v := range full.data {
-		if _, ok := set.data[k]; !ok {
-			newSet.data[k] = v
+	set.lazyInit()
+	if full == nil {
+		return &IntSet{
+			TSet: NewTSet[int](),
 		}
 	}
-	return
+	full.lazyInit()
+	return &IntSet{
+		TSet: set.TSet.Complement(full.TSet),
+	}
 }
 
 // Merge adds items from `others` sets into `set`.
 func (set *IntSet) Merge(others ...*IntSet) *IntSet {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	for _, other := range others {
-		if set != other {
-			other.mu.RLock()
-		}
-		for k, v := range other.data {
-			set.data[k] = v
-		}
-		if set != other {
-			other.mu.RUnlock()
-		}
-	}
+	set.lazyInit()
+	set.TSet.Merge(set.toTSetSlice(others)...)
 	return set
 }
 
@@ -372,101 +217,46 @@ func (set *IntSet) Merge(others ...*IntSet) *IntSet {
 // Note: The items should be converted to int type,
 // or you'd get a result that you unexpected.
 func (set *IntSet) Sum() (sum int) {
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	for k := range set.data {
-		sum += k
-	}
-	return
+	set.lazyInit()
+	return set.TSet.Sum()
 }
 
 // Pop randomly pops an item from set.
 func (set *IntSet) Pop() int {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	for k := range set.data {
-		delete(set.data, k)
-		return k
-	}
-	return 0
+	set.lazyInit()
+	return set.TSet.Pop()
 }
 
 // Pops randomly pops `size` items from set.
 // It returns all items if size == -1.
 func (set *IntSet) Pops(size int) []int {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	if size > len(set.data) || size == -1 {
-		size = len(set.data)
-	}
-	if size <= 0 {
-		return nil
-	}
-	index := 0
-	array := make([]int, size)
-	for k := range set.data {
-		delete(set.data, k)
-		array[index] = k
-		index++
-		if index == size {
-			break
-		}
-	}
-	return array
+	set.lazyInit()
+	return set.TSet.Pops(size)
 }
 
 // Walk applies a user supplied function `f` to every item of set.
 func (set *IntSet) Walk(f func(item int) int) *IntSet {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	m := make(map[int]struct{}, len(set.data))
-	for k, v := range set.data {
-		m[f(k)] = v
-	}
-	set.data = m
+	set.lazyInit()
+	set.TSet.Walk(f)
 	return set
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (set IntSet) MarshalJSON() ([]byte, error) {
-	return json.Marshal(set.Slice())
+	set.lazyInit()
+	return set.TSet.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (set *IntSet) UnmarshalJSON(b []byte) error {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	if set.data == nil {
-		set.data = make(map[int]struct{})
-	}
-	var array []int
-	if err := json.UnmarshalUseNumber(b, &array); err != nil {
-		return err
-	}
-	for _, v := range array {
-		set.data[v] = struct{}{}
-	}
-	return nil
+	set.lazyInit()
+	return set.TSet.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for set.
 func (set *IntSet) UnmarshalValue(value any) (err error) {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	if set.data == nil {
-		set.data = make(map[int]struct{})
-	}
-	var array []int
-	switch value.(type) {
-	case string, []byte:
-		err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
-	default:
-		array = gconv.SliceInt(value)
-	}
-	for _, v := range array {
-		set.data[v] = struct{}{}
-	}
-	return
+	set.lazyInit()
+	return set.TSet.UnmarshalValue(value)
 }
 
 // DeepCopy implements interface for deep copy of current type.
@@ -474,15 +264,21 @@ func (set *IntSet) DeepCopy() any {
 	if set == nil {
 		return nil
 	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	var (
-		slice = make([]int, len(set.data))
-		index = 0
-	)
-	for k := range set.data {
-		slice[index] = k
-		index++
+	set.lazyInit()
+	return &IntSet{
+		TSet: set.TSet.DeepCopy().(*TSet[int]),
 	}
-	return NewIntSetFrom(slice, set.mu.IsSafe())
+}
+
+// toTSetSlice converts []*IntSet to []*TSet[int]
+func (set *IntSet) toTSetSlice(sets []*IntSet) (tSets []*TSet[int]) {
+	tSets = make([]*TSet[int], len(sets))
+	for i, v := range sets {
+		if v == nil {
+			continue
+		}
+		v.lazyInit()
+		tSets[i] = v.TSet
+	}
+	return
 }
diff --git a/container/gset/gset_str_set.go b/container/gset/gset_str_set.go
index 660c85a93..3fc041996 100644
--- a/container/gset/gset_str_set.go
+++ b/container/gset/gset_str_set.go
@@ -8,19 +8,14 @@
 package gset
 
 import (
-	"bytes"
 	"strings"
-
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/text/gstr"
-	"github.com/gogf/gf/v2/util/gconv"
+	"sync"
 )
 
 // StrSet is consisted of string items.
 type StrSet struct {
-	mu   rwmutex.RWMutex
-	data map[string]struct{}
+	*TSet[string]
+	once sync.Once
 }
 
 // NewStrSet create and returns a new set, which contains un-repeated items.
@@ -28,61 +23,45 @@ type StrSet struct {
 // which is false in default.
 func NewStrSet(safe ...bool) *StrSet {
 	return &StrSet{
-		mu:   rwmutex.Create(safe...),
-		data: make(map[string]struct{}),
+		TSet: NewTSet[string](safe...),
 	}
 }
 
 // NewStrSetFrom returns a new set from `items`.
 func NewStrSetFrom(items []string, safe ...bool) *StrSet {
-	m := make(map[string]struct{})
-	for _, v := range items {
-		m[v] = struct{}{}
-	}
 	return &StrSet{
-		mu:   rwmutex.Create(safe...),
-		data: m,
+		TSet: NewTSetFrom(items, safe...),
 	}
 }
 
+// lazyInit lazily initializes the set.
+func (a *StrSet) lazyInit() {
+	a.once.Do(func() {
+		if a.TSet == nil {
+			a.TSet = NewTSet[string]()
+		}
+	})
+}
+
 // Iterator iterates the set readonly with given callback function `f`,
 // if `f` returns true then continue iterating; or false to stop.
 func (set *StrSet) Iterator(f func(v string) bool) {
-	for _, k := range set.Slice() {
-		if !f(k) {
-			break
-		}
-	}
+	set.lazyInit()
+	set.TSet.Iterator(f)
 }
 
 // Add adds one or multiple items to the set.
 func (set *StrSet) Add(item ...string) {
-	set.mu.Lock()
-	if set.data == nil {
-		set.data = make(map[string]struct{})
-	}
-	for _, v := range item {
-		set.data[v] = struct{}{}
-	}
-	set.mu.Unlock()
+	set.lazyInit()
+	set.TSet.Add(item...)
 }
 
 // AddIfNotExist checks whether item exists in the set,
 // it adds the item to set and returns true if it does not exist in the set,
 // or else it does nothing and returns false.
 func (set *StrSet) AddIfNotExist(item string) bool {
-	if !set.Contains(item) {
-		set.mu.Lock()
-		defer set.mu.Unlock()
-		if set.data == nil {
-			set.data = make(map[string]struct{})
-		}
-		if _, ok := set.data[item]; !ok {
-			set.data[item] = struct{}{}
-			return true
-		}
-	}
-	return false
+	set.lazyInit()
+	return set.TSet.AddIfNotExist(item)
 }
 
 // AddIfNotExistFunc checks whether item exists in the set,
@@ -91,20 +70,8 @@ func (set *StrSet) AddIfNotExist(item string) bool {
 //
 // Note that, the function `f` is executed without writing lock.
 func (set *StrSet) AddIfNotExistFunc(item string, f func() bool) bool {
-	if !set.Contains(item) {
-		if f() {
-			set.mu.Lock()
-			defer set.mu.Unlock()
-			if set.data == nil {
-				set.data = make(map[string]struct{})
-			}
-			if _, ok := set.data[item]; !ok {
-				set.data[item] = struct{}{}
-				return true
-			}
-		}
-	}
-	return false
+	set.lazyInit()
+	return set.TSet.AddIfNotExistFunc(item, f)
 }
 
 // AddIfNotExistFuncLock checks whether item exists in the set,
@@ -113,36 +80,20 @@ func (set *StrSet) AddIfNotExistFunc(item string, f func() bool) bool {
 //
 // Note that, the function `f` is executed without writing lock.
 func (set *StrSet) AddIfNotExistFuncLock(item string, f func() bool) bool {
-	if !set.Contains(item) {
-		set.mu.Lock()
-		defer set.mu.Unlock()
-		if set.data == nil {
-			set.data = make(map[string]struct{})
-		}
-		if f() {
-			if _, ok := set.data[item]; !ok {
-				set.data[item] = struct{}{}
-				return true
-			}
-		}
-	}
-	return false
+	set.lazyInit()
+	return set.TSet.AddIfNotExistFuncLock(item, f)
 }
 
 // Contains checks whether the set contains `item`.
 func (set *StrSet) Contains(item string) bool {
-	var ok bool
-	set.mu.RLock()
-	if set.data != nil {
-		_, ok = set.data[item]
-	}
-	set.mu.RUnlock()
-	return ok
+	set.lazyInit()
+	return set.TSet.Contains(item)
 }
 
 // ContainsI checks whether a value exists in the set with case-insensitively.
 // Note that it internally iterates the whole set to do the comparison with case-insensitively.
 func (set *StrSet) ContainsI(item string) bool {
+	set.lazyInit()
 	set.mu.RLock()
 	defer set.mu.RUnlock()
 	for k := range set.data {
@@ -155,64 +106,32 @@ func (set *StrSet) ContainsI(item string) bool {
 
 // Remove deletes `item` from set.
 func (set *StrSet) Remove(item string) {
-	set.mu.Lock()
-	if set.data != nil {
-		delete(set.data, item)
-	}
-	set.mu.Unlock()
+	set.lazyInit()
+	set.TSet.Remove(item)
 }
 
 // Size returns the size of the set.
 func (set *StrSet) Size() int {
-	set.mu.RLock()
-	l := len(set.data)
-	set.mu.RUnlock()
-	return l
+	set.lazyInit()
+	return set.TSet.Size()
 }
 
 // Clear deletes all items of the set.
 func (set *StrSet) Clear() {
-	set.mu.Lock()
-	set.data = make(map[string]struct{})
-	set.mu.Unlock()
+	set.lazyInit()
+	set.TSet.Clear()
 }
 
 // Slice returns the an of items of the set as slice.
 func (set *StrSet) Slice() []string {
-	set.mu.RLock()
-	var (
-		i   = 0
-		ret = make([]string, len(set.data))
-	)
-	for item := range set.data {
-		ret[i] = item
-		i++
-	}
-
-	set.mu.RUnlock()
-	return ret
+	set.lazyInit()
+	return set.TSet.Slice()
 }
 
 // Join joins items with a string `glue`.
 func (set *StrSet) Join(glue string) string {
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	if len(set.data) == 0 {
-		return ""
-	}
-	var (
-		l      = len(set.data)
-		i      = 0
-		buffer = bytes.NewBuffer(nil)
-	)
-	for k := range set.data {
-		buffer.WriteString(k)
-		if i != l-1 {
-			buffer.WriteString(glue)
-		}
-		i++
-	}
-	return buffer.String()
+	set.lazyInit()
+	return set.TSet.Join(glue)
 }
 
 // String returns items as a string, which implements like json.Marshal does.
@@ -220,57 +139,27 @@ func (set *StrSet) String() string {
 	if set == nil {
 		return ""
 	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	var (
-		l      = len(set.data)
-		i      = 0
-		buffer = bytes.NewBuffer(nil)
-	)
-	buffer.WriteByte('[')
-	for k := range set.data {
-		buffer.WriteString(`"` + gstr.QuoteMeta(k, `"\`) + `"`)
-		if i != l-1 {
-			buffer.WriteByte(',')
-		}
-		i++
-	}
-	buffer.WriteByte(']')
-	return buffer.String()
+	set.lazyInit()
+	return set.TSet.String()
 }
 
 // LockFunc locks writing with callback function `f`.
 func (set *StrSet) LockFunc(f func(m map[string]struct{})) {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	f(set.data)
+	set.lazyInit()
+	set.TSet.LockFunc(f)
 }
 
 // RLockFunc locks reading with callback function `f`.
 func (set *StrSet) RLockFunc(f func(m map[string]struct{})) {
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	f(set.data)
+	set.lazyInit()
+	set.TSet.RLockFunc(f)
 }
 
 // Equal checks whether the two sets equal.
 func (set *StrSet) Equal(other *StrSet) bool {
-	if set == other {
-		return true
-	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	if len(set.data) != len(other.data) {
-		return false
-	}
-	for key := range set.data {
-		if _, ok := other.data[key]; !ok {
-			return false
-		}
-	}
-	return true
+	set.lazyInit()
+	other.lazyInit()
+	return set.TSet.Equal(other.TSet)
 }
 
 // IsSubsetOf checks whether the current set is a sub-set of `other`.
@@ -278,85 +167,38 @@ func (set *StrSet) IsSubsetOf(other *StrSet) bool {
 	if set == other {
 		return true
 	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	for key := range set.data {
-		if _, ok := other.data[key]; !ok {
-			return false
-		}
-	}
-	return true
+
+	set.lazyInit()
+	other.lazyInit()
+
+	return set.TSet.IsSubsetOf(other.TSet)
 }
 
 // Union returns a new set which is the union of `set` and `other`.
 // Which means, all the items in `newSet` are in `set` or in `other`.
 func (set *StrSet) Union(others ...*StrSet) (newSet *StrSet) {
-	newSet = NewStrSet()
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	for _, other := range others {
-		if set != other {
-			other.mu.RLock()
-		}
-		for k, v := range set.data {
-			newSet.data[k] = v
-		}
-		if set != other {
-			for k, v := range other.data {
-				newSet.data[k] = v
-			}
-		}
-		if set != other {
-			other.mu.RUnlock()
-		}
+	set.lazyInit()
+	return &StrSet{
+		TSet: set.TSet.Union(set.toTSetSlice(others)...),
 	}
-
-	return
 }
 
 // Diff returns a new set which is the difference set from `set` to `other`.
 // Which means, all the items in `newSet` are in `set` but not in `other`.
 func (set *StrSet) Diff(others ...*StrSet) (newSet *StrSet) {
-	newSet = NewStrSet()
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	for _, other := range others {
-		if set == other {
-			continue
-		}
-		other.mu.RLock()
-		for k, v := range set.data {
-			if _, ok := other.data[k]; !ok {
-				newSet.data[k] = v
-			}
-		}
-		other.mu.RUnlock()
+	set.lazyInit()
+	return &StrSet{
+		TSet: set.TSet.Diff(set.toTSetSlice(others)...),
 	}
-	return
 }
 
 // Intersect returns a new set which is the intersection from `set` to `other`.
 // Which means, all the items in `newSet` are in `set` and also in `other`.
 func (set *StrSet) Intersect(others ...*StrSet) (newSet *StrSet) {
-	newSet = NewStrSet()
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	for _, other := range others {
-		if set != other {
-			other.mu.RLock()
-		}
-		for k, v := range set.data {
-			if _, ok := other.data[k]; ok {
-				newSet.data[k] = v
-			}
-		}
-		if set != other {
-			other.mu.RUnlock()
-		}
+	set.lazyInit()
+	return &StrSet{
+		TSet: set.TSet.Intersect(set.toTSetSlice(others)...),
 	}
-	return
 }
 
 // Complement returns a new set which is the complement from `set` to `full`.
@@ -365,36 +207,22 @@ func (set *StrSet) Intersect(others ...*StrSet) (newSet *StrSet) {
 // It returns the difference between `full` and `set`
 // if the given set `full` is not the full set of `set`.
 func (set *StrSet) Complement(full *StrSet) (newSet *StrSet) {
-	newSet = NewStrSet()
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	if set != full {
-		full.mu.RLock()
-		defer full.mu.RUnlock()
-	}
-	for k, v := range full.data {
-		if _, ok := set.data[k]; !ok {
-			newSet.data[k] = v
+	set.lazyInit()
+	if full == nil {
+		return &StrSet{
+			TSet: NewTSet[string](),
 		}
 	}
-	return
+	full.lazyInit()
+	return &StrSet{
+		TSet: set.TSet.Complement(full.TSet),
+	}
 }
 
 // Merge adds items from `others` sets into `set`.
 func (set *StrSet) Merge(others ...*StrSet) *StrSet {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	for _, other := range others {
-		if set != other {
-			other.mu.RLock()
-		}
-		for k, v := range other.data {
-			set.data[k] = v
-		}
-		if set != other {
-			other.mu.RUnlock()
-		}
-	}
+	set.lazyInit()
+	set.TSet.Merge(set.toTSetSlice(others)...)
 	return set
 }
 
@@ -402,101 +230,46 @@ func (set *StrSet) Merge(others ...*StrSet) *StrSet {
 // Note: The items should be converted to int type,
 // or you'd get a result that you unexpected.
 func (set *StrSet) Sum() (sum int) {
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	for k := range set.data {
-		sum += gconv.Int(k)
-	}
-	return
+	set.lazyInit()
+	return set.TSet.Sum()
 }
 
 // Pop randomly pops an item from set.
 func (set *StrSet) Pop() string {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	for k := range set.data {
-		delete(set.data, k)
-		return k
-	}
-	return ""
+	set.lazyInit()
+	return set.TSet.Pop()
 }
 
 // Pops randomly pops `size` items from set.
 // It returns all items if size == -1.
 func (set *StrSet) Pops(size int) []string {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	if size > len(set.data) || size == -1 {
-		size = len(set.data)
-	}
-	if size <= 0 {
-		return nil
-	}
-	index := 0
-	array := make([]string, size)
-	for k := range set.data {
-		delete(set.data, k)
-		array[index] = k
-		index++
-		if index == size {
-			break
-		}
-	}
-	return array
+	set.lazyInit()
+	return set.TSet.Pops(size)
 }
 
 // Walk applies a user supplied function `f` to every item of set.
 func (set *StrSet) Walk(f func(item string) string) *StrSet {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	m := make(map[string]struct{}, len(set.data))
-	for k, v := range set.data {
-		m[f(k)] = v
-	}
-	set.data = m
+	set.lazyInit()
+	set.TSet.Walk(f)
 	return set
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (set StrSet) MarshalJSON() ([]byte, error) {
-	return json.Marshal(set.Slice())
+	set.lazyInit()
+	return set.TSet.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (set *StrSet) UnmarshalJSON(b []byte) error {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	if set.data == nil {
-		set.data = make(map[string]struct{})
-	}
-	var array []string
-	if err := json.UnmarshalUseNumber(b, &array); err != nil {
-		return err
-	}
-	for _, v := range array {
-		set.data[v] = struct{}{}
-	}
-	return nil
+	set.lazyInit()
+	return set.TSet.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for set.
 func (set *StrSet) UnmarshalValue(value any) (err error) {
-	set.mu.Lock()
-	defer set.mu.Unlock()
-	if set.data == nil {
-		set.data = make(map[string]struct{})
-	}
-	var array []string
-	switch value.(type) {
-	case string, []byte:
-		err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
-	default:
-		array = gconv.SliceStr(value)
-	}
-	for _, v := range array {
-		set.data[v] = struct{}{}
-	}
-	return
+	set.lazyInit()
+	return set.TSet.UnmarshalValue(value)
 }
 
 // DeepCopy implements interface for deep copy of current type.
@@ -504,15 +277,21 @@ func (set *StrSet) DeepCopy() any {
 	if set == nil {
 		return nil
 	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	var (
-		slice = make([]string, len(set.data))
-		index = 0
-	)
-	for k := range set.data {
-		slice[index] = k
-		index++
+	set.lazyInit()
+	return &StrSet{
+		TSet: set.TSet.DeepCopy().(*TSet[string]),
 	}
-	return NewStrSetFrom(slice, set.mu.IsSafe())
+}
+
+// toTSetSlice converts []*StrSet to []*TSet[string]
+func (set *StrSet) toTSetSlice(sets []*StrSet) (tSets []*TSet[string]) {
+	tSets = make([]*TSet[string], len(sets))
+	for i, v := range sets {
+		if v == nil {
+			continue
+		}
+		v.lazyInit()
+		tSets[i] = v.TSet
+	}
+	return
 }
diff --git a/container/gset/gset_t_set.go b/container/gset/gset_t_set.go
new file mode 100644
index 000000000..15962e57e
--- /dev/null
+++ b/container/gset/gset_t_set.go
@@ -0,0 +1,575 @@
+// 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 gset
+
+import (
+	"bytes"
+
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+// NilChecker is a function that checks whether the given value is nil.
+type NilChecker[T any] func(T) bool
+
+// TSet[T] is consisted of any items.
+type TSet[T comparable] struct {
+	mu         rwmutex.RWMutex
+	data       map[T]struct{}
+	nilChecker NilChecker[T]
+}
+
+// NewTSet creates and returns a new set, which contains un-repeated items.
+// Also see New.
+func NewTSet[T comparable](safe ...bool) *TSet[T] {
+	return &TSet[T]{
+		data: make(map[T]struct{}),
+		mu:   rwmutex.Create(safe...),
+	}
+}
+
+// NewTSetWithChecker creates and returns a new set with a custom nil checker.
+// The parameter `nilChecker` is a function used to determine if a value is nil.
+// The parameter `safe` is used to specify whether using set in concurrent-safety mode.
+func NewTSetWithChecker[T comparable](checker NilChecker[T], safe ...bool) *TSet[T] {
+	s := NewTSet[T](safe...)
+	s.SetNilChecker(checker)
+	return s
+}
+
+// NewTSetFrom returns a new set from `items`.
+// `items` - A slice of type T.
+func NewTSetFrom[T comparable](items []T, safe ...bool) *TSet[T] {
+	m := make(map[T]struct{})
+	for _, v := range items {
+		m[v] = struct{}{}
+	}
+	return &TSet[T]{
+		data: m,
+		mu:   rwmutex.Create(safe...),
+	}
+}
+
+// NewTSetWithCheckerFrom returns a new set from `items` with a custom nil checker.
+// The parameter `items` is a slice of elements to be added to the set.
+// The parameter `checker` is a function used to determine if a value is nil.
+// The parameter `safe` is used to specify whether using set in concurrent-safety mode.
+func NewTSetWithCheckerFrom[T comparable](items []T, checker NilChecker[T], safe ...bool) *TSet[T] {
+	set := NewTSetWithChecker[T](checker, safe...)
+	set.Add(items...)
+	return set
+}
+
+// SetNilChecker registers a custom nil checker function for the set elements.
+// This function is used to determine if an element should be considered as nil.
+// The nil checker function takes an element of type T and returns a boolean indicating
+// whether the element should be treated as nil.
+func (set *TSet[T]) SetNilChecker(nilChecker NilChecker[T]) {
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	set.nilChecker = nilChecker
+}
+
+// isNil checks whether the given value is nil.
+// It first checks if a custom nil checker function is registered and uses it if available,
+// otherwise it falls back to the default empty.IsNil function.
+func (set *TSet[T]) isNil(v T) bool {
+	if set.nilChecker != nil {
+		return set.nilChecker(v)
+	}
+	return empty.IsNil(v)
+}
+
+// Iterator iterates the set readonly with given callback function `f`,
+// if `f` returns true then continue iterating; or false to stop.
+func (set *TSet[T]) Iterator(f func(v T) bool) {
+	for _, k := range set.Slice() {
+		if !f(k) {
+			break
+		}
+	}
+}
+
+// Add adds one or multiple items to the set.
+func (set *TSet[T]) Add(items ...T) {
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	if set.data == nil {
+		set.data = make(map[T]struct{})
+	}
+	for _, v := range items {
+		set.data[v] = struct{}{}
+	}
+}
+
+// AddIfNotExist checks whether item exists in the set,
+// it adds the item to set and returns true if it does not exist in the set,
+// or else it does nothing and returns false.
+//
+// Note that, if `item` is nil, it does nothing and returns false.
+func (set *TSet[T]) AddIfNotExist(item T) bool {
+	if set.isNil(item) {
+		return false
+	}
+	if !set.Contains(item) {
+		set.mu.Lock()
+		defer set.mu.Unlock()
+		if set.data == nil {
+			set.data = make(map[T]struct{})
+		}
+		if _, ok := set.data[item]; !ok {
+			set.data[item] = struct{}{}
+			return true
+		}
+	}
+	return false
+}
+
+// AddIfNotExistFunc checks whether item exists in the set,
+// it adds the item to set and returns true if it does not exist in the set and
+// function `f` returns true, or else it does nothing and returns false.
+//
+// Note that, if `item` is nil, it does nothing and returns false. The function `f`
+// is executed without writing lock.
+func (set *TSet[T]) AddIfNotExistFunc(item T, f func() bool) bool {
+	if set.isNil(item) {
+		return false
+	}
+	if !set.Contains(item) {
+		if f() {
+			set.mu.Lock()
+			defer set.mu.Unlock()
+			if set.data == nil {
+				set.data = make(map[T]struct{})
+			}
+			if _, ok := set.data[item]; !ok {
+				set.data[item] = struct{}{}
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// AddIfNotExistFuncLock checks whether item exists in the set,
+// it adds the item to set and returns true if it does not exists in the set and
+// function `f` returns true, or else it does nothing and returns false.
+//
+// Note that, if `item` is nil, it does nothing and returns false. The function `f`
+// is executed within writing lock.
+func (set *TSet[T]) AddIfNotExistFuncLock(item T, f func() bool) bool {
+	if set.isNil(item) {
+		return false
+	}
+	if !set.Contains(item) {
+		set.mu.Lock()
+		defer set.mu.Unlock()
+		if set.data == nil {
+			set.data = make(map[T]struct{})
+		}
+		if f() {
+			if _, ok := set.data[item]; !ok {
+				set.data[item] = struct{}{}
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// Contains checks whether the set contains `item`.
+func (set *TSet[T]) Contains(item T) bool {
+	var ok bool
+	set.mu.RLock()
+	if set.data != nil {
+		_, ok = set.data[item]
+	}
+	set.mu.RUnlock()
+	return ok
+}
+
+// Remove deletes `item` from set.
+func (set *TSet[T]) Remove(item T) {
+	set.mu.Lock()
+	if set.data != nil {
+		delete(set.data, item)
+	}
+	set.mu.Unlock()
+}
+
+// Size returns the size of the set.
+func (set *TSet[T]) Size() int {
+	set.mu.RLock()
+	l := len(set.data)
+	set.mu.RUnlock()
+	return l
+}
+
+// Clear deletes all items of the set.
+func (set *TSet[T]) Clear() {
+	set.mu.Lock()
+	set.data = make(map[T]struct{})
+	set.mu.Unlock()
+}
+
+// Slice returns all items of the set as slice.
+func (set *TSet[T]) Slice() []T {
+	set.mu.RLock()
+	var (
+		i   = 0
+		ret = make([]T, len(set.data))
+	)
+	for item := range set.data {
+		ret[i] = item
+		i++
+	}
+	set.mu.RUnlock()
+	return ret
+}
+
+// Join joins items with a string `glue`.
+func (set *TSet[T]) Join(glue string) string {
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	if len(set.data) == 0 {
+		return ""
+	}
+	var (
+		l      = len(set.data)
+		i      = 0
+		buffer = bytes.NewBuffer(nil)
+	)
+	for k := range set.data {
+		buffer.WriteString(gconv.String(k))
+		if i != l-1 {
+			buffer.WriteString(glue)
+		}
+		i++
+	}
+	return buffer.String()
+}
+
+// String returns items as a string, which implements like json.Marshal does.
+func (set *TSet[T]) String() string {
+	if set == nil {
+		return ""
+	}
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	var (
+		s      string
+		l      = len(set.data)
+		i      = 0
+		buffer = bytes.NewBuffer(nil)
+	)
+	buffer.WriteByte('[')
+	for k := range set.data {
+		s = gconv.String(k)
+		if gstr.IsNumeric(s) {
+			buffer.WriteString(s)
+		} else {
+			buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
+		}
+		if i != l-1 {
+			buffer.WriteByte(',')
+		}
+		i++
+	}
+	buffer.WriteByte(']')
+	return buffer.String()
+}
+
+// LockFunc locks writing with callback function `f`.
+func (set *TSet[T]) LockFunc(f func(m map[T]struct{})) {
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	f(set.data)
+}
+
+// RLockFunc locks reading with callback function `f`.
+func (set *TSet[T]) RLockFunc(f func(m map[T]struct{})) {
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	f(set.data)
+}
+
+// Equal checks whether the two sets equal.
+func (set *TSet[T]) Equal(other *TSet[T]) bool {
+	if set == other {
+		return true
+	}
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+	if len(set.data) != len(other.data) {
+		return false
+	}
+	for key := range set.data {
+		if _, ok := other.data[key]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+// IsSubsetOf checks whether the current set is a sub-set of `other`.
+func (set *TSet[T]) IsSubsetOf(other *TSet[T]) bool {
+	if set == other {
+		return true
+	}
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+	for key := range set.data {
+		if _, ok := other.data[key]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+// Union returns a new set which is the union of `set` and `others`.
+// Which means, all the items in `newSet` are in `set` or in `others`.
+func (set *TSet[T]) Union(others ...*TSet[T]) (newSet *TSet[T]) {
+	newSet = NewTSet[T]()
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for _, other := range others {
+		if other == nil {
+			continue
+		}
+		if set != other {
+			other.mu.RLock()
+		}
+		for k, v := range set.data {
+			newSet.data[k] = v
+		}
+		if set != other {
+			for k, v := range other.data {
+				newSet.data[k] = v
+			}
+		}
+		if set != other {
+			other.mu.RUnlock()
+		}
+	}
+
+	return
+}
+
+// Diff returns a new set which is the difference set from `set` to `others`.
+// Which means, all the items in `newSet` are in `set` but not in `others`.
+func (set *TSet[T]) Diff(others ...*TSet[T]) (newSet *TSet[T]) {
+	newSet = NewTSet[T]()
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for _, other := range others {
+		if other == nil {
+			continue
+		}
+		if set == other {
+			continue
+		}
+		other.mu.RLock()
+		for k, v := range set.data {
+			if _, ok := other.data[k]; !ok {
+				newSet.data[k] = v
+			}
+		}
+		other.mu.RUnlock()
+	}
+	return
+}
+
+// Intersect returns a new set which is the intersection from `set` to `others`.
+// Which means, all the items in `newSet` are in `set` and also in `others`.
+func (set *TSet[T]) Intersect(others ...*TSet[T]) (newSet *TSet[T]) {
+	newSet = NewTSet[T]()
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for _, other := range others {
+		if other == nil {
+			continue
+		}
+		if set != other {
+			other.mu.RLock()
+		}
+		for k, v := range set.data {
+			if _, ok := other.data[k]; ok {
+				newSet.data[k] = v
+			}
+		}
+		if set != other {
+			other.mu.RUnlock()
+		}
+	}
+	return
+}
+
+// Complement returns a new set which is the complement from `set` to `full`.
+// Which means, all the items in `newSet` are in `full` and not in `set`.
+//
+// It returns the difference between `full` and `set`
+// if the given set `full` is not the full set of `set`.
+func (set *TSet[T]) Complement(full *TSet[T]) (newSet *TSet[T]) {
+	newSet = NewTSet[T]()
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	if set != full {
+		full.mu.RLock()
+		defer full.mu.RUnlock()
+	}
+	for k, v := range full.data {
+		if _, ok := set.data[k]; !ok {
+			newSet.data[k] = v
+		}
+	}
+	return
+}
+
+// Merge adds items from `others` sets into `set`.
+func (set *TSet[T]) Merge(others ...*TSet[T]) *TSet[T] {
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	for _, other := range others {
+		if other == nil {
+			continue
+		}
+		if set != other {
+			other.mu.RLock()
+		}
+		for k, v := range other.data {
+			set.data[k] = v
+		}
+		if set != other {
+			other.mu.RUnlock()
+		}
+	}
+	return set
+}
+
+// Sum sums items.
+// Note: The items should be converted to int type,
+// or you'd get a result that you unexpected.
+func (set *TSet[T]) Sum() (sum int) {
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for k := range set.data {
+		sum += gconv.Int(k)
+	}
+	return
+}
+
+// Pop randomly pops an item from set.
+func (set *TSet[T]) Pop() (item T) {
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	for k := range set.data {
+		delete(set.data, k)
+		return k
+	}
+	return
+}
+
+// Pops randomly pops `size` items from set.
+// It returns all items if size == -1.
+func (set *TSet[T]) Pops(size int) []T {
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	if size > len(set.data) || size == -1 {
+		size = len(set.data)
+	}
+	if size <= 0 {
+		return nil
+	}
+	index := 0
+	array := make([]T, size)
+	for k := range set.data {
+		delete(set.data, k)
+		array[index] = k
+		index++
+		if index == size {
+			break
+		}
+	}
+	return array
+}
+
+// Walk applies a user supplied function `f` to every item of set.
+func (set *TSet[T]) Walk(f func(item T) T) *TSet[T] {
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	m := make(map[T]struct{}, len(set.data))
+	for k, v := range set.data {
+		m[f(k)] = v
+	}
+	set.data = m
+	return set
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (set TSet[T]) MarshalJSON() ([]byte, error) {
+	return json.Marshal(set.Slice())
+}
+
+// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
+func (set *TSet[T]) UnmarshalJSON(b []byte) error {
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	if set.data == nil {
+		set.data = make(map[T]struct{})
+	}
+	var array []T
+	if err := json.UnmarshalUseNumber(b, &array); err != nil {
+		return err
+	}
+	for _, v := range array {
+		set.data[v] = struct{}{}
+	}
+	return nil
+}
+
+// UnmarshalValue is an interface implement which sets any type of value for set.
+func (set *TSet[T]) UnmarshalValue(value any) (err error) {
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	if set.data == nil {
+		set.data = make(map[T]struct{})
+	}
+	var array []T
+	switch value.(type) {
+	case string, []byte:
+		err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
+	default:
+		if err = gconv.Scan(value, &array); err != nil {
+			return
+		}
+	}
+	for _, v := range array {
+		set.data[v] = struct{}{}
+	}
+	return
+}
+
+// DeepCopy implements interface for deep copy of current type.
+func (set *TSet[T]) DeepCopy() any {
+	if set == nil {
+		return nil
+	}
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	data := make([]T, 0)
+	for k := range set.data {
+		data = append(data, k)
+	}
+	return NewTSetFrom[T](data, set.mu.IsSafe())
+}
diff --git a/container/gset/gset_z_example_any_test.go b/container/gset/gset_z_example_any_test.go
index 8592ae852..0c786e5f7 100644
--- a/container/gset/gset_z_example_any_test.go
+++ b/container/gset/gset_z_example_any_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gset_test
diff --git a/container/gset/gset_z_example_int_test.go b/container/gset/gset_z_example_int_test.go
index 2462f472b..69f41dc6a 100644
--- a/container/gset/gset_z_example_int_test.go
+++ b/container/gset/gset_z_example_int_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gset_test
diff --git a/container/gset/gset_z_example_str_test.go b/container/gset/gset_z_example_str_test.go
index 9bcc5d58b..58eff8591 100644
--- a/container/gset/gset_z_example_str_test.go
+++ b/container/gset/gset_z_example_str_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gset_test
diff --git a/container/gset/gset_z_unit_any_test.go b/container/gset/gset_z_unit_any_test.go
index 39ab7fb8a..5f5460640 100644
--- a/container/gset/gset_z_unit_any_test.go
+++ b/container/gset/gset_z_unit_any_test.go
@@ -187,6 +187,19 @@ func TestSet_Union(t *testing.T) {
 		t.Assert(s3.Contains(3), true)
 		t.Assert(s3.Contains(4), true)
 	})
+
+	// Test with nil element in slice
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s1.Add(1, 2)
+		s2.Add(3, 4)
+		s3 := s1.Union(s2, nil)
+		t.Assert(s3.Contains(1), true)
+		t.Assert(s3.Contains(2), true)
+		t.Assert(s3.Contains(3), true)
+		t.Assert(s3.Contains(4), true)
+	})
 }
 
 func TestSet_Diff(t *testing.T) {
@@ -236,6 +249,14 @@ func TestSet_Complement(t *testing.T) {
 		t.Assert(s3.Contains(4), true)
 		t.Assert(s3.Contains(5), true)
 	})
+
+	// Test with nil full set
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewSet()
+		s1.Add(1, 2, 3)
+		s3 := s1.Complement(nil)
+		t.Assert(s3.Size(), 0)
+	})
 }
 
 func TestNewFrom(t *testing.T) {
diff --git a/container/gset/gset_z_unit_int_test.go b/container/gset/gset_z_unit_int_test.go
index 9dcc4b3be..de315efa2 100644
--- a/container/gset/gset_z_unit_int_test.go
+++ b/container/gset/gset_z_unit_int_test.go
@@ -167,6 +167,19 @@ func TestIntSet_Union(t *testing.T) {
 		t.Assert(s3.Contains(3), true)
 		t.Assert(s3.Contains(4), true)
 	})
+
+	// Test with nil element in slice
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s1.Add(1, 2)
+		s2.Add(3, 4)
+		s3 := s1.Union(s2, nil)
+		t.Assert(s3.Contains(1), true)
+		t.Assert(s3.Contains(2), true)
+		t.Assert(s3.Contains(3), true)
+		t.Assert(s3.Contains(4), true)
+	})
 }
 
 func TestIntSet_Diff(t *testing.T) {
@@ -216,6 +229,14 @@ func TestIntSet_Complement(t *testing.T) {
 		t.Assert(s3.Contains(4), true)
 		t.Assert(s3.Contains(5), true)
 	})
+
+	// Test with nil full set
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewIntSet()
+		s1.Add(1, 2, 3)
+		s3 := s1.Complement(nil)
+		t.Assert(s3.Size(), 0)
+	})
 }
 
 func TestIntSet_Size(t *testing.T) {
diff --git a/container/gset/gset_z_unit_str_test.go b/container/gset/gset_z_unit_str_test.go
index d5da71ab5..3a7202d17 100644
--- a/container/gset/gset_z_unit_str_test.go
+++ b/container/gset/gset_z_unit_str_test.go
@@ -178,6 +178,19 @@ func TestStrSet_Union(t *testing.T) {
 		t.Assert(s3.Contains("3"), true)
 		t.Assert(s3.Contains("4"), true)
 	})
+
+	// Test with nil element in slice
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewStrSet()
+		s2 := gset.NewStrSet()
+		s1.Add("1", "2")
+		s2.Add("3", "4")
+		s3 := s1.Union(s2, nil)
+		t.Assert(s3.Contains("1"), true)
+		t.Assert(s3.Contains("2"), true)
+		t.Assert(s3.Contains("3"), true)
+		t.Assert(s3.Contains("4"), true)
+	})
 }
 
 func TestStrSet_Diff(t *testing.T) {
@@ -227,6 +240,14 @@ func TestStrSet_Complement(t *testing.T) {
 		t.Assert(s3.Contains("4"), true)
 		t.Assert(s3.Contains("5"), true)
 	})
+
+	// Test with nil full set
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewStrSet()
+		s1.Add("1", "2", "3")
+		s3 := s1.Complement(nil)
+		t.Assert(s3.Size(), 0)
+	})
 }
 
 func TestNewIntSetFrom(t *testing.T) {
diff --git a/container/gset/gset_z_unit_t_set_test.go b/container/gset/gset_z_unit_t_set_test.go
new file mode 100644
index 000000000..66cfb326b
--- /dev/null
+++ b/container/gset/gset_z_unit_t_set_test.go
@@ -0,0 +1,632 @@
+// 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 gset_test
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/gset"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func TestTSet_New(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		s.Add(1, 1, 2)
+		s.Add([]int{3, 4}...)
+		t.Assert(s.Size(), 4)
+		t.AssertIN(1, s.Slice())
+		t.AssertIN(2, s.Slice())
+		t.AssertIN(3, s.Slice())
+		t.AssertIN(4, s.Slice())
+		t.AssertNI(0, s.Slice())
+		t.Assert(s.Contains(4), true)
+		t.Assert(s.Contains(5), false)
+		s.Remove(1)
+		t.Assert(s.Size(), 3)
+		s.Clear()
+		t.Assert(s.Size(), 0)
+	})
+}
+
+func TestTSet_NewFrom(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3}, true)
+		t.Assert(s.Size(), 3)
+		t.Assert(s.Contains(1), true)
+		t.Assert(s.Contains(2), true)
+		t.Assert(s.Contains(3), true)
+		t.Assert(s.Contains(4), false)
+	})
+}
+
+func TestTSet_Add_NilData(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var s gset.TSet[int]
+		s.Add(1, 2, 3)
+		t.Assert(s.Size(), 3)
+		t.Assert(s.Contains(1), true)
+	})
+}
+
+func TestTSet_AddIfNotExist(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int](true)
+		s.Add(1)
+		t.Assert(s.Contains(1), true)
+		t.Assert(s.AddIfNotExist(1), false)
+		t.Assert(s.AddIfNotExist(2), true)
+		t.Assert(s.Contains(2), true)
+		t.Assert(s.AddIfNotExist(2), false)
+	})
+
+	// Test with pointer type to test nil check
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[*int](true)
+
+		val := 1
+		ptr := &val
+		t.Assert(s.AddIfNotExist(ptr), true)
+		t.Assert(s.AddIfNotExist(ptr), false)
+	})
+
+	// Test nil data map initialization
+	gtest.C(t, func(t *gtest.T) {
+		var s gset.TSet[int]
+		t.Assert(s.AddIfNotExist(1), true)
+		t.Assert(s.Size(), 1)
+	})
+}
+
+func TestTSet_AddIfNotExistFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int](true)
+		s.Add(1)
+		t.Assert(s.Contains(1), true)
+		t.Assert(s.Contains(2), false)
+		t.Assert(s.AddIfNotExistFunc(2, func() bool { return false }), false)
+		t.Assert(s.Contains(2), false)
+		t.Assert(s.AddIfNotExistFunc(2, func() bool { return true }), true)
+		t.Assert(s.Contains(2), true)
+		t.Assert(s.AddIfNotExistFunc(2, func() bool { return true }), false)
+		t.Assert(s.Contains(2), true)
+	})
+
+	// Test concurrent scenario
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int](true)
+		wg := sync.WaitGroup{}
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			r := s.AddIfNotExistFunc(1, func() bool {
+				time.Sleep(100 * time.Millisecond)
+				return true
+			})
+			t.Assert(r, false)
+		}()
+		s.Add(1)
+		wg.Wait()
+	})
+
+	// Test nil data map initialization
+	gtest.C(t, func(t *gtest.T) {
+		var s gset.TSet[int]
+		t.Assert(s.AddIfNotExistFunc(1, func() bool { return true }), true)
+		t.Assert(s.Size(), 1)
+	})
+}
+
+func TestTSet_AddIfNotExistFuncLock(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int](true)
+		s.Add(1)
+		t.Assert(s.Contains(1), true)
+		t.Assert(s.Contains(2), false)
+		t.Assert(s.AddIfNotExistFuncLock(2, func() bool { return false }), false)
+		t.Assert(s.Contains(2), false)
+		t.Assert(s.AddIfNotExistFuncLock(2, func() bool { return true }), true)
+		t.Assert(s.Contains(2), true)
+		t.Assert(s.AddIfNotExistFuncLock(2, func() bool { return true }), false)
+		t.Assert(s.Contains(2), true)
+	})
+
+	// Test nil data map initialization
+	gtest.C(t, func(t *gtest.T) {
+		var s gset.TSet[int]
+		t.Assert(s.AddIfNotExistFuncLock(1, func() bool { return true }), true)
+		t.Assert(s.Size(), 1)
+	})
+}
+
+func TestTSet_Iterator(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3, 4, 5}, true)
+		var sum int
+		s.Iterator(func(v int) bool {
+			sum += v
+			return true
+		})
+		t.Assert(sum, 15)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3, 4, 5}, true)
+		var count int
+		s.Iterator(func(v int) bool {
+			count++
+			return count < 3
+		})
+		t.Assert(count, 3)
+	})
+}
+
+func TestTSet_Join(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		t.Assert(s.Join(","), "")
+		s.Add(1, 2, 3)
+		result := s.Join(",")
+		t.Assert(len(result) > 0, true)
+	})
+}
+
+func TestTSet_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var s *gset.TSet[int]
+		t.Assert(s.String(), "")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		t.Assert(s.String(), "[]")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		result := s.String()
+		t.Assert(len(result) > 2, true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[string]([]string{"a", "b", "c"})
+		result := s.String()
+		t.Assert(len(result) > 2, true)
+	})
+}
+
+func TestTSet_Equal(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s2 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		t.Assert(s1.Equal(s2), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s2 := gset.NewTSetFrom[int]([]int{1, 2, 3, 4})
+		t.Assert(s1.Equal(s2), false)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		t.Assert(s1.Equal(s1), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s2 := gset.NewTSetFrom[int]([]int{1, 2, 4})
+		t.Assert(s1.Equal(s2), false)
+	})
+}
+
+func TestTSet_IsSubsetOf(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2})
+		s2 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		t.Assert(s1.IsSubsetOf(s2), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s2 := gset.NewTSetFrom[int]([]int{1, 2})
+		t.Assert(s1.IsSubsetOf(s2), false)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		t.Assert(s1.IsSubsetOf(s1), true)
+	})
+}
+
+func TestTSet_Union(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s2 := gset.NewTSetFrom[int]([]int{3, 4, 5})
+		s := s1.Union(s2)
+		t.Assert(s.Size(), 5)
+		t.Assert(s.Contains(1), true)
+		t.Assert(s.Contains(2), true)
+		t.Assert(s.Contains(3), true)
+		t.Assert(s.Contains(4), true)
+		t.Assert(s.Contains(5), true)
+	})
+
+	// Test with nil set - should skip it and copy s1 data
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		var s2 *gset.TSet[int]
+		s := s1.Union(s2)
+		// Since s2 is nil and skipped, newSet will be empty
+		// because the loop runs but nothing is copied when other is nil
+		t.Assert(s.Size(), 0)
+	})
+
+	// Test with self
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s := s1.Union(s1)
+		t.Assert(s.Size(), 3)
+	})
+}
+
+func TestTSet_Diff(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s2 := gset.NewTSetFrom[int]([]int{3, 4, 5})
+		s := s1.Diff(s2)
+		t.Assert(s.Size(), 2)
+		t.Assert(s.Contains(1), true)
+		t.Assert(s.Contains(2), true)
+		t.Assert(s.Contains(3), false)
+	})
+
+	// Test with nil set - should skip it
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		var s2 *gset.TSet[int]
+		s := s1.Diff(s2)
+		// Since s2 is nil and skipped, newSet will be empty
+		// because the loop runs but nothing is copied when other is nil
+		t.Assert(s.Size(), 0)
+	})
+
+	// Test with self
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s := s1.Diff(s1)
+		t.Assert(s.Size(), 0)
+	})
+}
+
+func TestTSet_Intersect(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s2 := gset.NewTSetFrom[int]([]int{3, 4, 5})
+		s := s1.Intersect(s2)
+		t.Assert(s.Size(), 1)
+		t.Assert(s.Contains(3), true)
+	})
+
+	// Test with nil set
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		var s2 *gset.TSet[int]
+		s := s1.Intersect(s2)
+		t.Assert(s.Size(), 0)
+	})
+
+	// Test with self
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s := s1.Intersect(s1)
+		t.Assert(s.Size(), 3)
+	})
+}
+
+func TestTSet_Complement(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s2 := gset.NewTSetFrom[int]([]int{1, 2, 3, 4, 5})
+		s := s1.Complement(s2)
+		t.Assert(s.Size(), 2)
+		t.Assert(s.Contains(4), true)
+		t.Assert(s.Contains(5), true)
+	})
+
+	// Test with self
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s := s1.Complement(s1)
+		t.Assert(s.Size(), 0)
+	})
+}
+
+func TestTSet_Merge(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s2 := gset.NewTSetFrom[int]([]int{3, 4, 5})
+		s1.Merge(s2)
+		t.Assert(s1.Size(), 5)
+		t.Assert(s1.Contains(1), true)
+		t.Assert(s1.Contains(2), true)
+		t.Assert(s1.Contains(3), true)
+		t.Assert(s1.Contains(4), true)
+		t.Assert(s1.Contains(5), true)
+	})
+
+	// Test with nil set
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		var s2 *gset.TSet[int]
+		s1.Merge(s2)
+		t.Assert(s1.Size(), 3)
+	})
+
+	// Test with self
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		s1.Merge(s1)
+		t.Assert(s1.Size(), 3)
+	})
+}
+
+func TestTSet_Sum(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		t.Assert(s.Sum(), 6)
+	})
+}
+
+func TestTSet_Pop(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		item := s.Pop()
+		t.Assert(s.Size(), 2)
+		t.Assert(s.Contains(item), false)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		item := s.Pop()
+		t.Assert(item, 0)
+	})
+}
+
+func TestTSet_Pops(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3, 4, 5})
+		items := s.Pops(3)
+		t.Assert(len(items), 3)
+		t.Assert(s.Size(), 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		items := s.Pops(-1)
+		t.Assert(len(items), 3)
+		t.Assert(s.Size(), 0)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		items := s.Pops(0)
+		t.Assert(items, nil)
+		t.Assert(s.Size(), 3)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		items := s.Pops(10)
+		t.Assert(len(items), 3)
+		t.Assert(s.Size(), 0)
+	})
+}
+
+func TestTSet_Walk(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2})
+		s.Walk(func(item int) int {
+			return item + 10
+		})
+		t.Assert(s.Size(), 2)
+		t.Assert(s.Contains(11), true)
+		t.Assert(s.Contains(12), true)
+	})
+}
+
+func TestTSet_MarshalJSON(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3})
+		b, err := json.Marshal(s)
+		t.AssertNil(err)
+		t.Assert(len(b) > 0, true)
+	})
+}
+
+func TestTSet_UnmarshalJSON(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		b := []byte(`[1,2,3]`)
+		err := json.UnmarshalUseNumber(b, &s)
+		t.AssertNil(err)
+		t.Assert(s.Size(), 3)
+		t.Assert(s.Contains(1), true)
+		t.Assert(s.Contains(2), true)
+		t.Assert(s.Contains(3), true)
+	})
+
+	// Test with nil data map
+	gtest.C(t, func(t *gtest.T) {
+		var s gset.TSet[int]
+		b := []byte(`[1,2,3]`)
+		err := json.UnmarshalUseNumber(b, &s)
+		t.AssertNil(err)
+		t.Assert(s.Size(), 3)
+	})
+
+	// Test with invalid JSON
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		b := []byte(`{invalid}`)
+		err := json.UnmarshalUseNumber(b, &s)
+		t.AssertNE(err, nil)
+	})
+
+	// Test with empty array
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		b := []byte(`[]`)
+		err := json.UnmarshalUseNumber(b, &s)
+		t.AssertNil(err)
+		t.Assert(s.Size(), 0)
+	})
+}
+
+func TestTSet_UnmarshalValue(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		err := s.UnmarshalValue([]byte(`[1,2,3]`))
+		t.AssertNil(err)
+		t.Assert(s.Size(), 3)
+		t.Assert(s.Contains(1), true)
+		t.Assert(s.Contains(2), true)
+		t.Assert(s.Contains(3), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		err := s.UnmarshalValue(`[1,2,3]`)
+		t.AssertNil(err)
+		t.Assert(s.Size(), 3)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		err := s.UnmarshalValue([]int{1, 2, 3})
+		t.AssertNil(err)
+		t.Assert(s.Size(), 3)
+	})
+
+	// Test with nil data map
+	gtest.C(t, func(t *gtest.T) {
+		var s gset.TSet[int]
+		err := s.UnmarshalValue([]int{1, 2, 3})
+		t.AssertNil(err)
+		t.Assert(s.Size(), 3)
+	})
+
+	// Test error case with invalid JSON
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		err := s.UnmarshalValue([]byte(`{invalid}`))
+		t.AssertNE(err, nil)
+	})
+
+	// Test with empty array for string/bytes case
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		err := s.UnmarshalValue([]byte(`[]`))
+		t.AssertNil(err)
+		t.Assert(s.Size(), 0)
+	})
+
+	// Test with empty slice for default case
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSet[int]()
+		err := s.UnmarshalValue([]int{})
+		t.AssertNil(err)
+		t.Assert(s.Size(), 0)
+	})
+}
+
+func TestTSet_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := gset.NewTSetFrom[int]([]int{1, 2, 3}, true)
+		s2 := s1.DeepCopy().(*gset.TSet[int])
+		t.Assert(s1.Size(), s2.Size())
+		t.Assert(s1.Contains(1), s2.Contains(1))
+		t.Assert(s1.Contains(2), s2.Contains(2))
+		t.Assert(s1.Contains(3), s2.Contains(3))
+
+		s1.Add(4)
+		t.Assert(s1.Size(), 4)
+		t.Assert(s2.Size(), 3)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		var s1 *gset.TSet[int]
+		s2 := s1.DeepCopy()
+		t.Assert(s2, nil)
+	})
+}
+
+func TestTSet_LockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3}, true)
+		s.LockFunc(func(m map[int]struct{}) {
+			m[4] = struct{}{}
+		})
+		t.Assert(s.Size(), 4)
+		t.Assert(s.Contains(4), true)
+	})
+}
+
+func TestTSet_RLockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := gset.NewTSetFrom[int]([]int{1, 2, 3}, true)
+		var sum int
+		s.RLockFunc(func(m map[int]struct{}) {
+			for k := range m {
+				sum += k
+			}
+		})
+		t.Assert(sum, 6)
+	})
+}
+
+func Test_TSet_TypedNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type Student struct {
+			Name string
+			Age  int
+		}
+		set := gset.NewTSet[*Student](true)
+		var s *Student = nil
+		exist := set.AddIfNotExist(s)
+		t.Assert(exist, false)
+
+		set2 := gset.NewTSet[*Student](true)
+		set2.SetNilChecker(func(student *Student) bool {
+			return student == nil
+		})
+		exist2 := set2.AddIfNotExist(s)
+		t.Assert(exist2, false)
+	})
+}
+
+func Test_NewTSetWithChecker_TypedNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type Student struct {
+			Name string
+			Age  int
+		}
+		set := gset.NewTSet[*Student](true)
+		var s *Student = nil
+		exist := set.AddIfNotExist(s)
+		t.Assert(exist, false)
+
+		set2 := gset.NewTSetWithChecker[*Student](func(student *Student) bool {
+			return student == nil
+		}, true)
+		exist2 := set2.AddIfNotExist(s)
+		t.Assert(exist2, false)
+	})
+}
diff --git a/container/gtree/gtree.go b/container/gtree/gtree.go
index 461756c2b..29287da56 100644
--- a/container/gtree/gtree.go
+++ b/container/gtree/gtree.go
@@ -162,12 +162,12 @@ type iTree interface {
 	IteratorDescFrom(key any, match bool, f func(key, value any) bool)
 }
 
-// iteratorFromGetIndex returns the index of the key in the keys slice.
+// iteratorFromGetIndexT returns the index of the key in the keys slice.
 //
 // The parameter `match` specifies whether starting iterating only if the `key` is fully matched,
 // or else using index searching iterating.
 // If `isIterator` is true, iterator is available; or else not.
-func iteratorFromGetIndex(key any, keys []any, match bool) (index int, canIterator bool) {
+func iteratorFromGetIndexT[T comparable](key T, keys []T, match bool) (index int, canIterator bool) {
 	if match {
 		for i, k := range keys {
 			if k == key {
@@ -176,10 +176,19 @@ func iteratorFromGetIndex(key any, keys []any, match bool) (index int, canIterat
 			}
 		}
 	} else {
-		if i, ok := key.(int); ok {
+		if i, ok := any(key).(int); ok {
 			canIterator = true
 			index = i
 		}
 	}
 	return
 }
+
+// iteratorFromGetIndex returns the index of the key in the keys slice.
+//
+// The parameter `match` specifies whether starting iterating only if the `key` is fully matched,
+// or else using index searching iterating.
+// If `isIterator` is true, iterator is available; or else not.
+func iteratorFromGetIndex(key any, keys []any, match bool) (index int, canIterator bool) {
+	return iteratorFromGetIndexT(key, keys, match)
+}
diff --git a/container/gtree/gtree_avltree.go b/container/gtree/gtree_avltree.go
index 0d21c131e..5835d6bbd 100644
--- a/container/gtree/gtree_avltree.go
+++ b/container/gtree/gtree_avltree.go
@@ -7,31 +7,22 @@
 package gtree
 
 import (
-	"fmt"
-
-	"github.com/emirpasic/gods/trees/avltree"
+	"sync"
 
 	"github.com/gogf/gf/v2/container/gvar"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/text/gstr"
-	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gutil"
 )
 
 var _ iTree = (*AVLTree)(nil)
 
 // AVLTree holds elements of the AVL tree.
 type AVLTree struct {
-	mu         rwmutex.RWMutex
-	root       *AVLTreeNode
-	comparator func(v1, v2 any) int
-	tree       *avltree.Tree
+	*AVLKVTree[any, any]
+	once sync.Once
 }
 
 // AVLTreeNode is a single element within the tree.
-type AVLTreeNode struct {
-	Key   any
-	Value any
-}
+type AVLTreeNode = AVLKVTreeNode[any, any]
 
 // NewAVLTree instantiates an AVL tree with the custom key comparator.
 //
@@ -39,9 +30,7 @@ type AVLTreeNode struct {
 // which is false in default.
 func NewAVLTree(comparator func(v1, v2 any) int, safe ...bool) *AVLTree {
 	return &AVLTree{
-		mu:         rwmutex.Create(safe...),
-		comparator: comparator,
-		tree:       avltree.NewWith(comparator),
+		AVLKVTree: NewAVLKVTree[any, any](comparator, safe...),
 	}
 }
 
@@ -49,58 +38,55 @@ func NewAVLTree(comparator func(v1, v2 any) int, safe ...bool) *AVLTree {
 //
 // The parameter `safe` is used to specify whether using tree in concurrent-safety, which is false in default.
 func NewAVLTreeFrom(comparator func(v1, v2 any) int, data map[any]any, safe ...bool) *AVLTree {
-	tree := NewAVLTree(comparator, safe...)
-	for k, v := range data {
-		tree.doSet(k, v)
+	return &AVLTree{
+		AVLKVTree: NewAVLKVTreeFrom(comparator, data, safe...),
 	}
-	return tree
+}
+
+// lazyInit lazily initializes the tree.
+func (tree *AVLTree) lazyInit() {
+	tree.once.Do(func() {
+		if tree.AVLKVTree == nil {
+			tree.AVLKVTree = NewAVLKVTree[any, any](gutil.ComparatorTStr, false)
+		}
+	})
 }
 
 // Clone clones and returns a new tree from current tree.
 func (tree *AVLTree) Clone() *AVLTree {
-	newTree := NewAVLTree(tree.comparator, tree.mu.IsSafe())
-	newTree.Sets(tree.Map())
-	return newTree
+	if tree == nil {
+		return nil
+	}
+	tree.lazyInit()
+	return &AVLTree{
+		AVLKVTree: tree.AVLKVTree.Clone(),
+	}
 }
 
 // Set sets key-value pair into the tree.
 func (tree *AVLTree) Set(key any, value any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	tree.doSet(key, value)
+	tree.lazyInit()
+	tree.AVLKVTree.Set(key, value)
 }
 
 // Sets batch sets key-values to the tree.
 func (tree *AVLTree) Sets(data map[any]any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	for key, value := range data {
-		tree.doSet(key, value)
-	}
+	tree.lazyInit()
+	tree.AVLKVTree.Sets(data)
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and such setting key-value pair operation would be ignored.
 func (tree *AVLTree) SetIfNotExist(key any, value any) bool {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if _, ok := tree.doGet(key); !ok {
-		tree.doSet(key, value)
-		return true
-	}
-	return false
+	tree.lazyInit()
+	return tree.AVLKVTree.SetIfNotExist(key, value)
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and such setting key-value pair operation would be ignored.
 func (tree *AVLTree) SetIfNotExistFunc(key any, f func() any) bool {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if _, ok := tree.doGet(key); !ok {
-		tree.doSet(key, f())
-		return true
-	}
-	return false
+	tree.lazyInit()
+	return tree.AVLKVTree.SetIfNotExistFunc(key, f)
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -109,13 +95,8 @@ func (tree *AVLTree) SetIfNotExistFunc(key any, f func() any) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` within mutex lock.
 func (tree *AVLTree) SetIfNotExistFuncLock(key any, f func() any) bool {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if _, ok := tree.doGet(key); !ok {
-		tree.doSet(key, f)
-		return true
-	}
-	return false
+	tree.lazyInit()
+	return tree.AVLKVTree.SetIfNotExistFuncLock(key, f)
 }
 
 // Get searches the `key` in the tree and returns its associated `value` or nil if key is not found in tree.
@@ -123,32 +104,22 @@ func (tree *AVLTree) SetIfNotExistFuncLock(key any, f func() any) bool {
 // Note that, the `nil` value from Get function cannot be used to determine key existence, please use Contains function
 // to do so.
 func (tree *AVLTree) Get(key any) (value any) {
-	value, _ = tree.Search(key)
-	return
+	tree.lazyInit()
+	return tree.AVLKVTree.Get(key)
 }
 
 // GetOrSet returns its `value` of `key`, or sets value with given `value` if it does not exist and then returns
 // this value.
 func (tree *AVLTree) GetOrSet(key any, value any) any {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if v, ok := tree.doGet(key); !ok {
-		return tree.doSet(key, value)
-	} else {
-		return v
-	}
+	tree.lazyInit()
+	return tree.AVLKVTree.GetOrSet(key, value)
 }
 
 // GetOrSetFunc returns its `value` of `key`, or sets value with returned value of callback function `f` if it does not
 // exist and then returns this value.
 func (tree *AVLTree) GetOrSetFunc(key any, f func() any) any {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if v, ok := tree.doGet(key); !ok {
-		return tree.doSet(key, f())
-	} else {
-		return v
-	}
+	tree.lazyInit()
+	return tree.AVLKVTree.GetOrSetFunc(key, f)
 }
 
 // GetOrSetFuncLock returns its `value` of `key`, or sets value with returned value of callback function `f` if it does
@@ -156,13 +127,8 @@ func (tree *AVLTree) GetOrSetFunc(key any, f func() any) any {
 //
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f` within mutex lock.
 func (tree *AVLTree) GetOrSetFuncLock(key any, f func() any) any {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if v, ok := tree.doGet(key); !ok {
-		return tree.doSet(key, f)
-	} else {
-		return v
-	}
+	tree.lazyInit()
+	return tree.AVLKVTree.GetOrSetFuncLock(key, f)
 }
 
 // GetVar returns a gvar.Var with the value by given `key`.
@@ -170,7 +136,8 @@ func (tree *AVLTree) GetOrSetFuncLock(key any, f func() any) any {
 //
 // Also see function Get.
 func (tree *AVLTree) GetVar(key any) *gvar.Var {
-	return gvar.New(tree.Get(key))
+	tree.lazyInit()
+	return tree.AVLKVTree.GetVar(key)
 }
 
 // GetVarOrSet returns a gvar.Var with result from GetVarOrSet.
@@ -178,7 +145,8 @@ func (tree *AVLTree) GetVar(key any) *gvar.Var {
 //
 // Also see function GetOrSet.
 func (tree *AVLTree) GetVarOrSet(key any, value any) *gvar.Var {
-	return gvar.New(tree.GetOrSet(key, value))
+	tree.lazyInit()
+	return tree.AVLKVTree.GetVarOrSet(key, value)
 }
 
 // GetVarOrSetFunc returns a gvar.Var with result from GetOrSetFunc.
@@ -186,7 +154,8 @@ func (tree *AVLTree) GetVarOrSet(key any, value any) *gvar.Var {
 //
 // Also see function GetOrSetFunc.
 func (tree *AVLTree) GetVarOrSetFunc(key any, f func() any) *gvar.Var {
-	return gvar.New(tree.GetOrSetFunc(key, f))
+	tree.lazyInit()
+	return tree.AVLKVTree.GetVarOrSetFunc(key, f)
 }
 
 // GetVarOrSetFuncLock returns a gvar.Var with result from GetOrSetFuncLock.
@@ -194,127 +163,100 @@ func (tree *AVLTree) GetVarOrSetFunc(key any, f func() any) *gvar.Var {
 //
 // Also see function GetOrSetFuncLock.
 func (tree *AVLTree) GetVarOrSetFuncLock(key any, f func() any) *gvar.Var {
-	return gvar.New(tree.GetOrSetFuncLock(key, f))
+	tree.lazyInit()
+	return tree.AVLKVTree.GetVarOrSetFuncLock(key, f)
 }
 
 // Search searches the tree with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (tree *AVLTree) Search(key any) (value any, found bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	if node, found := tree.doGet(key); found {
-		return node, true
-	}
-	return nil, false
+	tree.lazyInit()
+	return tree.AVLKVTree.Search(key)
 }
 
 // Contains checks and returns whether given `key` exists in the tree.
 func (tree *AVLTree) Contains(key any) bool {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	_, ok := tree.doGet(key)
-	return ok
+	tree.lazyInit()
+	return tree.AVLKVTree.Contains(key)
 }
 
 // Size returns number of nodes in the tree.
 func (tree *AVLTree) Size() int {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Size()
+	tree.lazyInit()
+	return tree.AVLKVTree.Size()
 }
 
 // IsEmpty returns true if the tree does not contain any nodes.
 func (tree *AVLTree) IsEmpty() bool {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Size() == 0
+	tree.lazyInit()
+	return tree.AVLKVTree.IsEmpty()
 }
 
 // Remove removes the node from the tree by `key`, and returns its associated value of `key`.
 // The given `key` should adhere to the comparator's type assertion, otherwise method panics.
 func (tree *AVLTree) Remove(key any) (value any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	return tree.doRemove(key)
+	tree.lazyInit()
+	return tree.AVLKVTree.Remove(key)
 }
 
 // Removes batch deletes key-value pairs from the tree by `keys`.
 func (tree *AVLTree) Removes(keys []any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	for _, key := range keys {
-		tree.doRemove(key)
-	}
+	tree.lazyInit()
+	tree.AVLKVTree.Removes(keys)
 }
 
 // Clear removes all nodes from the tree.
 func (tree *AVLTree) Clear() {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	tree.tree.Clear()
+	tree.lazyInit()
+	tree.AVLKVTree.Clear()
 }
 
 // Keys returns all keys from the tree in order by its comparator.
 func (tree *AVLTree) Keys() []any {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Keys()
+	tree.lazyInit()
+	return tree.AVLKVTree.Keys()
 }
 
 // Values returns all values from the true in order by its comparator based on the key.
 func (tree *AVLTree) Values() []any {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Values()
+	tree.lazyInit()
+	return tree.AVLKVTree.Values()
 }
 
 // Replace clears the data of the tree and sets the nodes by given `data`.
 func (tree *AVLTree) Replace(data map[any]any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	tree.tree.Clear()
-	for k, v := range data {
-		tree.doSet(k, v)
-	}
+	tree.lazyInit()
+	tree.AVLKVTree.Replace(data)
 }
 
 // Print prints the tree to stdout.
 func (tree *AVLTree) Print() {
-	fmt.Println(tree.String())
+	tree.lazyInit()
+	tree.AVLKVTree.Print()
 }
 
 // String returns a string representation of container.
 func (tree *AVLTree) String() string {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return gstr.Replace(tree.tree.String(), "AVLTree\n", "")
+	tree.lazyInit()
+	return tree.AVLKVTree.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (tree *AVLTree) MarshalJSON() (jsonBytes []byte, err error) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.MarshalJSON()
+	tree.lazyInit()
+	return tree.AVLKVTree.MarshalJSON()
 }
 
 // Map returns all key-value pairs as map.
 func (tree *AVLTree) Map() map[any]any {
-	m := make(map[any]any, tree.Size())
-	tree.IteratorAsc(func(key, value any) bool {
-		m[key] = value
-		return true
-	})
-	return m
+	tree.lazyInit()
+	return tree.AVLKVTree.Map()
 }
 
 // MapStrAny returns all key-value items as map[string]any.
 func (tree *AVLTree) MapStrAny() map[string]any {
-	m := make(map[string]any, tree.Size())
-	tree.IteratorAsc(func(key, value any) bool {
-		m[gconv.String(key)] = value
-		return true
-	})
-	return m
+	tree.lazyInit()
+	return tree.AVLKVTree.MapStrAny()
 }
 
 // Iterator is alias of IteratorAsc.
@@ -334,18 +276,8 @@ func (tree *AVLTree) IteratorFrom(key any, match bool, f func(key, value any) bo
 // IteratorAsc iterates the tree readonly in ascending order with given callback function `f`.
 // If callback function `f` returns true, then it continues iterating; or false to stop.
 func (tree *AVLTree) IteratorAsc(f func(key, value any) bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	var (
-		ok bool
-		it = tree.tree.Iterator()
-	)
-	for it.Begin(); it.Next(); {
-		index, value := it.Key(), it.Value()
-		if ok = f(index, value); !ok {
-			break
-		}
-	}
+	tree.lazyInit()
+	tree.AVLKVTree.IteratorAsc(f)
 }
 
 // IteratorAscFrom iterates the tree readonly in ascending order with given callback function `f`.
@@ -355,34 +287,16 @@ func (tree *AVLTree) IteratorAsc(f func(key, value any) bool) {
 // searching iterating.
 // If callback function `f` returns true, then it continues iterating; or false to stop.
 func (tree *AVLTree) IteratorAscFrom(key any, match bool, f func(key, value any) bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	var keys = tree.tree.Keys()
-	index, canIterator := iteratorFromGetIndex(key, keys, match)
-	if !canIterator {
-		return
-	}
-	for ; index < len(keys); index++ {
-		f(keys[index], tree.Get(keys[index]))
-	}
+	tree.lazyInit()
+	tree.AVLKVTree.IteratorAscFrom(key, match, f)
 }
 
 // IteratorDesc iterates the tree readonly in descending order with given callback function `f`.
 //
 // If callback function `f` returns true, then it continues iterating; or false to stop.
 func (tree *AVLTree) IteratorDesc(f func(key, value any) bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	var (
-		ok bool
-		it = tree.tree.Iterator()
-	)
-	for it.End(); it.Prev(); {
-		index, value := it.Key(), it.Value()
-		if ok = f(index, value); !ok {
-			break
-		}
-	}
+	tree.lazyInit()
+	tree.AVLKVTree.IteratorDesc(f)
 }
 
 // IteratorDescFrom iterates the tree readonly in descending order with given callback function `f`.
@@ -392,44 +306,20 @@ func (tree *AVLTree) IteratorDesc(f func(key, value any) bool) {
 // searching iterating.
 // If callback function `f` returns true, then it continues iterating; or false to stop.
 func (tree *AVLTree) IteratorDescFrom(key any, match bool, f func(key, value any) bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	var keys = tree.tree.Keys()
-	index, canIterator := iteratorFromGetIndex(key, keys, match)
-	if !canIterator {
-		return
-	}
-	for ; index >= 0; index-- {
-		f(keys[index], tree.Get(keys[index]))
-	}
+	tree.lazyInit()
+	tree.AVLKVTree.IteratorDescFrom(key, match, f)
 }
 
 // Left returns the minimum element corresponding to the comparator of the tree or nil if the tree is empty.
 func (tree *AVLTree) Left() *AVLTreeNode {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	node := tree.tree.Left()
-	if node == nil {
-		return nil
-	}
-	return &AVLTreeNode{
-		Key:   node.Key,
-		Value: node.Value,
-	}
+	tree.lazyInit()
+	return tree.AVLKVTree.Left()
 }
 
 // Right returns the maximum element corresponding to the comparator of the tree or nil if the tree is empty.
 func (tree *AVLTree) Right() *AVLTreeNode {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	node := tree.tree.Right()
-	if node == nil {
-		return nil
-	}
-	return &AVLTreeNode{
-		Key:   node.Key,
-		Value: node.Value,
-	}
+	tree.lazyInit()
+	return tree.AVLKVTree.Right()
 }
 
 // Floor Finds floor node of the input key, returns the floor node or nil if no floor node is found.
@@ -441,16 +331,8 @@ func (tree *AVLTree) Right() *AVLTreeNode {
 //
 // Key should adhere to the comparator's type assertion, otherwise method panics.
 func (tree *AVLTree) Floor(key any) (floor *AVLTreeNode, found bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	node, ok := tree.tree.Floor(key)
-	if !ok {
-		return nil, false
-	}
-	return &AVLTreeNode{
-		Key:   node.Key,
-		Value: node.Value,
-	}, true
+	tree.lazyInit()
+	return tree.AVLKVTree.Floor(key)
 }
 
 // Ceiling finds ceiling node of the input key, returns the ceiling node or nil if no ceiling node is found.
@@ -462,16 +344,8 @@ func (tree *AVLTree) Floor(key any) (floor *AVLTreeNode, found bool) {
 //
 // Key should adhere to the comparator's type assertion, otherwise method panics.
 func (tree *AVLTree) Ceiling(key any) (ceiling *AVLTreeNode, found bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	node, ok := tree.tree.Ceiling(key)
-	if !ok {
-		return nil, false
-	}
-	return &AVLTreeNode{
-		Key:   node.Key,
-		Value: node.Value,
-	}, true
+	tree.lazyInit()
+	return tree.AVLKVTree.Ceiling(key)
 }
 
 // Flip exchanges key-value of the tree to value-key.
@@ -480,6 +354,8 @@ func (tree *AVLTree) Ceiling(key any) (ceiling *AVLTreeNode, found bool) {
 //
 // If the type of value is different with key, you pass the new `comparator`.
 func (tree *AVLTree) Flip(comparator ...func(v1, v2 any) int) {
+	tree.lazyInit()
+
 	var t = new(AVLTree)
 	if len(comparator) > 0 {
 		t = NewAVLTree(comparator[0], tree.mu.IsSafe())
@@ -493,32 +369,3 @@ func (tree *AVLTree) Flip(comparator ...func(v1, v2 any) int) {
 	tree.Clear()
 	tree.Sets(t.Map())
 }
-
-// doSet inserts key-value pair node into the tree without lock.
-// If `key` already exists, then its value is updated with the new value.
-// If `value` is type of <func() any>, it will be executed and its return value will be set to the map with `key`.
-//
-// It returns value with given `key`.
-func (tree *AVLTree) doSet(key, value any) any {
-	if f, ok := value.(func() any); ok {
-		value = f()
-	}
-	if value == nil {
-		return value
-	}
-	tree.tree.Put(key, value)
-	return value
-}
-
-// doGet retrieves and returns the value of given key from tree without lock.
-func (tree *AVLTree) doGet(key any) (value any, found bool) {
-	return tree.tree.Get(key)
-}
-
-// doRemove removes key from tree and returns its associated value without lock.
-// Note that, the given `key` should adhere to the comparator's type assertion, otherwise method panics.
-func (tree *AVLTree) doRemove(key any) (value any) {
-	value, _ = tree.tree.Get(key)
-	tree.tree.Remove(key)
-	return
-}
diff --git a/container/gtree/gtree_btree.go b/container/gtree/gtree_btree.go
index 1ae03a132..24b8589a9 100644
--- a/container/gtree/gtree_btree.go
+++ b/container/gtree/gtree_btree.go
@@ -7,31 +7,22 @@
 package gtree
 
 import (
-	"fmt"
-
-	"github.com/emirpasic/gods/trees/btree"
+	"sync"
 
 	"github.com/gogf/gf/v2/container/gvar"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/text/gstr"
-	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gutil"
 )
 
 var _ iTree = (*BTree)(nil)
 
 // BTree holds elements of the B-tree.
 type BTree struct {
-	mu         rwmutex.RWMutex
-	comparator func(v1, v2 any) int
-	m          int // order (maximum number of children)
-	tree       *btree.Tree
+	*BKVTree[any, any]
+	once sync.Once
 }
 
 // BTreeEntry represents the key-value pair contained within nodes.
-type BTreeEntry struct {
-	Key   any
-	Value any
-}
+type BTreeEntry = BKVTreeEntry[any, any]
 
 // NewBTree instantiates a B-tree with `m` (maximum number of children) and a custom key comparator.
 // The parameter `safe` is used to specify whether using tree in concurrent-safety,
@@ -39,10 +30,7 @@ type BTreeEntry struct {
 // Note that the `m` must be greater or equal than 3, or else it panics.
 func NewBTree(m int, comparator func(v1, v2 any) int, safe ...bool) *BTree {
 	return &BTree{
-		mu:         rwmutex.Create(safe...),
-		m:          m,
-		comparator: comparator,
-		tree:       btree.NewWith(m, comparator),
+		BKVTree: NewBKVTree[any, any](m, comparator, safe...),
 	}
 }
 
@@ -50,58 +38,55 @@ func NewBTree(m int, comparator func(v1, v2 any) int, safe ...bool) *BTree {
 // The parameter `safe` is used to specify whether using tree in concurrent-safety,
 // which is false in default.
 func NewBTreeFrom(m int, comparator func(v1, v2 any) int, data map[any]any, safe ...bool) *BTree {
-	tree := NewBTree(m, comparator, safe...)
-	for k, v := range data {
-		tree.doSet(k, v)
+	return &BTree{
+		BKVTree: NewBKVTreeFrom(m, comparator, data, safe...),
 	}
-	return tree
+}
+
+// lazyInit lazily initializes the tree.
+func (tree *BTree) lazyInit() {
+	tree.once.Do(func() {
+		if tree.BKVTree == nil {
+			tree.BKVTree = NewBKVTree[any, any](3, gutil.ComparatorTStr, false)
+		}
+	})
 }
 
 // Clone clones and returns a new tree from current tree.
 func (tree *BTree) Clone() *BTree {
-	newTree := NewBTree(tree.m, tree.comparator, tree.mu.IsSafe())
-	newTree.Sets(tree.Map())
-	return newTree
+	if tree == nil {
+		return nil
+	}
+	tree.lazyInit()
+	return &BTree{
+		BKVTree: tree.BKVTree.Clone(),
+	}
 }
 
 // Set sets key-value pair into the tree.
 func (tree *BTree) Set(key any, value any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	tree.doSet(key, value)
+	tree.lazyInit()
+	tree.BKVTree.Set(key, value)
 }
 
 // Sets batch sets key-values to the tree.
 func (tree *BTree) Sets(data map[any]any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	for k, v := range data {
-		tree.doSet(k, v)
-	}
+	tree.lazyInit()
+	tree.BKVTree.Sets(data)
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and such setting key-value pair operation would be ignored.
 func (tree *BTree) SetIfNotExist(key any, value any) bool {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if _, ok := tree.doGet(key); !ok {
-		tree.doSet(key, value)
-		return true
-	}
-	return false
+	tree.lazyInit()
+	return tree.BKVTree.SetIfNotExist(key, value)
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and such setting key-value pair operation would be ignored.
 func (tree *BTree) SetIfNotExistFunc(key any, f func() any) bool {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if _, ok := tree.doGet(key); !ok {
-		tree.doSet(key, f())
-		return true
-	}
-	return false
+	tree.lazyInit()
+	return tree.BKVTree.SetIfNotExistFunc(key, f)
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -110,13 +95,8 @@ func (tree *BTree) SetIfNotExistFunc(key any, f func() any) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` within mutex lock.
 func (tree *BTree) SetIfNotExistFuncLock(key any, f func() any) bool {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if _, ok := tree.doGet(key); !ok {
-		tree.doSet(key, f)
-		return true
-	}
-	return false
+	tree.lazyInit()
+	return tree.BKVTree.SetIfNotExistFuncLock(key, f)
 }
 
 // Get searches the `key` in the tree and returns its associated `value` or nil if key is not found in tree.
@@ -124,34 +104,22 @@ func (tree *BTree) SetIfNotExistFuncLock(key any, f func() any) bool {
 // Note that, the `nil` value from Get function cannot be used to determine key existence, please use Contains function
 // to do so.
 func (tree *BTree) Get(key any) (value any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	value, _ = tree.doGet(key)
-	return
+	tree.lazyInit()
+	return tree.BKVTree.Get(key)
 }
 
 // GetOrSet returns its `value` of `key`, or sets value with given `value` if it does not exist and then returns
 // this value.
 func (tree *BTree) GetOrSet(key any, value any) any {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if v, ok := tree.doGet(key); !ok {
-		return tree.doSet(key, value)
-	} else {
-		return v
-	}
+	tree.lazyInit()
+	return tree.BKVTree.GetOrSet(key, value)
 }
 
 // GetOrSetFunc returns its `value` of `key`, or sets value with returned value of callback function `f` if it does not
 // exist and then returns this value.
 func (tree *BTree) GetOrSetFunc(key any, f func() any) any {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if v, ok := tree.doGet(key); !ok {
-		return tree.doSet(key, f())
-	} else {
-		return v
-	}
+	tree.lazyInit()
+	return tree.BKVTree.GetOrSetFunc(key, f)
 }
 
 // GetOrSetFuncLock returns its `value` of `key`, or sets value with returned value of callback function `f` if it does
@@ -159,13 +127,8 @@ func (tree *BTree) GetOrSetFunc(key any, f func() any) any {
 //
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f` within mutex lock.
 func (tree *BTree) GetOrSetFuncLock(key any, f func() any) any {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if v, ok := tree.doGet(key); !ok {
-		return tree.doSet(key, f)
-	} else {
-		return v
-	}
+	tree.lazyInit()
+	return tree.BKVTree.GetOrSetFuncLock(key, f)
 }
 
 // GetVar returns a gvar.Var with the value by given `key`.
@@ -173,7 +136,8 @@ func (tree *BTree) GetOrSetFuncLock(key any, f func() any) any {
 //
 // Also see function Get.
 func (tree *BTree) GetVar(key any) *gvar.Var {
-	return gvar.New(tree.Get(key))
+	tree.lazyInit()
+	return tree.BKVTree.GetVar(key)
 }
 
 // GetVarOrSet returns a gvar.Var with result from GetVarOrSet.
@@ -181,7 +145,8 @@ func (tree *BTree) GetVar(key any) *gvar.Var {
 //
 // Also see function GetOrSet.
 func (tree *BTree) GetVarOrSet(key any, value any) *gvar.Var {
-	return gvar.New(tree.GetOrSet(key, value))
+	tree.lazyInit()
+	return tree.BKVTree.GetVarOrSet(key, value)
 }
 
 // GetVarOrSetFunc returns a gvar.Var with result from GetOrSetFunc.
@@ -189,7 +154,8 @@ func (tree *BTree) GetVarOrSet(key any, value any) *gvar.Var {
 //
 // Also see function GetOrSetFunc.
 func (tree *BTree) GetVarOrSetFunc(key any, f func() any) *gvar.Var {
-	return gvar.New(tree.GetOrSetFunc(key, f))
+	tree.lazyInit()
+	return tree.BKVTree.GetVarOrSetFunc(key, f)
 }
 
 // GetVarOrSetFuncLock returns a gvar.Var with result from GetOrSetFuncLock.
@@ -197,155 +163,123 @@ func (tree *BTree) GetVarOrSetFunc(key any, f func() any) *gvar.Var {
 //
 // Also see function GetOrSetFuncLock.
 func (tree *BTree) GetVarOrSetFuncLock(key any, f func() any) *gvar.Var {
-	return gvar.New(tree.GetOrSetFuncLock(key, f))
+	tree.lazyInit()
+	return tree.BKVTree.GetVarOrSetFuncLock(key, f)
 }
 
 // Search searches the tree with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (tree *BTree) Search(key any) (value any, found bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Get(key)
+	tree.lazyInit()
+	return tree.BKVTree.Search(key)
 }
 
 // Contains checks and returns whether given `key` exists in the tree.
 func (tree *BTree) Contains(key any) bool {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	_, ok := tree.doGet(key)
-	return ok
+	tree.lazyInit()
+	return tree.BKVTree.Contains(key)
 }
 
 // Size returns number of nodes in the tree.
 func (tree *BTree) Size() int {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Size()
+	tree.lazyInit()
+	return tree.BKVTree.Size()
 }
 
 // IsEmpty returns true if tree does not contain any nodes
 func (tree *BTree) IsEmpty() bool {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Size() == 0
+	tree.lazyInit()
+	return tree.BKVTree.IsEmpty()
 }
 
 // Remove removes the node from the tree by `key`, and returns its associated value of `key`.
 // The given `key` should adhere to the comparator's type assertion, otherwise method panics.
 func (tree *BTree) Remove(key any) (value any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	return tree.doRemove(key)
+	tree.lazyInit()
+	return tree.BKVTree.Remove(key)
 }
 
 // Removes batch deletes key-value pairs from the tree by `keys`.
 func (tree *BTree) Removes(keys []any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	for _, key := range keys {
-		tree.doRemove(key)
-	}
+	tree.lazyInit()
+	tree.BKVTree.Removes(keys)
 }
 
 // Clear removes all nodes from the tree.
 func (tree *BTree) Clear() {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	tree.tree.Clear()
+	tree.lazyInit()
+	tree.BKVTree.Clear()
 }
 
 // Keys returns all keys from the tree in order by its comparator.
 func (tree *BTree) Keys() []any {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Keys()
+	tree.lazyInit()
+	return tree.BKVTree.Keys()
 }
 
 // Values returns all values from the true in order by its comparator based on the key.
 func (tree *BTree) Values() []any {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Values()
+	tree.lazyInit()
+	return tree.BKVTree.Values()
 }
 
 // Replace clears the data of the tree and sets the nodes by given `data`.
 func (tree *BTree) Replace(data map[any]any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	tree.tree.Clear()
-	for k, v := range data {
-		tree.doSet(k, v)
-	}
+	tree.lazyInit()
+	tree.BKVTree.Replace(data)
 }
 
 // Map returns all key-value pairs as map.
 func (tree *BTree) Map() map[any]any {
-	m := make(map[any]any, tree.Size())
-	tree.IteratorAsc(func(key, value any) bool {
-		m[key] = value
-		return true
-	})
-	return m
+	tree.lazyInit()
+	return tree.BKVTree.Map()
 }
 
 // MapStrAny returns all key-value items as map[string]any.
 func (tree *BTree) MapStrAny() map[string]any {
-	m := make(map[string]any, tree.Size())
-	tree.IteratorAsc(func(key, value any) bool {
-		m[gconv.String(key)] = value
-		return true
-	})
-	return m
+	tree.lazyInit()
+	return tree.BKVTree.MapStrAny()
 }
 
 // Print prints the tree to stdout.
 func (tree *BTree) Print() {
-	fmt.Println(tree.String())
+	tree.lazyInit()
+	tree.BKVTree.Print()
 }
 
 // String returns a string representation of container (for debugging purposes)
 func (tree *BTree) String() string {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return gstr.Replace(tree.tree.String(), "BTree\n", "")
+	tree.lazyInit()
+	return tree.BKVTree.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (tree *BTree) MarshalJSON() (jsonBytes []byte, err error) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.MarshalJSON()
+	tree.lazyInit()
+	return tree.BKVTree.MarshalJSON()
 }
 
 // Iterator is alias of IteratorAsc.
 //
 // Also see IteratorAsc.
 func (tree *BTree) Iterator(f func(key, value any) bool) {
-	tree.IteratorAsc(f)
+	tree.lazyInit()
+	tree.BKVTree.Iterator(f)
 }
 
 // IteratorFrom is alias of IteratorAscFrom.
 //
 // Also see IteratorAscFrom.
 func (tree *BTree) IteratorFrom(key any, match bool, f func(key, value any) bool) {
-	tree.IteratorAscFrom(key, match, f)
+	tree.lazyInit()
+	tree.BKVTree.IteratorFrom(key, match, f)
 }
 
 // IteratorAsc iterates the tree readonly in ascending order with given callback function `f`.
 // If callback function `f` returns true, then it continues iterating; or false to stop.
 func (tree *BTree) IteratorAsc(f func(key, value any) bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	var (
-		ok bool
-		it = tree.tree.Iterator()
-	)
-	for it.Begin(); it.Next(); {
-		index, value := it.Key(), it.Value()
-		if ok = f(index, value); !ok {
-			break
-		}
-	}
+	tree.lazyInit()
+	tree.BKVTree.IteratorAsc(f)
 }
 
 // IteratorAscFrom iterates the tree readonly in ascending order with given callback function `f`.
@@ -355,34 +289,16 @@ func (tree *BTree) IteratorAsc(f func(key, value any) bool) {
 // searching iterating.
 // If callback function `f` returns true, then it continues iterating; or false to stop.
 func (tree *BTree) IteratorAscFrom(key any, match bool, f func(key, value any) bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	var keys = tree.tree.Keys()
-	index, canIterator := iteratorFromGetIndex(key, keys, match)
-	if !canIterator {
-		return
-	}
-	for ; index < len(keys); index++ {
-		f(keys[index], tree.Get(keys[index]))
-	}
+	tree.lazyInit()
+	tree.BKVTree.IteratorAscFrom(key, match, f)
 }
 
 // IteratorDesc iterates the tree readonly in descending order with given callback function `f`.
 //
 // If callback function `f` returns true, then it continues iterating; or false to stop.
 func (tree *BTree) IteratorDesc(f func(key, value any) bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	var (
-		ok bool
-		it = tree.tree.Iterator()
-	)
-	for it.End(); it.Prev(); {
-		index, value := it.Key(), it.Value()
-		if ok = f(index, value); !ok {
-			break
-		}
-	}
+	tree.lazyInit()
+	tree.BKVTree.IteratorDesc(f)
 }
 
 // IteratorDescFrom iterates the tree readonly in descending order with given callback function `f`.
@@ -392,78 +308,24 @@ func (tree *BTree) IteratorDesc(f func(key, value any) bool) {
 // searching iterating.
 // If callback function `f` returns true, then it continues iterating; or false to stop.
 func (tree *BTree) IteratorDescFrom(key any, match bool, f func(key, value any) bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	var keys = tree.tree.Keys()
-	index, canIterator := iteratorFromGetIndex(key, keys, match)
-	if !canIterator {
-		return
-	}
-	for ; index >= 0; index-- {
-		f(keys[index], tree.Get(keys[index]))
-	}
+	tree.lazyInit()
+	tree.BKVTree.IteratorDescFrom(key, match, f)
 }
 
 // Height returns the height of the tree.
 func (tree *BTree) Height() int {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Height()
+	tree.lazyInit()
+	return tree.BKVTree.Height()
 }
 
 // Left returns the minimum element corresponding to the comparator of the tree or nil if the tree is empty.
 func (tree *BTree) Left() *BTreeEntry {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	node := tree.tree.Left()
-	if node == nil || node.Entries == nil || len(node.Entries) == 0 {
-		return nil
-	}
-	return &BTreeEntry{
-		Key:   node.Entries[0].Key,
-		Value: node.Entries[0].Value,
-	}
+	tree.lazyInit()
+	return tree.BKVTree.Left()
 }
 
 // Right returns the maximum element corresponding to the comparator of the tree or nil if the tree is empty.
 func (tree *BTree) Right() *BTreeEntry {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	node := tree.tree.Right()
-	if node == nil || node.Entries == nil || len(node.Entries) == 0 {
-		return nil
-	}
-	return &BTreeEntry{
-		Key:   node.Entries[len(node.Entries)-1].Key,
-		Value: node.Entries[len(node.Entries)-1].Value,
-	}
-}
-
-// doSet inserts key-value pair node into the tree without lock.
-// If `key` already exists, then its value is updated with the new value.
-// If `value` is type of <func() any>, it will be executed and its return value will be set to the map with `key`.
-//
-// It returns value with given `key`.
-func (tree *BTree) doSet(key any, value any) any {
-	if f, ok := value.(func() any); ok {
-		value = f()
-	}
-	if value == nil {
-		return value
-	}
-	tree.tree.Put(key, value)
-	return value
-}
-
-// doGet get the value from the tree by key without lock.
-func (tree *BTree) doGet(key any) (value any, ok bool) {
-	return tree.tree.Get(key)
-}
-
-// doRemove removes key from tree and returns its associated value without lock.
-// Note that, the given `key` should adhere to the comparator's type assertion, otherwise method panics.
-func (tree *BTree) doRemove(key any) (value any) {
-	value, _ = tree.tree.Get(key)
-	tree.tree.Remove(key)
-	return
+	tree.lazyInit()
+	return tree.BKVTree.Right()
 }
diff --git a/container/gtree/gtree_k_v_avltree.go b/container/gtree/gtree_k_v_avltree.go
new file mode 100644
index 000000000..b0fe2d293
--- /dev/null
+++ b/container/gtree/gtree_k_v_avltree.go
@@ -0,0 +1,584 @@
+// 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 gtree
+
+import (
+	"fmt"
+
+	"github.com/emirpasic/gods/v2/trees/avltree"
+
+	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+// NilChecker is a function that checks whether the given value is nil.
+type NilChecker[V any] func(V) bool
+
+// AVLKVTree holds elements of the AVL tree.
+type AVLKVTree[K comparable, V any] struct {
+	mu         rwmutex.RWMutex
+	comparator func(v1, v2 K) int
+	tree       *avltree.Tree[K, V]
+	nilChecker NilChecker[V]
+}
+
+// AVLKVTreeNode is a single element within the tree.
+type AVLKVTreeNode[K comparable, V any] struct {
+	Key   K
+	Value V
+}
+
+// NewAVLKVTree instantiates an AVL tree with the custom key comparator.
+//
+// The parameter `safe` is used to specify whether using tree in concurrent-safety,
+// which is false in default.
+func NewAVLKVTree[K comparable, V any](comparator func(v1, v2 K) int, safe ...bool) *AVLKVTree[K, V] {
+	return &AVLKVTree[K, V]{
+		mu:         rwmutex.Create(safe...),
+		comparator: comparator,
+		tree:       avltree.NewWith[K, V](comparator),
+	}
+}
+
+// NewAVLKVTreeWithChecker instantiates an AVL tree with the custom key comparator and nil checker.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety, which is false in default.
+// The parameter `checker` is used to specify whether the given value is nil.
+func NewAVLKVTreeWithChecker[K comparable, V any](comparator func(v1, v2 K) int, checker NilChecker[V], safe ...bool) *AVLKVTree[K, V] {
+	t := NewAVLKVTree[K, V](comparator, safe...)
+	t.SetNilChecker(checker)
+	return t
+}
+
+// NewAVLKVTreeFrom instantiates an AVL tree with the custom key comparator and data map.
+//
+// The parameter `safe` is used to specify whether using tree in concurrent-safety, which is false in default.
+func NewAVLKVTreeFrom[K comparable, V any](comparator func(v1, v2 K) int, data map[K]V, safe ...bool) *AVLKVTree[K, V] {
+	tree := NewAVLKVTree[K, V](comparator, safe...)
+	for k, v := range data {
+		tree.doSet(k, v)
+	}
+	return tree
+}
+
+// NewAVLKVTreeWithCheckerFrom instantiates an AVL tree with the custom key comparator, nil checker and data map.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety, which is false in default.
+// The parameter `checker` is used to specify whether the given value is nil.
+func NewAVLKVTreeWithCheckerFrom[K comparable, V any](comparator func(v1, v2 K) int, data map[K]V, checker NilChecker[V], safe ...bool) *AVLKVTree[K, V] {
+	tree := NewAVLKVTreeWithChecker[K, V](comparator, checker, safe...)
+	for k, v := range data {
+		tree.doSet(k, v)
+	}
+	return tree
+}
+
+// SetNilChecker registers a custom nil checker function for the map values.
+// This function is used to determine if a value should be considered as nil.
+// The nil checker function takes a value of type V and returns a boolean indicating
+// whether the value should be treated as nil.
+func (tree *AVLKVTree[K, V]) SetNilChecker(nilChecker NilChecker[V]) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	tree.nilChecker = nilChecker
+}
+
+// isNil checks whether the given value is nil.
+// It first checks if a custom nil checker function is registered and uses it if available,
+// otherwise it falls back to the default empty.IsNil function.
+func (tree *AVLKVTree[K, V]) isNil(v V) bool {
+	if tree.nilChecker != nil {
+		return tree.nilChecker(v)
+	}
+	return empty.IsNil(v)
+}
+
+// Clone clones and returns a new tree from current tree.
+func (tree *AVLKVTree[K, V]) Clone() *AVLKVTree[K, V] {
+	if tree == nil {
+		return nil
+	}
+	newTree := NewAVLKVTree[K, V](tree.comparator, tree.mu.IsSafe())
+	newTree.Sets(tree.Map())
+	return newTree
+}
+
+// Set sets key-value pair into the tree.
+func (tree *AVLKVTree[K, V]) Set(key K, value V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	tree.doSet(key, value)
+}
+
+// Sets batch sets key-values to the tree.
+func (tree *AVLKVTree[K, V]) Sets(data map[K]V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	for key, value := range data {
+		tree.doSet(key, value)
+	}
+}
+
+// SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
+// It returns false if `key` exists, and such setting key-value pair operation would be ignored.
+func (tree *AVLKVTree[K, V]) SetIfNotExist(key K, value V) bool {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if _, ok := tree.doGet(key); !ok {
+		tree.doSet(key, value)
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
+// It returns false if `key` exists, and such setting key-value pair operation would be ignored.
+func (tree *AVLKVTree[K, V]) SetIfNotExistFunc(key K, f func() V) bool {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if _, ok := tree.doGet(key); !ok {
+		tree.doSet(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
+// It returns false if `key` exists, and such setting key-value pair operation would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function `f` within mutex lock.
+func (tree *AVLKVTree[K, V]) SetIfNotExistFuncLock(key K, f func() V) bool {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if _, ok := tree.doGet(key); !ok {
+		tree.doSet(key, f())
+		return true
+	}
+	return false
+}
+
+// Get searches the `key` in the tree and returns its associated `value` or nil if key is not found in tree.
+//
+// Note that, the `nil` value from Get function cannot be used to determine key existence, please use Contains function
+// to do so.
+func (tree *AVLKVTree[K, V]) Get(key K) (value V) {
+	value, _ = tree.Search(key)
+	return
+}
+
+// GetOrSet returns its `value` of `key`, or sets value with given `value` if it does not exist and then returns
+// this value.
+func (tree *AVLKVTree[K, V]) GetOrSet(key K, value V) V {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if v, ok := tree.doGet(key); !ok {
+		return tree.doSet(key, value)
+	} else {
+		return v
+	}
+}
+
+// GetOrSetFunc returns its `value` of `key`, or sets value with returned value of callback function `f` if it does not
+// exist and then returns this value.
+func (tree *AVLKVTree[K, V]) GetOrSetFunc(key K, f func() V) V {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if v, ok := tree.doGet(key); !ok {
+		return tree.doSet(key, f())
+	} else {
+		return v
+	}
+}
+
+// GetOrSetFuncLock returns its `value` of `key`, or sets value with returned value of callback function `f` if it does
+// not exist and then returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f` within mutex lock.
+func (tree *AVLKVTree[K, V]) GetOrSetFuncLock(key K, f func() V) V {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if v, ok := tree.doGet(key); !ok {
+		return tree.doSet(key, f())
+	} else {
+		return v
+	}
+}
+
+// GetVar returns a gvar.Var with the value by given `key`.
+// Note that, the returned gvar.Var is un-concurrent safe.
+//
+// Also see function Get.
+func (tree *AVLKVTree[K, V]) GetVar(key K) *gvar.Var {
+	return gvar.New(tree.Get(key))
+}
+
+// GetVarOrSet returns a gvar.Var with result from GetVarOrSet.
+// Note that, the returned gvar.Var is un-concurrent safe.
+//
+// Also see function GetOrSet.
+func (tree *AVLKVTree[K, V]) GetVarOrSet(key K, value V) *gvar.Var {
+	return gvar.New(tree.GetOrSet(key, value))
+}
+
+// GetVarOrSetFunc returns a gvar.Var with result from GetOrSetFunc.
+// Note that, the returned gvar.Var is un-concurrent safe.
+//
+// Also see function GetOrSetFunc.
+func (tree *AVLKVTree[K, V]) GetVarOrSetFunc(key K, f func() V) *gvar.Var {
+	return gvar.New(tree.GetOrSetFunc(key, f))
+}
+
+// GetVarOrSetFuncLock returns a gvar.Var with result from GetOrSetFuncLock.
+// Note that, the returned gvar.Var is un-concurrent safe.
+//
+// Also see function GetOrSetFuncLock.
+func (tree *AVLKVTree[K, V]) GetVarOrSetFuncLock(key K, f func() V) *gvar.Var {
+	return gvar.New(tree.GetOrSetFuncLock(key, f))
+}
+
+// Search searches the tree with given `key`.
+// Second return parameter `found` is true if key was found, otherwise false.
+func (tree *AVLKVTree[K, V]) Search(key K) (value V, found bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	if node, found := tree.doGet(key); found {
+		return node, true
+	}
+	found = false
+	return
+}
+
+// Contains checks and returns whether given `key` exists in the tree.
+func (tree *AVLKVTree[K, V]) Contains(key K) bool {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	_, ok := tree.doGet(key)
+	return ok
+}
+
+// Size returns number of nodes in the tree.
+func (tree *AVLKVTree[K, V]) Size() int {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Size()
+}
+
+// IsEmpty returns true if the tree does not contain any nodes.
+func (tree *AVLKVTree[K, V]) IsEmpty() bool {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Size() == 0
+}
+
+// Remove removes the node from the tree by `key`, and returns its associated value of `key`.
+// The given `key` should adhere to the comparator's type assertion, otherwise method panics.
+func (tree *AVLKVTree[K, V]) Remove(key K) (value V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	return tree.doRemove(key)
+}
+
+// Removes batch deletes key-value pairs from the tree by `keys`.
+func (tree *AVLKVTree[K, V]) Removes(keys []K) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	for _, key := range keys {
+		tree.doRemove(key)
+	}
+}
+
+// Clear removes all nodes from the tree.
+func (tree *AVLKVTree[K, V]) Clear() {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	tree.tree.Clear()
+}
+
+// Keys returns all keys from the tree in order by its comparator.
+func (tree *AVLKVTree[K, V]) Keys() []K {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Keys()
+}
+
+// Values returns all values from the true in order by its comparator based on the key.
+func (tree *AVLKVTree[K, V]) Values() []V {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Values()
+}
+
+// Replace clears the data of the tree and sets the nodes by given `data`.
+func (tree *AVLKVTree[K, V]) Replace(data map[K]V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	tree.tree.Clear()
+	for k, v := range data {
+		tree.doSet(k, v)
+	}
+}
+
+// Print prints the tree to stdout.
+func (tree *AVLKVTree[K, V]) Print() {
+	fmt.Println(tree.String())
+}
+
+// String returns a string representation of container.
+func (tree *AVLKVTree[K, V]) String() string {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return gstr.Replace(tree.tree.String(), "AVLTree\n", "")
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (tree *AVLKVTree[K, V]) MarshalJSON() (jsonBytes []byte, err error) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+
+	elements := make(map[string]V)
+	it := tree.tree.Iterator()
+	for it.Next() {
+		elements[gconv.String(it.Key())] = it.Value()
+	}
+	return json.Marshal(&elements)
+}
+
+// Map returns all key-value pairs as map.
+func (tree *AVLKVTree[K, V]) Map() map[K]V {
+	m := make(map[K]V, tree.Size())
+	tree.IteratorAsc(func(key K, value V) bool {
+		m[key] = value
+		return true
+	})
+	return m
+}
+
+// MapStrAny returns all key-value items as map[string]any.
+func (tree *AVLKVTree[K, V]) MapStrAny() map[string]any {
+	m := make(map[string]any, tree.Size())
+	tree.IteratorAsc(func(key K, value V) bool {
+		m[gconv.String(key)] = value
+		return true
+	})
+	return m
+}
+
+// Iterator is alias of IteratorAsc.
+//
+// Also see IteratorAsc.
+func (tree *AVLKVTree[K, V]) Iterator(f func(key K, value V) bool) {
+	tree.IteratorAsc(f)
+}
+
+// IteratorFrom is alias of IteratorAscFrom.
+//
+// Also see IteratorAscFrom.
+func (tree *AVLKVTree[K, V]) IteratorFrom(key K, match bool, f func(key K, value V) bool) {
+	tree.IteratorAscFrom(key, match, f)
+}
+
+// IteratorAsc iterates the tree readonly in ascending order with given callback function `f`.
+// If callback function `f` returns true, then it continues iterating; or false to stop.
+func (tree *AVLKVTree[K, V]) IteratorAsc(f func(key K, value V) bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	var (
+		ok bool
+		it = tree.tree.Iterator()
+	)
+	for it.Begin(); it.Next(); {
+		index, value := it.Key(), it.Value()
+		if ok = f(index, value); !ok {
+			break
+		}
+	}
+}
+
+// IteratorAscFrom iterates the tree readonly in ascending order with given callback function `f`.
+//
+// The parameter `key` specifies the start entry for iterating.
+// The parameter `match` specifies whether starting iterating only if the `key` is fully matched, or else using index
+// searching iterating.
+// If callback function `f` returns true, then it continues iterating; or false to stop.
+func (tree *AVLKVTree[K, V]) IteratorAscFrom(key K, match bool, f func(key K, value V) bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	var keys = tree.tree.Keys()
+	index, canIterator := iteratorFromGetIndexT(key, keys, match)
+	if !canIterator {
+		return
+	}
+	for ; index < len(keys); index++ {
+		f(keys[index], tree.Get(keys[index]))
+	}
+}
+
+// IteratorDesc iterates the tree readonly in descending order with given callback function `f`.
+//
+// If callback function `f` returns true, then it continues iterating; or false to stop.
+func (tree *AVLKVTree[K, V]) IteratorDesc(f func(key K, value V) bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	var (
+		ok bool
+		it = tree.tree.Iterator()
+	)
+	for it.End(); it.Prev(); {
+		index, value := it.Key(), it.Value()
+		if ok = f(index, value); !ok {
+			break
+		}
+	}
+}
+
+// IteratorDescFrom iterates the tree readonly in descending order with given callback function `f`.
+//
+// The parameter `key` specifies the start entry for iterating.
+// The parameter `match` specifies whether starting iterating only if the `key` is fully matched, or else using index
+// searching iterating.
+// If callback function `f` returns true, then it continues iterating; or false to stop.
+func (tree *AVLKVTree[K, V]) IteratorDescFrom(key K, match bool, f func(key K, value V) bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	var keys = tree.tree.Keys()
+	index, canIterator := iteratorFromGetIndexT(key, keys, match)
+	if !canIterator {
+		return
+	}
+	for ; index >= 0; index-- {
+		f(keys[index], tree.Get(keys[index]))
+	}
+}
+
+// Left returns the minimum element corresponding to the comparator of the tree or nil if the tree is empty.
+func (tree *AVLKVTree[K, V]) Left() *AVLKVTreeNode[K, V] {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	node := tree.tree.Left()
+	if node == nil {
+		return nil
+	}
+	return &AVLKVTreeNode[K, V]{
+		Key:   node.Key,
+		Value: node.Value,
+	}
+}
+
+// Right returns the maximum element corresponding to the comparator of the tree or nil if the tree is empty.
+func (tree *AVLKVTree[K, V]) Right() *AVLKVTreeNode[K, V] {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	node := tree.tree.Right()
+	if node == nil {
+		return nil
+	}
+	return &AVLKVTreeNode[K, V]{
+		Key:   node.Key,
+		Value: node.Value,
+	}
+}
+
+// Floor Finds floor node of the input key, returns the floor node or nil if no floor node is found.
+// The second returned parameter `found` is true if floor was found, otherwise false.
+//
+// Floor node is defined as the largest node that is smaller than or equal to the given node.
+// A floor node may not be found, either because the tree is empty, or because
+// all nodes in the tree is larger than the given node.
+//
+// Key should adhere to the comparator's type assertion, otherwise method panics.
+func (tree *AVLKVTree[K, V]) Floor(key K) (floor *AVLKVTreeNode[K, V], found bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	node, ok := tree.tree.Floor(key)
+	if !ok {
+		return nil, false
+	}
+	return &AVLKVTreeNode[K, V]{
+		Key:   node.Key,
+		Value: node.Value,
+	}, true
+}
+
+// Ceiling finds ceiling node of the input key, returns the ceiling node or nil if no ceiling node is found.
+// The second return parameter `found` is true if ceiling was found, otherwise false.
+//
+// Ceiling node is defined as the smallest node that is larger than or equal to the given node.
+// A ceiling node may not be found, either because the tree is empty, or because
+// all nodes in the tree is smaller than the given node.
+//
+// Key should adhere to the comparator's type assertion, otherwise method panics.
+func (tree *AVLKVTree[K, V]) Ceiling(key K) (ceiling *AVLKVTreeNode[K, V], found bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	node, ok := tree.tree.Ceiling(key)
+	if !ok {
+		return nil, false
+	}
+	return &AVLKVTreeNode[K, V]{
+		Key:   node.Key,
+		Value: node.Value,
+	}, true
+}
+
+// Flip exchanges key-value of the tree to value-key.
+// Note that you should guarantee the value is the same type as key,
+// or else the comparator would panic.
+//
+// If the type of value is different with key, you pass the new `comparator`.
+func (tree *AVLKVTree[K, V]) Flip(comparator ...func(v1, v2 K) int) {
+	var t = new(AVLKVTree[K, V])
+	if len(comparator) > 0 {
+		t = NewAVLKVTree[K, V](comparator[0], tree.mu.IsSafe())
+	} else {
+		t = NewAVLKVTree[K, V](tree.comparator, tree.mu.IsSafe())
+	}
+	var (
+		newKey   K
+		newValue V
+	)
+	tree.IteratorAsc(func(key K, value V) bool {
+		if err := gconv.Scan(key, &newValue); err != nil {
+			panic(err)
+		}
+		if err := gconv.Scan(value, &newKey); err != nil {
+			panic(err)
+		}
+		t.doSet(newKey, newValue)
+		return true
+	})
+	tree.Clear()
+	tree.Sets(t.Map())
+}
+
+// doSet inserts key-value pair node into the tree without lock.
+// If `key` already exists, then its value is updated with the new value.
+// If `value` is type of <func() any>, it will be executed and its return value will be set to the map with `key`.
+//
+// It returns value with given `key`.
+func (tree *AVLKVTree[K, V]) doSet(key K, value V) V {
+	if tree.isNil(value) {
+		return value
+	}
+	tree.tree.Put(key, value)
+	return value
+}
+
+// doGet retrieves and returns the value of given key from tree without lock.
+func (tree *AVLKVTree[K, V]) doGet(key K) (value V, found bool) {
+	return tree.tree.Get(key)
+}
+
+// doRemove removes key from tree and returns its associated value without lock.
+// Note that, the given `key` should adhere to the comparator's type assertion, otherwise method panics.
+func (tree *AVLKVTree[K, V]) doRemove(key K) (value V) {
+	value, _ = tree.tree.Get(key)
+	tree.tree.Remove(key)
+	return
+}
diff --git a/container/gtree/gtree_k_v_btree.go b/container/gtree/gtree_k_v_btree.go
new file mode 100644
index 000000000..7586622ae
--- /dev/null
+++ b/container/gtree/gtree_k_v_btree.go
@@ -0,0 +1,516 @@
+// 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 gtree
+
+import (
+	"fmt"
+
+	"github.com/emirpasic/gods/v2/trees/btree"
+
+	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+// BKVTree holds elements of the B-tree.
+type BKVTree[K comparable, V any] struct {
+	mu         rwmutex.RWMutex
+	comparator func(v1, v2 K) int
+	m          int // order (maximum number of children)
+	tree       *btree.Tree[K, V]
+	nilChecker NilChecker[V]
+}
+
+// BKVTreeEntry represents the key-value pair contained within nodes.
+type BKVTreeEntry[K comparable, V any] struct {
+	Key   K
+	Value V
+}
+
+// NewBKVTree instantiates a B-tree with `m` (maximum number of children) and a custom key comparator.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety,
+// which is false in default.
+// Note that the `m` must be greater or equal than 3, or else it panics.
+func NewBKVTree[K comparable, V any](m int, comparator func(v1, v2 K) int, safe ...bool) *BKVTree[K, V] {
+	return &BKVTree[K, V]{
+		mu:         rwmutex.Create(safe...),
+		m:          m,
+		comparator: comparator,
+		tree:       btree.NewWith[K, V](m, comparator),
+	}
+}
+
+// NewBKVTreeWithChecker instantiates a B-tree with `m` (maximum number of children), a custom key comparator and nil checker.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety, which is false in default.
+// The parameter `checker` is used to specify whether the given value is nil.
+func NewBKVTreeWithChecker[K comparable, V any](m int, comparator func(v1, v2 K) int, checker NilChecker[V], safe ...bool) *BKVTree[K, V] {
+	t := NewBKVTree[K, V](m, comparator, safe...)
+	t.SetNilChecker(checker)
+	return t
+}
+
+// NewBKVTreeFrom instantiates a B-tree with `m` (maximum number of children), a custom key comparator and data map.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety,
+// which is false in default.
+func NewBKVTreeFrom[K comparable, V any](m int, comparator func(v1, v2 K) int, data map[K]V, safe ...bool) *BKVTree[K, V] {
+	tree := NewBKVTree[K, V](m, comparator, safe...)
+	for k, v := range data {
+		tree.doSet(k, v)
+	}
+	return tree
+}
+
+// NewBKVTreeWithCheckerFrom instantiates a B-tree with `m` (maximum number of children), a custom key comparator, nil checker and data map.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety, which is false in default.
+// The parameter `checker` is used to specify whether the given value is nil.
+func NewBKVTreeWithCheckerFrom[K comparable, V any](m int, comparator func(v1, v2 K) int, data map[K]V, checker NilChecker[V], safe ...bool) *BKVTree[K, V] {
+	tree := NewBKVTreeWithChecker[K, V](m, comparator, checker, safe...)
+	for k, v := range data {
+		tree.doSet(k, v)
+	}
+	return tree
+}
+
+// SetNilChecker registers a custom nil checker function for the map values.
+// This function is used to determine if a value should be considered as nil.
+// The nil checker function takes a value of type V and returns a boolean indicating
+// whether the value should be treated as nil.
+func (tree *BKVTree[K, V]) SetNilChecker(nilChecker NilChecker[V]) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	tree.nilChecker = nilChecker
+}
+
+// isNil checks whether the given value is nil.
+// It first checks if a custom nil checker function is registered and uses it if available,
+// otherwise it falls back to the default empty.IsNil function.
+func (tree *BKVTree[K, V]) isNil(v V) bool {
+	if tree.nilChecker != nil {
+		return tree.nilChecker(v)
+	}
+	return empty.IsNil(v)
+}
+
+// Clone clones and returns a new tree from current tree.
+func (tree *BKVTree[K, V]) Clone() *BKVTree[K, V] {
+	if tree == nil {
+		return nil
+	}
+	newTree := NewBKVTree[K, V](tree.m, tree.comparator, tree.mu.IsSafe())
+	newTree.Sets(tree.Map())
+	return newTree
+}
+
+// Set sets key-value pair into the tree.
+func (tree *BKVTree[K, V]) Set(key K, value V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	tree.doSet(key, value)
+}
+
+// Sets batch sets key-values to the tree.
+func (tree *BKVTree[K, V]) Sets(data map[K]V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	for k, v := range data {
+		tree.doSet(k, v)
+	}
+}
+
+// SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
+// It returns false if `key` exists, and such setting key-value pair operation would be ignored.
+func (tree *BKVTree[K, V]) SetIfNotExist(key K, value V) bool {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if _, ok := tree.doGet(key); !ok {
+		tree.doSet(key, value)
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
+// It returns false if `key` exists, and such setting key-value pair operation would be ignored.
+func (tree *BKVTree[K, V]) SetIfNotExistFunc(key K, f func() V) bool {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if _, ok := tree.doGet(key); !ok {
+		tree.doSet(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
+// It returns false if `key` exists, and such setting key-value pair operation would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function `f` within mutex lock.
+func (tree *BKVTree[K, V]) SetIfNotExistFuncLock(key K, f func() V) bool {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if _, ok := tree.doGet(key); !ok {
+		tree.doSet(key, f())
+		return true
+	}
+	return false
+}
+
+// Get searches the `key` in the tree and returns its associated `value` or nil if key is not found in tree.
+//
+// Note that, the `nil` value from Get function cannot be used to determine key existence, please use Contains function
+// to do so.
+func (tree *BKVTree[K, V]) Get(key K) (value V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	value, _ = tree.doGet(key)
+	return
+}
+
+// GetOrSet returns its `value` of `key`, or sets value with given `value` if it does not exist and then returns
+// this value.
+func (tree *BKVTree[K, V]) GetOrSet(key K, value V) V {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if v, ok := tree.doGet(key); !ok {
+		return tree.doSet(key, value)
+	} else {
+		return v
+	}
+}
+
+// GetOrSetFunc returns its `value` of `key`, or sets value with returned value of callback function `f` if it does not
+// exist and then returns this value.
+func (tree *BKVTree[K, V]) GetOrSetFunc(key K, f func() V) V {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if v, ok := tree.doGet(key); !ok {
+		return tree.doSet(key, f())
+	} else {
+		return v
+	}
+}
+
+// GetOrSetFuncLock returns its `value` of `key`, or sets value with returned value of callback function `f` if it does
+// not exist and then returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f` within mutex lock.
+func (tree *BKVTree[K, V]) GetOrSetFuncLock(key K, f func() V) V {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if v, ok := tree.doGet(key); !ok {
+		return tree.doSet(key, f())
+	} else {
+		return v
+	}
+}
+
+// GetVar returns a gvar.Var with the value by given `key`.
+// Note that, the returned gvar.Var is un-concurrent safe.
+//
+// Also see function Get.
+func (tree *BKVTree[K, V]) GetVar(key K) *gvar.Var {
+	return gvar.New(tree.Get(key))
+}
+
+// GetVarOrSet returns a gvar.Var with result from GetVarOrSet.
+// Note that, the returned gvar.Var is un-concurrent safe.
+//
+// Also see function GetOrSet.
+func (tree *BKVTree[K, V]) GetVarOrSet(key K, value V) *gvar.Var {
+	return gvar.New(tree.GetOrSet(key, value))
+}
+
+// GetVarOrSetFunc returns a gvar.Var with result from GetOrSetFunc.
+// Note that, the returned gvar.Var is un-concurrent safe.
+//
+// Also see function GetOrSetFunc.
+func (tree *BKVTree[K, V]) GetVarOrSetFunc(key K, f func() V) *gvar.Var {
+	return gvar.New(tree.GetOrSetFunc(key, f))
+}
+
+// GetVarOrSetFuncLock returns a gvar.Var with result from GetOrSetFuncLock.
+// Note that, the returned gvar.Var is un-concurrent safe.
+//
+// Also see function GetOrSetFuncLock.
+func (tree *BKVTree[K, V]) GetVarOrSetFuncLock(key K, f func() V) *gvar.Var {
+	return gvar.New(tree.GetOrSetFuncLock(key, f))
+}
+
+// Search searches the tree with given `key`.
+// Second return parameter `found` is true if key was found, otherwise false.
+func (tree *BKVTree[K, V]) Search(key K) (value V, found bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Get(key)
+}
+
+// Contains checks and returns whether given `key` exists in the tree.
+func (tree *BKVTree[K, V]) Contains(key K) bool {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	_, ok := tree.doGet(key)
+	return ok
+}
+
+// Size returns number of nodes in the tree.
+func (tree *BKVTree[K, V]) Size() int {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Size()
+}
+
+// IsEmpty returns true if tree does not contain any nodes
+func (tree *BKVTree[K, V]) IsEmpty() bool {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Size() == 0
+}
+
+// Remove removes the node from the tree by `key`, and returns its associated value of `key`.
+// The given `key` should adhere to the comparator's type assertion, otherwise method panics.
+func (tree *BKVTree[K, V]) Remove(key K) (value V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	return tree.doRemove(key)
+}
+
+// Removes batch deletes key-value pairs from the tree by `keys`.
+func (tree *BKVTree[K, V]) Removes(keys []K) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	for _, key := range keys {
+		tree.doRemove(key)
+	}
+}
+
+// Clear removes all nodes from the tree.
+func (tree *BKVTree[K, V]) Clear() {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	tree.tree.Clear()
+}
+
+// Keys returns all keys from the tree in order by its comparator.
+func (tree *BKVTree[K, V]) Keys() []K {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Keys()
+}
+
+// Values returns all values from the true in order by its comparator based on the key.
+func (tree *BKVTree[K, V]) Values() []V {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Values()
+}
+
+// Replace clears the data of the tree and sets the nodes by given `data`.
+func (tree *BKVTree[K, V]) Replace(data map[K]V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	tree.tree.Clear()
+	for k, v := range data {
+		tree.doSet(k, v)
+	}
+}
+
+// Map returns all key-value pairs as map.
+func (tree *BKVTree[K, V]) Map() map[K]V {
+	m := make(map[K]V, tree.Size())
+	tree.IteratorAsc(func(key K, value V) bool {
+		m[key] = value
+		return true
+	})
+	return m
+}
+
+// MapStrAny returns all key-value items as map[string]any.
+func (tree *BKVTree[K, V]) MapStrAny() map[string]any {
+	m := make(map[string]any, tree.Size())
+	tree.IteratorAsc(func(key K, value V) bool {
+		m[gconv.String(key)] = value
+		return true
+	})
+	return m
+}
+
+// Print prints the tree to stdout.
+func (tree *BKVTree[K, V]) Print() {
+	fmt.Println(tree.String())
+}
+
+// String returns a string representation of container (for debugging purposes)
+func (tree *BKVTree[K, V]) String() string {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return gstr.Replace(tree.tree.String(), "BTree\n", "")
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (tree *BKVTree[K, V]) MarshalJSON() (jsonBytes []byte, err error) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+
+	elements := make(map[string]V)
+	it := tree.tree.Iterator()
+	for it.Next() {
+		elements[gconv.String(it.Key())] = it.Value()
+	}
+	return json.Marshal(&elements)
+}
+
+// Iterator is alias of IteratorAsc.
+//
+// Also see IteratorAsc.
+func (tree *BKVTree[K, V]) Iterator(f func(key K, value V) bool) {
+	tree.IteratorAsc(f)
+}
+
+// IteratorFrom is alias of IteratorAscFrom.
+//
+// Also see IteratorAscFrom.
+func (tree *BKVTree[K, V]) IteratorFrom(key K, match bool, f func(key K, value V) bool) {
+	tree.IteratorAscFrom(key, match, f)
+}
+
+// IteratorAsc iterates the tree readonly in ascending order with given callback function `f`.
+// If callback function `f` returns true, then it continues iterating; or false to stop.
+func (tree *BKVTree[K, V]) IteratorAsc(f func(key K, value V) bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	var (
+		ok bool
+		it = tree.tree.Iterator()
+	)
+	for it.Begin(); it.Next(); {
+		index, value := it.Key(), it.Value()
+		if ok = f(index, value); !ok {
+			break
+		}
+	}
+}
+
+// IteratorAscFrom iterates the tree readonly in ascending order with given callback function `f`.
+//
+// The parameter `key` specifies the start entry for iterating.
+// The parameter `match` specifies whether starting iterating only if the `key` is fully matched, or else using index
+// searching iterating.
+// If callback function `f` returns true, then it continues iterating; or false to stop.
+func (tree *BKVTree[K, V]) IteratorAscFrom(key K, match bool, f func(key K, value V) bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	var keys = tree.tree.Keys()
+	index, canIterator := iteratorFromGetIndexT(key, keys, match)
+	if !canIterator {
+		return
+	}
+	for ; index < len(keys); index++ {
+		f(keys[index], tree.Get(keys[index]))
+	}
+}
+
+// IteratorDesc iterates the tree readonly in descending order with given callback function `f`.
+//
+// If callback function `f` returns true, then it continues iterating; or false to stop.
+func (tree *BKVTree[K, V]) IteratorDesc(f func(key K, value V) bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	var (
+		ok bool
+		it = tree.tree.Iterator()
+	)
+	for it.End(); it.Prev(); {
+		index, value := it.Key(), it.Value()
+		if ok = f(index, value); !ok {
+			break
+		}
+	}
+}
+
+// IteratorDescFrom iterates the tree readonly in descending order with given callback function `f`.
+//
+// The parameter `key` specifies the start entry for iterating.
+// The parameter `match` specifies whether starting iterating only if the `key` is fully matched, or else using index
+// searching iterating.
+// If callback function `f` returns true, then it continues iterating; or false to stop.
+func (tree *BKVTree[K, V]) IteratorDescFrom(key K, match bool, f func(key K, value V) bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	var keys = tree.tree.Keys()
+	index, canIterator := iteratorFromGetIndexT(key, keys, match)
+	if !canIterator {
+		return
+	}
+	for ; index >= 0; index-- {
+		f(keys[index], tree.Get(keys[index]))
+	}
+}
+
+// Height returns the height of the tree.
+func (tree *BKVTree[K, V]) Height() int {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Height()
+}
+
+// Left returns the minimum element corresponding to the comparator of the tree or nil if the tree is empty.
+func (tree *BKVTree[K, V]) Left() *BKVTreeEntry[K, V] {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	node := tree.tree.Left()
+	if node == nil || node.Entries == nil || len(node.Entries) == 0 {
+		return nil
+	}
+	return &BKVTreeEntry[K, V]{
+		Key:   node.Entries[0].Key,
+		Value: node.Entries[0].Value,
+	}
+}
+
+// Right returns the maximum element corresponding to the comparator of the tree or nil if the tree is empty.
+func (tree *BKVTree[K, V]) Right() *BKVTreeEntry[K, V] {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	node := tree.tree.Right()
+	if node == nil || node.Entries == nil || len(node.Entries) == 0 {
+		return nil
+	}
+	return &BKVTreeEntry[K, V]{
+		Key:   node.Entries[len(node.Entries)-1].Key,
+		Value: node.Entries[len(node.Entries)-1].Value,
+	}
+}
+
+// doSet inserts key-value pair node into the tree without lock.
+// If `key` already exists, then its value is updated with the new value.
+// If `value` is type of <func() any>, it will be executed and its return value will be set to the map with `key`.
+//
+// It returns value with given `key`.
+func (tree *BKVTree[K, V]) doSet(key K, value V) V {
+	if tree.isNil(value) {
+		return value
+	}
+	tree.tree.Put(key, value)
+	return value
+}
+
+// doGet get the value from the tree by key without lock.
+func (tree *BKVTree[K, V]) doGet(key K) (value V, ok bool) {
+	return tree.tree.Get(key)
+}
+
+// doRemove removes key from tree and returns its associated value without lock.
+// Note that, the given `key` should adhere to the comparator's type assertion, otherwise method panics.
+func (tree *BKVTree[K, V]) doRemove(key K) (value V) {
+	value, _ = tree.tree.Get(key)
+	tree.tree.Remove(key)
+	return
+}
diff --git a/container/gtree/gtree_k_v_redblacktree.go b/container/gtree/gtree_k_v_redblacktree.go
new file mode 100644
index 000000000..49936d73b
--- /dev/null
+++ b/container/gtree/gtree_k_v_redblacktree.go
@@ -0,0 +1,655 @@
+// 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 gtree
+
+import (
+	"fmt"
+
+	"github.com/emirpasic/gods/v2/trees/redblacktree"
+
+	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gutil"
+)
+
+// RedBlackKVTree holds elements of the red-black tree.
+type RedBlackKVTree[K comparable, V any] struct {
+	mu         rwmutex.RWMutex
+	comparator func(v1, v2 K) int
+	tree       *redblacktree.Tree[K, V]
+	nilChecker NilChecker[V]
+}
+
+// RedBlackKVTreeNode is a single element within the tree.
+type RedBlackKVTreeNode[K comparable, V any] struct {
+	Key   K
+	Value V
+}
+
+// NewRedBlackKVTree instantiates a red-black tree with the custom key comparator.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety,
+// which is false in default.
+func NewRedBlackKVTree[K comparable, V any](comparator func(v1, v2 K) int, safe ...bool) *RedBlackKVTree[K, V] {
+	var tree RedBlackKVTree[K, V]
+	RedBlackKVTreeInit(&tree, comparator, safe...)
+	return &tree
+}
+
+// NewRedBlackKVTreeWithChecker instantiates a red-black tree with the custom key comparator and `nilChecker`.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety, which is false in default.
+// The parameter `checker` is used to specify whether the given value is nil.
+func NewRedBlackKVTreeWithChecker[K comparable, V any](comparator func(v1, v2 K) int, checker NilChecker[V], safe ...bool) *RedBlackKVTree[K, V] {
+	t := NewRedBlackKVTree[K, V](comparator, safe...)
+	t.SetNilChecker(checker)
+	return t
+}
+
+// NewRedBlackKVTreeFrom instantiates a red-black tree with the custom key comparator and `data` map.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety,
+// which is false in default.
+func NewRedBlackKVTreeFrom[K comparable, V any](comparator func(v1, v2 K) int, data map[K]V, safe ...bool) *RedBlackKVTree[K, V] {
+	var tree RedBlackKVTree[K, V]
+	RedBlackKVTreeInitFrom(&tree, comparator, data, safe...)
+	return &tree
+}
+
+// NewRedBlackKVTreeWithCheckerFrom instantiates a red-black tree with the custom key comparator, `data` map and `nilChecker`.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety, which is false in default.
+// The parameter `checker` is used to specify whether the given value is nil.
+func NewRedBlackKVTreeWithCheckerFrom[K comparable, V any](comparator func(v1, v2 K) int, data map[K]V, checker NilChecker[V], safe ...bool) *RedBlackKVTree[K, V] {
+	t := NewRedBlackKVTreeWithChecker[K, V](comparator, checker, safe...)
+	for k, v := range data {
+		t.doSet(k, v)
+	}
+	return t
+}
+
+// RedBlackKVTreeInit instantiates a red-black tree with the custom key comparator.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety,
+// which is false in default.
+func RedBlackKVTreeInit[K comparable, V any](tree *RedBlackKVTree[K, V], comparator func(v1, v2 K) int, safe ...bool) {
+	if tree == nil {
+		return
+	}
+	tree.mu = rwmutex.Create(safe...)
+	tree.comparator = comparator
+	tree.tree = redblacktree.NewWith[K, V](comparator)
+}
+
+// RedBlackKVTreeInitFrom instantiates a red-black tree with the custom key comparator and `data` map.
+// The parameter `safe` is used to specify whether using tree in concurrent-safety,
+// which is false in default.
+func RedBlackKVTreeInitFrom[K comparable, V any](tree *RedBlackKVTree[K, V], comparator func(v1, v2 K) int, data map[K]V, safe ...bool) {
+	if tree == nil {
+		return
+	}
+	RedBlackKVTreeInit(tree, comparator, safe...)
+	for k, v := range data {
+		tree.doSet(k, v)
+	}
+}
+
+// SetNilChecker registers a custom nil checker function for the map values.
+// This function is used to determine if a value should be considered as nil.
+// The nil checker function takes a value of type V and returns a boolean indicating
+// whether the value should be treated as nil.
+func (tree *RedBlackKVTree[K, V]) SetNilChecker(nilChecker NilChecker[V]) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	tree.nilChecker = nilChecker
+}
+
+// isNil checks whether the given value is nil.
+// It first checks if a custom nil checker function is registered and uses it if available,
+// otherwise it falls back to the default empty.IsNil function.
+func (tree *RedBlackKVTree[K, V]) isNil(v V) bool {
+	if tree.nilChecker != nil {
+		return tree.nilChecker(v)
+	}
+	return empty.IsNil(v)
+}
+
+// SetComparator sets/changes the comparator for sorting.
+func (tree *RedBlackKVTree[K, V]) SetComparator(comparator func(a, b K) int) {
+	tree.comparator = comparator
+	if tree.tree == nil {
+		tree.tree = redblacktree.NewWith[K, V](comparator)
+	}
+	size := tree.tree.Size()
+	if size > 0 {
+		m := tree.Map()
+		tree.Sets(m)
+	}
+}
+
+// Clone clones and returns a new tree from current tree.
+func (tree *RedBlackKVTree[K, V]) Clone() *RedBlackKVTree[K, V] {
+	if tree == nil {
+		return nil
+	}
+	newTree := NewRedBlackKVTree[K, V](tree.comparator, tree.mu.IsSafe())
+	newTree.Sets(tree.Map())
+	return newTree
+}
+
+// Set sets key-value pair into the tree.
+func (tree *RedBlackKVTree[K, V]) Set(key K, value V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	tree.doSet(key, value)
+}
+
+// Sets batch sets key-values to the tree.
+func (tree *RedBlackKVTree[K, V]) Sets(data map[K]V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	for key, value := range data {
+		tree.doSet(key, value)
+	}
+}
+
+// SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
+// It returns false if `key` exists, and such setting key-value pair operation would be ignored.
+func (tree *RedBlackKVTree[K, V]) SetIfNotExist(key K, value V) bool {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if _, ok := tree.doGet(key); !ok {
+		tree.doSet(key, value)
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
+// It returns false if `key` exists, and such setting key-value pair operation would be ignored.
+func (tree *RedBlackKVTree[K, V]) SetIfNotExistFunc(key K, f func() V) bool {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if _, ok := tree.doGet(key); !ok {
+		tree.doSet(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
+// It returns false if `key` exists, and such setting key-value pair operation would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function `f` within mutex lock.
+func (tree *RedBlackKVTree[K, V]) SetIfNotExistFuncLock(key K, f func() V) bool {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if _, ok := tree.doGet(key); !ok {
+		tree.doSet(key, f())
+		return true
+	}
+	return false
+}
+
+// Get searches the `key` in the tree and returns its associated `value` or nil if key is not found in tree.
+//
+// Note that, the `nil` value from Get function cannot be used to determine key existence, please use Contains function
+// to do so.
+func (tree *RedBlackKVTree[K, V]) Get(key K) (value V) {
+	value, _ = tree.Search(key)
+	return
+}
+
+// GetOrSet returns its `value` of `key`, or sets value with given `value` if it does not exist and then returns
+// this value.
+func (tree *RedBlackKVTree[K, V]) GetOrSet(key K, value V) V {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if v, ok := tree.doGet(key); !ok {
+		return tree.doSet(key, value)
+	} else {
+		return v
+	}
+}
+
+// GetOrSetFunc returns its `value` of `key`, or sets value with returned value of callback function `f` if it does not
+// exist and then returns this value.
+func (tree *RedBlackKVTree[K, V]) GetOrSetFunc(key K, f func() V) V {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if v, ok := tree.doGet(key); !ok {
+		return tree.doSet(key, f())
+	} else {
+		return v
+	}
+}
+
+// GetOrSetFuncLock returns its `value` of `key`, or sets value with returned value of callback function `f` if it does
+// not exist and then returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f` within mutex lock.
+func (tree *RedBlackKVTree[K, V]) GetOrSetFuncLock(key K, f func() V) V {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if v, ok := tree.doGet(key); !ok {
+		return tree.doSet(key, f())
+	} else {
+		return v
+	}
+}
+
+// GetVar returns a gvar.Var with the value by given `key`.
+// Note that, the returned gvar.Var is un-concurrent safe.
+//
+// Also see function Get.
+func (tree *RedBlackKVTree[K, V]) GetVar(key K) *gvar.Var {
+	return gvar.New(tree.Get(key))
+}
+
+// GetVarOrSet returns a gvar.Var with result from GetVarOrSet.
+// Note that, the returned gvar.Var is un-concurrent safe.
+//
+// Also see function GetOrSet.
+func (tree *RedBlackKVTree[K, V]) GetVarOrSet(key K, value V) *gvar.Var {
+	return gvar.New(tree.GetOrSet(key, value))
+}
+
+// GetVarOrSetFunc returns a gvar.Var with result from GetOrSetFunc.
+// Note that, the returned gvar.Var is un-concurrent safe.
+//
+// Also see function GetOrSetFunc.
+func (tree *RedBlackKVTree[K, V]) GetVarOrSetFunc(key K, f func() V) *gvar.Var {
+	return gvar.New(tree.GetOrSetFunc(key, f))
+}
+
+// GetVarOrSetFuncLock returns a gvar.Var with result from GetOrSetFuncLock.
+// Note that, the returned gvar.Var is un-concurrent safe.
+//
+// Also see function GetOrSetFuncLock.
+func (tree *RedBlackKVTree[K, V]) GetVarOrSetFuncLock(key K, f func() V) *gvar.Var {
+	return gvar.New(tree.GetOrSetFuncLock(key, f))
+}
+
+// Search searches the tree with given `key`.
+// Second return parameter `found` is true if key was found, otherwise false.
+func (tree *RedBlackKVTree[K, V]) Search(key K) (value V, found bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	if node, found := tree.doGet(key); found {
+		return node, true
+	}
+	found = false
+	return
+}
+
+// Contains checks and returns whether given `key` exists in the tree.
+func (tree *RedBlackKVTree[K, V]) Contains(key K) bool {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	_, ok := tree.doGet(key)
+	return ok
+}
+
+// Size returns number of nodes in the tree.
+func (tree *RedBlackKVTree[K, V]) Size() int {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Size()
+}
+
+// IsEmpty returns true if tree does not contain any nodes.
+func (tree *RedBlackKVTree[K, V]) IsEmpty() bool {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Size() == 0
+}
+
+// Remove removes the node from the tree by `key`, and returns its associated value of `key`.
+// The given `key` should adhere to the comparator's type assertion, otherwise method panics.
+func (tree *RedBlackKVTree[K, V]) Remove(key K) (value V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	return tree.doRemove(key)
+}
+
+// Removes batch deletes key-value pairs from the tree by `keys`.
+func (tree *RedBlackKVTree[K, V]) Removes(keys []K) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	for _, key := range keys {
+		tree.doRemove(key)
+	}
+}
+
+// Clear removes all nodes from the tree.
+func (tree *RedBlackKVTree[K, V]) Clear() {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	tree.tree.Clear()
+}
+
+// Keys returns all keys from the tree in order by its comparator.
+func (tree *RedBlackKVTree[K, V]) Keys() []K {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Keys()
+}
+
+// Values returns all values from the true in order by its comparator based on the key.
+func (tree *RedBlackKVTree[K, V]) Values() []V {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return tree.tree.Values()
+}
+
+// Replace clears the data of the tree and sets the nodes by given `data`.
+func (tree *RedBlackKVTree[K, V]) Replace(data map[K]V) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	tree.tree.Clear()
+	for k, v := range data {
+		tree.doSet(k, v)
+	}
+}
+
+// Print prints the tree to stdout.
+func (tree *RedBlackKVTree[K, V]) Print() {
+	fmt.Println(tree.String())
+}
+
+// String returns a string representation of container
+func (tree *RedBlackKVTree[K, V]) String() string {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	return gstr.Replace(tree.tree.String(), "RedBlackTree\n", "")
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (tree RedBlackKVTree[K, V]) MarshalJSON() (jsonBytes []byte, err error) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+
+	elements := make(map[string]V)
+	it := tree.tree.Iterator()
+	for it.Next() {
+		elements[gconv.String(it.Key())] = it.Value()
+	}
+	return json.Marshal(&elements)
+}
+
+// Map returns all key-value pairs as map.
+func (tree *RedBlackKVTree[K, V]) Map() map[K]V {
+	m := make(map[K]V, tree.Size())
+	tree.IteratorAsc(func(key K, value V) bool {
+		m[key] = value
+		return true
+	})
+	return m
+}
+
+// MapStrAny returns all key-value items as map[string]any.
+func (tree *RedBlackKVTree[K, V]) MapStrAny() map[string]any {
+	m := make(map[string]any, tree.Size())
+	tree.IteratorAsc(func(key K, value V) bool {
+		m[gconv.String(key)] = value
+		return true
+	})
+	return m
+}
+
+// Iterator is alias of IteratorAsc.
+//
+// Also see IteratorAsc.
+func (tree *RedBlackKVTree[K, V]) Iterator(f func(key K, value V) bool) {
+	tree.IteratorAsc(f)
+}
+
+// IteratorFrom is alias of IteratorAscFrom.
+//
+// Also see IteratorAscFrom.
+func (tree *RedBlackKVTree[K, V]) IteratorFrom(key K, match bool, f func(key K, value V) bool) {
+	tree.IteratorAscFrom(key, match, f)
+}
+
+// IteratorAsc iterates the tree readonly in ascending order with given callback function `f`.
+// If callback function `f` returns true, then it continues iterating; or false to stop.
+func (tree *RedBlackKVTree[K, V]) IteratorAsc(f func(key K, value V) bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	var (
+		ok bool
+		it = tree.tree.Iterator()
+	)
+	for it.Begin(); it.Next(); {
+		index, value := it.Key(), it.Value()
+		if ok = f(index, value); !ok {
+			break
+		}
+	}
+}
+
+// IteratorAscFrom iterates the tree readonly in ascending order with given callback function `f`.
+//
+// The parameter `key` specifies the start entry for iterating.
+// The parameter `match` specifies whether starting iterating only if the `key` is fully matched, or else using index
+// searching iterating.
+// If callback function `f` returns true, then it continues iterating; or false to stop.
+func (tree *RedBlackKVTree[K, V]) IteratorAscFrom(key K, match bool, f func(key K, value V) bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	var keys = tree.tree.Keys()
+	index, canIterator := iteratorFromGetIndexT(key, keys, match)
+	if !canIterator {
+		return
+	}
+	for ; index < len(keys); index++ {
+		f(keys[index], tree.Get(keys[index]))
+	}
+}
+
+// IteratorDesc iterates the tree readonly in descending order with given callback function `f`.
+//
+// If callback function `f` returns true, then it continues iterating; or false to stop.
+func (tree *RedBlackKVTree[K, V]) IteratorDesc(f func(key K, value V) bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	var (
+		ok bool
+		it = tree.tree.Iterator()
+	)
+	for it.End(); it.Prev(); {
+		index, value := it.Key(), it.Value()
+		if ok = f(index, value); !ok {
+			break
+		}
+	}
+}
+
+// IteratorDescFrom iterates the tree readonly in descending order with given callback function `f`.
+//
+// The parameter `key` specifies the start entry for iterating.
+// The parameter `match` specifies whether starting iterating only if the `key` is fully matched, or else using index
+// searching iterating.
+// If callback function `f` returns true, then it continues iterating; or false to stop.
+func (tree *RedBlackKVTree[K, V]) IteratorDescFrom(key K, match bool, f func(key K, value V) bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	var keys = tree.tree.Keys()
+	index, canIterator := iteratorFromGetIndexT(key, keys, match)
+	if !canIterator {
+		return
+	}
+	for ; index >= 0; index-- {
+		f(keys[index], tree.Get(keys[index]))
+	}
+}
+
+// Left returns the minimum element corresponding to the comparator of the tree or nil if the tree is empty.
+func (tree *RedBlackKVTree[K, V]) Left() *RedBlackKVTreeNode[K, V] {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	node := tree.tree.Left()
+	if node == nil {
+		return nil
+	}
+	return &RedBlackKVTreeNode[K, V]{
+		Key:   node.Key,
+		Value: node.Value,
+	}
+}
+
+// Right returns the maximum element corresponding to the comparator of the tree or nil if the tree is empty.
+func (tree *RedBlackKVTree[K, V]) Right() *RedBlackKVTreeNode[K, V] {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	node := tree.tree.Right()
+	if node == nil {
+		return nil
+	}
+	return &RedBlackKVTreeNode[K, V]{
+		Key:   node.Key,
+		Value: node.Value,
+	}
+}
+
+// Floor Finds floor node of the input key, returns the floor node or nil if no floor node is found.
+// The second returned parameter `found` is true if floor was found, otherwise false.
+//
+// Floor node is defined as the largest node that is smaller than or equal to the given node.
+// A floor node may not be found, either because the tree is empty, or because
+// all nodes in the tree is larger than the given node.
+//
+// Key should adhere to the comparator's type assertion, otherwise method panics.
+func (tree *RedBlackKVTree[K, V]) Floor(key K) (floor *RedBlackKVTreeNode[K, V], found bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	node, found := tree.tree.Floor(key)
+	if !found {
+		return nil, false
+	}
+	return &RedBlackKVTreeNode[K, V]{
+		Key:   node.Key,
+		Value: node.Value,
+	}, true
+}
+
+// Ceiling finds ceiling node of the input key, returns the ceiling node or nil if no ceiling node is found.
+// The second return parameter `found` is true if ceiling was found, otherwise false.
+//
+// Ceiling node is defined as the smallest node that is larger than or equal to the given node.
+// A ceiling node may not be found, either because the tree is empty, or because
+// all nodes in the tree is smaller than the given node.
+//
+// Key should adhere to the comparator's type assertion, otherwise method panics.
+func (tree *RedBlackKVTree[K, V]) Ceiling(key K) (ceiling *RedBlackKVTreeNode[K, V], found bool) {
+	tree.mu.RLock()
+	defer tree.mu.RUnlock()
+	node, found := tree.tree.Ceiling(key)
+	if !found {
+		return nil, false
+	}
+	return &RedBlackKVTreeNode[K, V]{
+		Key:   node.Key,
+		Value: node.Value,
+	}, true
+}
+
+// Flip exchanges key-value of the tree to value-key.
+// Note that you should guarantee the value is the same type as key,
+// or else the comparator would panic.
+//
+// If the type of value is different with key, you pass the new `comparator`.
+func (tree *RedBlackKVTree[K, V]) Flip(comparator ...func(v1, v2 K) int) {
+	var t = new(RedBlackKVTree[K, V])
+	if len(comparator) > 0 {
+		t = NewRedBlackKVTree[K, V](comparator[0], tree.mu.IsSafe())
+	} else {
+		t = NewRedBlackKVTree[K, V](tree.comparator, tree.mu.IsSafe())
+	}
+	var (
+		newKey   K
+		newValue V
+	)
+	tree.IteratorAsc(func(key K, value V) bool {
+		if err := gconv.Scan(key, &newValue); err != nil {
+			panic(err)
+		}
+		if err := gconv.Scan(value, &newKey); err != nil {
+			panic(err)
+		}
+		t.doSet(newKey, newValue)
+		return true
+	})
+	tree.Clear()
+	tree.Sets(t.Map())
+}
+
+// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
+func (tree *RedBlackKVTree[K, V]) UnmarshalJSON(b []byte) (err error) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if tree.comparator == nil {
+		tree.comparator = gutil.ComparatorTStr[K]
+		tree.tree = redblacktree.NewWith[K, V](tree.comparator)
+	}
+	var data map[string]any
+	if err := json.UnmarshalUseNumber(b, &data); err != nil {
+		return err
+	}
+	var m = make(map[K]V)
+	if err = gconv.Scan(data, &m); err != nil {
+		return
+	}
+	for k, v := range m {
+		tree.doSet(k, v)
+	}
+	return nil
+}
+
+// UnmarshalValue is an interface implement which sets any type of value for map.
+func (tree *RedBlackKVTree[K, V]) UnmarshalValue(value any) (err error) {
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	if tree.comparator == nil {
+		tree.comparator = gutil.ComparatorTStr[K]
+		tree.tree = redblacktree.NewWith[K, V](tree.comparator)
+	}
+	var m = make(map[K]V)
+	if err = gconv.Scan(value, &m); err != nil {
+		return
+	}
+	for k, v := range m {
+		tree.doSet(k, v)
+	}
+	return
+}
+
+// doSet inserts key-value pair node into the tree without lock.
+// If `key` already exists, then its value is updated with the new value.
+// If `value` is type of <func() any>, it will be executed and its return value will be set to the map with `key`.
+//
+// It returns value with given `key`.
+func (tree *RedBlackKVTree[K, V]) doSet(key K, value V) (ret V) {
+	if tree.isNil(value) {
+		return
+	}
+	tree.tree.Put(key, value)
+	return value
+}
+
+// doGet retrieves and returns the value of given key from tree without lock.
+func (tree *RedBlackKVTree[K, V]) doGet(key K) (value V, found bool) {
+	return tree.tree.Get(key)
+}
+
+// doRemove removes key from tree and returns its associated value without lock.
+// Note that, the given `key` should adhere to the comparator's type assertion, otherwise method panics.
+func (tree *RedBlackKVTree[K, V]) doRemove(key K) (value V) {
+	value, _ = tree.tree.Get(key)
+	tree.tree.Remove(key)
+	return
+}
diff --git a/container/gtree/gtree_redblacktree.go b/container/gtree/gtree_redblacktree.go
index a94dc585e..9735075fb 100644
--- a/container/gtree/gtree_redblacktree.go
+++ b/container/gtree/gtree_redblacktree.go
@@ -7,15 +7,9 @@
 package gtree
 
 import (
-	"fmt"
-
-	"github.com/emirpasic/gods/trees/redblacktree"
+	"sync"
 
 	"github.com/gogf/gf/v2/container/gvar"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/text/gstr"
-	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/gutil"
 )
 
@@ -23,25 +17,19 @@ var _ iTree = (*RedBlackTree)(nil)
 
 // RedBlackTree holds elements of the red-black tree.
 type RedBlackTree struct {
-	mu         rwmutex.RWMutex
-	comparator func(v1, v2 any) int
-	tree       *redblacktree.Tree
+	*RedBlackKVTree[any, any]
+	once sync.Once
 }
 
 // RedBlackTreeNode is a single element within the tree.
-type RedBlackTreeNode struct {
-	Key   any
-	Value any
-}
+type RedBlackTreeNode = RedBlackKVTreeNode[any, any]
 
 // NewRedBlackTree instantiates a red-black tree with the custom key comparator.
 // The parameter `safe` is used to specify whether using tree in concurrent-safety,
 // which is false in default.
 func NewRedBlackTree(comparator func(v1, v2 any) int, safe ...bool) *RedBlackTree {
 	return &RedBlackTree{
-		mu:         rwmutex.Create(safe...),
-		comparator: comparator,
-		tree:       redblacktree.NewWith(comparator),
+		RedBlackKVTree: NewRedBlackKVTree[any, any](comparator, safe...),
 	}
 }
 
@@ -49,71 +37,61 @@ func NewRedBlackTree(comparator func(v1, v2 any) int, safe ...bool) *RedBlackTre
 // The parameter `safe` is used to specify whether using tree in concurrent-safety,
 // which is false in default.
 func NewRedBlackTreeFrom(comparator func(v1, v2 any) int, data map[any]any, safe ...bool) *RedBlackTree {
-	tree := NewRedBlackTree(comparator, safe...)
-	for k, v := range data {
-		tree.doSet(k, v)
+	return &RedBlackTree{
+		RedBlackKVTree: NewRedBlackKVTreeFrom(comparator, data, safe...),
 	}
-	return tree
+}
+
+// lazyInit lazily initializes the tree.
+func (tree *RedBlackTree) lazyInit() {
+	tree.once.Do(func() {
+		if tree.RedBlackKVTree == nil {
+			tree.RedBlackKVTree = NewRedBlackKVTree[any, any](gutil.ComparatorTStr[any], false)
+		}
+	})
 }
 
 // SetComparator sets/changes the comparator for sorting.
 func (tree *RedBlackTree) SetComparator(comparator func(a, b any) int) {
-	tree.comparator = comparator
-	if tree.tree == nil {
-		tree.tree = redblacktree.NewWith(comparator)
-	}
-	size := tree.tree.Size()
-	if size > 0 {
-		m := tree.Map()
-		tree.Sets(m)
-	}
+	tree.lazyInit()
+	tree.RedBlackKVTree.SetComparator(comparator)
 }
 
 // Clone clones and returns a new tree from current tree.
 func (tree *RedBlackTree) Clone() *RedBlackTree {
-	newTree := NewRedBlackTree(tree.comparator, tree.mu.IsSafe())
-	newTree.Sets(tree.Map())
-	return newTree
+	if tree == nil {
+		return nil
+	}
+	tree.lazyInit()
+	return &RedBlackTree{
+		RedBlackKVTree: tree.RedBlackKVTree.Clone(),
+	}
 }
 
 // Set sets key-value pair into the tree.
 func (tree *RedBlackTree) Set(key any, value any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	tree.doSet(key, value)
+	tree.lazyInit()
+	tree.RedBlackKVTree.Set(key, value)
 }
 
 // Sets batch sets key-values to the tree.
 func (tree *RedBlackTree) Sets(data map[any]any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	for key, value := range data {
-		tree.doSet(key, value)
-	}
+	tree.lazyInit()
+	tree.RedBlackKVTree.Sets(data)
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and such setting key-value pair operation would be ignored.
 func (tree *RedBlackTree) SetIfNotExist(key any, value any) bool {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if _, ok := tree.doGet(key); !ok {
-		tree.doSet(key, value)
-		return true
-	}
-	return false
+	tree.lazyInit()
+	return tree.RedBlackKVTree.SetIfNotExist(key, value)
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and such setting key-value pair operation would be ignored.
 func (tree *RedBlackTree) SetIfNotExistFunc(key any, f func() any) bool {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if _, ok := tree.doGet(key); !ok {
-		tree.doSet(key, f())
-		return true
-	}
-	return false
+	tree.lazyInit()
+	return tree.RedBlackKVTree.SetIfNotExistFunc(key, f)
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -122,13 +100,8 @@ func (tree *RedBlackTree) SetIfNotExistFunc(key any, f func() any) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` within mutex lock.
 func (tree *RedBlackTree) SetIfNotExistFuncLock(key any, f func() any) bool {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if _, ok := tree.doGet(key); !ok {
-		tree.doSet(key, f)
-		return true
-	}
-	return false
+	tree.lazyInit()
+	return tree.RedBlackKVTree.SetIfNotExistFuncLock(key, f)
 }
 
 // Get searches the `key` in the tree and returns its associated `value` or nil if key is not found in tree.
@@ -136,32 +109,22 @@ func (tree *RedBlackTree) SetIfNotExistFuncLock(key any, f func() any) bool {
 // Note that, the `nil` value from Get function cannot be used to determine key existence, please use Contains function
 // to do so.
 func (tree *RedBlackTree) Get(key any) (value any) {
-	value, _ = tree.Search(key)
-	return
+	tree.lazyInit()
+	return tree.RedBlackKVTree.Get(key)
 }
 
 // GetOrSet returns its `value` of `key`, or sets value with given `value` if it does not exist and then returns
 // this value.
 func (tree *RedBlackTree) GetOrSet(key any, value any) any {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if v, ok := tree.doGet(key); !ok {
-		return tree.doSet(key, value)
-	} else {
-		return v
-	}
+	tree.lazyInit()
+	return tree.RedBlackKVTree.GetOrSet(key, value)
 }
 
 // GetOrSetFunc returns its `value` of `key`, or sets value with returned value of callback function `f` if it does not
 // exist and then returns this value.
 func (tree *RedBlackTree) GetOrSetFunc(key any, f func() any) any {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if v, ok := tree.doGet(key); !ok {
-		return tree.doSet(key, f())
-	} else {
-		return v
-	}
+	tree.lazyInit()
+	return tree.RedBlackKVTree.GetOrSetFunc(key, f)
 }
 
 // GetOrSetFuncLock returns its `value` of `key`, or sets value with returned value of callback function `f` if it does
@@ -169,13 +132,8 @@ func (tree *RedBlackTree) GetOrSetFunc(key any, f func() any) any {
 //
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`within mutex lock.
 func (tree *RedBlackTree) GetOrSetFuncLock(key any, f func() any) any {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if v, ok := tree.doGet(key); !ok {
-		return tree.doSet(key, f)
-	} else {
-		return v
-	}
+	tree.lazyInit()
+	return tree.RedBlackKVTree.GetOrSetFuncLock(key, f)
 }
 
 // GetVar returns a gvar.Var with the value by given `key`.
@@ -183,7 +141,8 @@ func (tree *RedBlackTree) GetOrSetFuncLock(key any, f func() any) any {
 //
 // Also see function Get.
 func (tree *RedBlackTree) GetVar(key any) *gvar.Var {
-	return gvar.New(tree.Get(key))
+	tree.lazyInit()
+	return tree.RedBlackKVTree.GetVar(key)
 }
 
 // GetVarOrSet returns a gvar.Var with result from GetVarOrSet.
@@ -191,7 +150,8 @@ func (tree *RedBlackTree) GetVar(key any) *gvar.Var {
 //
 // Also see function GetOrSet.
 func (tree *RedBlackTree) GetVarOrSet(key any, value any) *gvar.Var {
-	return gvar.New(tree.GetOrSet(key, value))
+	tree.lazyInit()
+	return tree.RedBlackKVTree.GetVarOrSet(key, value)
 }
 
 // GetVarOrSetFunc returns a gvar.Var with result from GetOrSetFunc.
@@ -199,7 +159,8 @@ func (tree *RedBlackTree) GetVarOrSet(key any, value any) *gvar.Var {
 //
 // Also see function GetOrSetFunc.
 func (tree *RedBlackTree) GetVarOrSetFunc(key any, f func() any) *gvar.Var {
-	return gvar.New(tree.GetOrSetFunc(key, f))
+	tree.lazyInit()
+	return tree.RedBlackKVTree.GetVarOrSetFunc(key, f)
 }
 
 // GetVarOrSetFuncLock returns a gvar.Var with result from GetOrSetFuncLock.
@@ -207,158 +168,123 @@ func (tree *RedBlackTree) GetVarOrSetFunc(key any, f func() any) *gvar.Var {
 //
 // Also see function GetOrSetFuncLock.
 func (tree *RedBlackTree) GetVarOrSetFuncLock(key any, f func() any) *gvar.Var {
-	return gvar.New(tree.GetOrSetFuncLock(key, f))
+	tree.lazyInit()
+	return tree.RedBlackKVTree.GetVarOrSetFuncLock(key, f)
 }
 
 // Search searches the tree with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (tree *RedBlackTree) Search(key any) (value any, found bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	if node, found := tree.doGet(key); found {
-		return node, true
-	}
-	return nil, false
+	tree.lazyInit()
+	return tree.RedBlackKVTree.Search(key)
 }
 
 // Contains checks and returns whether given `key` exists in the tree.
 func (tree *RedBlackTree) Contains(key any) bool {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	_, ok := tree.doGet(key)
-	return ok
+	tree.lazyInit()
+	return tree.RedBlackKVTree.Contains(key)
 }
 
 // Size returns number of nodes in the tree.
 func (tree *RedBlackTree) Size() int {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Size()
+	tree.lazyInit()
+	return tree.RedBlackKVTree.Size()
 }
 
 // IsEmpty returns true if tree does not contain any nodes.
 func (tree *RedBlackTree) IsEmpty() bool {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Size() == 0
+	tree.lazyInit()
+	return tree.RedBlackKVTree.IsEmpty()
 }
 
 // Remove removes the node from the tree by `key`, and returns its associated value of `key`.
 // The given `key` should adhere to the comparator's type assertion, otherwise method panics.
 func (tree *RedBlackTree) Remove(key any) (value any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	return tree.doRemove(key)
+	tree.lazyInit()
+	return tree.RedBlackKVTree.Remove(key)
 }
 
 // Removes batch deletes key-value pairs from the tree by `keys`.
 func (tree *RedBlackTree) Removes(keys []any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	for _, key := range keys {
-		tree.doRemove(key)
-	}
+	tree.lazyInit()
+	tree.RedBlackKVTree.Removes(keys)
 }
 
 // Clear removes all nodes from the tree.
 func (tree *RedBlackTree) Clear() {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	tree.tree.Clear()
+	tree.lazyInit()
+	tree.RedBlackKVTree.Clear()
 }
 
 // Keys returns all keys from the tree in order by its comparator.
 func (tree *RedBlackTree) Keys() []any {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Keys()
+	tree.lazyInit()
+	return tree.RedBlackKVTree.Keys()
 }
 
 // Values returns all values from the true in order by its comparator based on the key.
 func (tree *RedBlackTree) Values() []any {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.Values()
+	tree.lazyInit()
+	return tree.RedBlackKVTree.Values()
 }
 
 // Replace clears the data of the tree and sets the nodes by given `data`.
 func (tree *RedBlackTree) Replace(data map[any]any) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	tree.tree.Clear()
-	for k, v := range data {
-		tree.doSet(k, v)
-	}
+	tree.lazyInit()
+	tree.RedBlackKVTree.Replace(data)
 }
 
 // Print prints the tree to stdout.
 func (tree *RedBlackTree) Print() {
-	fmt.Println(tree.String())
+	tree.lazyInit()
+	tree.RedBlackKVTree.Print()
 }
 
 // String returns a string representation of container
 func (tree *RedBlackTree) String() string {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return gstr.Replace(tree.tree.String(), "RedBlackTree\n", "")
+	tree.lazyInit()
+	return tree.RedBlackKVTree.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (tree *RedBlackTree) MarshalJSON() (jsonBytes []byte, err error) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	return tree.tree.MarshalJSON()
+func (tree RedBlackTree) MarshalJSON() (jsonBytes []byte, err error) {
+	tree.lazyInit()
+	return tree.RedBlackKVTree.MarshalJSON()
 }
 
 // Map returns all key-value pairs as map.
 func (tree *RedBlackTree) Map() map[any]any {
-	m := make(map[any]any, tree.Size())
-	tree.IteratorAsc(func(key, value any) bool {
-		m[key] = value
-		return true
-	})
-	return m
+	tree.lazyInit()
+	return tree.RedBlackKVTree.Map()
 }
 
 // MapStrAny returns all key-value items as map[string]any.
 func (tree *RedBlackTree) MapStrAny() map[string]any {
-	m := make(map[string]any, tree.Size())
-	tree.IteratorAsc(func(key, value any) bool {
-		m[gconv.String(key)] = value
-		return true
-	})
-	return m
+	tree.lazyInit()
+	return tree.RedBlackKVTree.MapStrAny()
 }
 
 // Iterator is alias of IteratorAsc.
 //
 // Also see IteratorAsc.
 func (tree *RedBlackTree) Iterator(f func(key, value any) bool) {
-	tree.IteratorAsc(f)
+	tree.lazyInit()
+	tree.RedBlackKVTree.Iterator(f)
 }
 
 // IteratorFrom is alias of IteratorAscFrom.
 //
 // Also see IteratorAscFrom.
 func (tree *RedBlackTree) IteratorFrom(key any, match bool, f func(key, value any) bool) {
-	tree.IteratorAscFrom(key, match, f)
+	tree.lazyInit()
+	tree.RedBlackKVTree.IteratorFrom(key, match, f)
 }
 
 // IteratorAsc iterates the tree readonly in ascending order with given callback function `f`.
 // If callback function `f` returns true, then it continues iterating; or false to stop.
 func (tree *RedBlackTree) IteratorAsc(f func(key, value any) bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	var (
-		ok bool
-		it = tree.tree.Iterator()
-	)
-	for it.Begin(); it.Next(); {
-		index, value := it.Key(), it.Value()
-		if ok = f(index, value); !ok {
-			break
-		}
-	}
+	tree.lazyInit()
+	tree.RedBlackKVTree.IteratorAsc(f)
 }
 
 // IteratorAscFrom iterates the tree readonly in ascending order with given callback function `f`.
@@ -368,34 +294,16 @@ func (tree *RedBlackTree) IteratorAsc(f func(key, value any) bool) {
 // searching iterating.
 // If callback function `f` returns true, then it continues iterating; or false to stop.
 func (tree *RedBlackTree) IteratorAscFrom(key any, match bool, f func(key, value any) bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	var keys = tree.tree.Keys()
-	index, canIterator := iteratorFromGetIndex(key, keys, match)
-	if !canIterator {
-		return
-	}
-	for ; index < len(keys); index++ {
-		f(keys[index], tree.Get(keys[index]))
-	}
+	tree.lazyInit()
+	tree.RedBlackKVTree.IteratorAscFrom(key, match, f)
 }
 
 // IteratorDesc iterates the tree readonly in descending order with given callback function `f`.
 //
 // If callback function `f` returns true, then it continues iterating; or false to stop.
 func (tree *RedBlackTree) IteratorDesc(f func(key, value any) bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	var (
-		ok bool
-		it = tree.tree.Iterator()
-	)
-	for it.End(); it.Prev(); {
-		index, value := it.Key(), it.Value()
-		if ok = f(index, value); !ok {
-			break
-		}
-	}
+	tree.lazyInit()
+	tree.RedBlackKVTree.IteratorDesc(f)
 }
 
 // IteratorDescFrom iterates the tree readonly in descending order with given callback function `f`.
@@ -405,44 +313,20 @@ func (tree *RedBlackTree) IteratorDesc(f func(key, value any) bool) {
 // searching iterating.
 // If callback function `f` returns true, then it continues iterating; or false to stop.
 func (tree *RedBlackTree) IteratorDescFrom(key any, match bool, f func(key, value any) bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	var keys = tree.tree.Keys()
-	index, canIterator := iteratorFromGetIndex(key, keys, match)
-	if !canIterator {
-		return
-	}
-	for ; index >= 0; index-- {
-		f(keys[index], tree.Get(keys[index]))
-	}
+	tree.lazyInit()
+	tree.RedBlackKVTree.IteratorDescFrom(key, match, f)
 }
 
 // Left returns the minimum element corresponding to the comparator of the tree or nil if the tree is empty.
 func (tree *RedBlackTree) Left() *RedBlackTreeNode {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	node := tree.tree.Left()
-	if node == nil {
-		return nil
-	}
-	return &RedBlackTreeNode{
-		Key:   node.Key,
-		Value: node.Value,
-	}
+	tree.lazyInit()
+	return tree.RedBlackKVTree.Left()
 }
 
 // Right returns the maximum element corresponding to the comparator of the tree or nil if the tree is empty.
 func (tree *RedBlackTree) Right() *RedBlackTreeNode {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	node := tree.tree.Right()
-	if node == nil {
-		return nil
-	}
-	return &RedBlackTreeNode{
-		Key:   node.Key,
-		Value: node.Value,
-	}
+	tree.lazyInit()
+	return tree.RedBlackKVTree.Right()
 }
 
 // Floor Finds floor node of the input key, returns the floor node or nil if no floor node is found.
@@ -454,16 +338,8 @@ func (tree *RedBlackTree) Right() *RedBlackTreeNode {
 //
 // Key should adhere to the comparator's type assertion, otherwise method panics.
 func (tree *RedBlackTree) Floor(key any) (floor *RedBlackTreeNode, found bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	node, found := tree.tree.Floor(key)
-	if !found {
-		return nil, false
-	}
-	return &RedBlackTreeNode{
-		Key:   node.Key,
-		Value: node.Value,
-	}, true
+	tree.lazyInit()
+	return tree.RedBlackKVTree.Floor(key)
 }
 
 // Ceiling finds ceiling node of the input key, returns the ceiling node or nil if no ceiling node is found.
@@ -475,16 +351,8 @@ func (tree *RedBlackTree) Floor(key any) (floor *RedBlackTreeNode, found bool) {
 //
 // Key should adhere to the comparator's type assertion, otherwise method panics.
 func (tree *RedBlackTree) Ceiling(key any) (ceiling *RedBlackTreeNode, found bool) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-	node, found := tree.tree.Ceiling(key)
-	if !found {
-		return nil, false
-	}
-	return &RedBlackTreeNode{
-		Key:   node.Key,
-		Value: node.Value,
-	}, true
+	tree.lazyInit()
+	return tree.RedBlackKVTree.Ceiling(key)
 }
 
 // Flip exchanges key-value of the tree to value-key.
@@ -493,6 +361,7 @@ func (tree *RedBlackTree) Ceiling(key any) (ceiling *RedBlackTreeNode, found boo
 //
 // If the type of value is different with key, you pass the new `comparator`.
 func (tree *RedBlackTree) Flip(comparator ...func(v1, v2 any) int) {
+	tree.lazyInit()
 	var t = new(RedBlackTree)
 	if len(comparator) > 0 {
 		t = NewRedBlackTree(comparator[0], tree.mu.IsSafe())
@@ -509,61 +378,12 @@ func (tree *RedBlackTree) Flip(comparator ...func(v1, v2 any) int) {
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (tree *RedBlackTree) UnmarshalJSON(b []byte) error {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if tree.comparator == nil {
-		tree.comparator = gutil.ComparatorString
-		tree.tree = redblacktree.NewWith(tree.comparator)
-	}
-	var data map[string]any
-	if err := json.UnmarshalUseNumber(b, &data); err != nil {
-		return err
-	}
-	for k, v := range data {
-		tree.doSet(k, v)
-	}
-	return nil
+	tree.lazyInit()
+	return tree.RedBlackKVTree.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
 func (tree *RedBlackTree) UnmarshalValue(value any) (err error) {
-	tree.mu.Lock()
-	defer tree.mu.Unlock()
-	if tree.comparator == nil {
-		tree.comparator = gutil.ComparatorString
-		tree.tree = redblacktree.NewWith(tree.comparator)
-	}
-	for k, v := range gconv.Map(value) {
-		tree.doSet(k, v)
-	}
-	return
-}
-
-// doSet inserts key-value pair node into the tree without lock.
-// If `key` already exists, then its value is updated with the new value.
-// If `value` is type of <func() any>, it will be executed and its return value will be set to the map with `key`.
-//
-// It returns value with given `key`.
-func (tree *RedBlackTree) doSet(key, value any) any {
-	if f, ok := value.(func() any); ok {
-		value = f()
-	}
-	if value == nil {
-		return value
-	}
-	tree.tree.Put(key, value)
-	return value
-}
-
-// doGet retrieves and returns the value of given key from tree without lock.
-func (tree *RedBlackTree) doGet(key any) (value any, found bool) {
-	return tree.tree.Get(key)
-}
-
-// doRemove removes key from tree and returns its associated value without lock.
-// Note that, the given `key` should adhere to the comparator's type assertion, otherwise method panics.
-func (tree *RedBlackTree) doRemove(key any) (value any) {
-	value, _ = tree.tree.Get(key)
-	tree.tree.Remove(key)
-	return
+	tree.lazyInit()
+	return tree.RedBlackKVTree.UnmarshalValue(value)
 }
diff --git a/container/gtree/gtree_z_avl_tree_test.go b/container/gtree/gtree_z_avl_tree_test.go
index ffc711ebd..9233f32b1 100644
--- a/container/gtree/gtree_z_avl_tree_test.go
+++ b/container/gtree/gtree_z_avl_tree_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gtree_test
diff --git a/container/gtree/gtree_z_b_tree_test.go b/container/gtree/gtree_z_b_tree_test.go
index 9dee970e4..1cf4a26be 100644
--- a/container/gtree/gtree_z_b_tree_test.go
+++ b/container/gtree/gtree_z_b_tree_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gtree_test
diff --git a/container/gtree/gtree_z_example_avltree_test.go b/container/gtree/gtree_z_example_avltree_test.go
index 5dd24229e..bd9e12c97 100644
--- a/container/gtree/gtree_z_example_avltree_test.go
+++ b/container/gtree/gtree_z_example_avltree_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gtree_test
diff --git a/container/gtree/gtree_z_example_btree_test.go b/container/gtree/gtree_z_example_btree_test.go
index 661311b31..4e861766f 100644
--- a/container/gtree/gtree_z_example_btree_test.go
+++ b/container/gtree/gtree_z_example_btree_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/Agogf/gf.
 
 package gtree_test
diff --git a/container/gtree/gtree_z_example_redblacktree_test.go b/container/gtree/gtree_z_example_redblacktree_test.go
index 84d434776..9917745ee 100644
--- a/container/gtree/gtree_z_example_redblacktree_test.go
+++ b/container/gtree/gtree_z_example_redblacktree_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gtree_test
diff --git a/container/gtree/gtree_z_example_test.go b/container/gtree/gtree_z_example_test.go
index 410fbcf2a..0f733b446 100644
--- a/container/gtree/gtree_z_example_test.go
+++ b/container/gtree/gtree_z_example_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/Agogf/gf.
 
 package gtree_test
diff --git a/container/gtree/gtree_z_k_v_tree_test.go b/container/gtree/gtree_z_k_v_tree_test.go
new file mode 100644
index 000000000..92a229d2f
--- /dev/null
+++ b/container/gtree/gtree_z_k_v_tree_test.go
@@ -0,0 +1,215 @@
+// 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 gtree_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/container/gtree"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gutil"
+)
+
+func Test_KVAVLTree_TypedNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type Student struct {
+			Name string
+			Age  int
+		}
+		avlTree := gtree.NewAVLKVTree[int, *Student](gutil.ComparatorTStr[int], true)
+		for i := 0; i < 10; i++ {
+			if i%2 == 0 {
+				avlTree.Set(i, &Student{})
+			} else {
+				var s *Student = nil
+				avlTree.Set(i, s)
+			}
+		}
+		t.Assert(avlTree.Size(), 5)
+
+		avlTree2 := gtree.NewAVLKVTree[int, *Student](gutil.ComparatorTStr[int], true)
+		avlTree2.SetNilChecker(func(student *Student) bool {
+			return student == nil
+		})
+		for i := 0; i < 10; i++ {
+			if i%2 == 0 {
+				avlTree2.Set(i, &Student{})
+			} else {
+				var s *Student = nil
+				avlTree2.Set(i, s)
+			}
+		}
+		t.Assert(avlTree2.Size(), 5)
+
+	})
+}
+
+func Test_KVBTree_TypedNil(t *testing.T) {
+	type Student struct {
+		Name string
+		Age  int
+	}
+	gtest.C(t, func(t *gtest.T) {
+		btree := gtree.NewBKVTree[int, *Student](100, gutil.ComparatorTStr[int], true)
+		for i := 0; i < 10; i++ {
+			if i%2 == 0 {
+				btree.Set(i, &Student{})
+			} else {
+				var s *Student = nil
+				btree.Set(i, s)
+			}
+		}
+		t.Assert(btree.Size(), 5)
+
+		btree2 := gtree.NewBKVTree[int, *Student](100, gutil.ComparatorTStr[int], true)
+		btree2.SetNilChecker(func(student *Student) bool {
+			return student == nil
+		})
+		for i := 0; i < 10; i++ {
+			if i%2 == 0 {
+				btree2.Set(i, &Student{})
+			} else {
+				var s *Student = nil
+				btree2.Set(i, s)
+			}
+		}
+		t.Assert(btree2.Size(), 5)
+	})
+
+}
+
+func Test_KVRedBlackTree_TypedNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type Student struct {
+			Name string
+			Age  int
+		}
+		redBlackTree := gtree.NewRedBlackKVTree[int, *Student](gutil.ComparatorTStr[int], true)
+		for i := 0; i < 10; i++ {
+			if i%2 == 0 {
+				redBlackTree.Set(i, &Student{})
+			} else {
+				var s *Student = nil
+				redBlackTree.Set(i, s)
+			}
+		}
+		t.Assert(redBlackTree.Size(), 5)
+
+		redBlackTree2 := gtree.NewRedBlackKVTree[int, *Student](gutil.ComparatorTStr[int], true)
+		redBlackTree2.SetNilChecker(func(student *Student) bool {
+			return student == nil
+		})
+		for i := 0; i < 10; i++ {
+			if i%2 == 0 {
+				redBlackTree2.Set(i, &Student{})
+			} else {
+				var s *Student = nil
+				redBlackTree2.Set(i, s)
+			}
+		}
+		t.Assert(redBlackTree2.Size(), 5)
+	})
+}
+
+func Test_NewKVAVLTreeWithChecker_TypedNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type Student struct {
+			Name string
+			Age  int
+		}
+		avlTree := gtree.NewAVLKVTree[int, *Student](gutil.ComparatorTStr[int], true)
+		for i := 0; i < 10; i++ {
+			if i%2 == 0 {
+				avlTree.Set(i, &Student{})
+			} else {
+				var s *Student = nil
+				avlTree.Set(i, s)
+			}
+		}
+		t.Assert(avlTree.Size(), 5)
+
+		avlTree2 := gtree.NewAVLKVTreeWithChecker[int, *Student](gutil.ComparatorTStr[int], func(student *Student) bool {
+			return student == nil
+		}, true)
+		for i := 0; i < 10; i++ {
+			if i%2 == 0 {
+				avlTree2.Set(i, &Student{})
+			} else {
+				var s *Student = nil
+				avlTree2.Set(i, s)
+			}
+		}
+		t.Assert(avlTree2.Size(), 5)
+
+	})
+}
+
+func Test_NewKVBTreeWithChecker_TypedNil(t *testing.T) {
+	type Student struct {
+		Name string
+		Age  int
+	}
+	gtest.C(t, func(t *gtest.T) {
+		btree := gtree.NewBKVTree[int, *Student](100, gutil.ComparatorTStr[int], true)
+		for i := 0; i < 10; i++ {
+			if i%2 == 0 {
+				btree.Set(i, &Student{})
+			} else {
+				var s *Student = nil
+				btree.Set(i, s)
+			}
+		}
+		t.Assert(btree.Size(), 5)
+
+		btree2 := gtree.NewBKVTreeWithChecker[int, *Student](100, gutil.ComparatorTStr[int], func(student *Student) bool {
+			return student == nil
+		}, true)
+		for i := 0; i < 10; i++ {
+			if i%2 == 0 {
+				btree2.Set(i, &Student{})
+			} else {
+				var s *Student = nil
+				btree2.Set(i, s)
+			}
+		}
+		t.Assert(btree2.Size(), 5)
+	})
+
+}
+
+func Test_NewRedBlackKVTreeWithChecker_TypedNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type Student struct {
+			Name string
+			Age  int
+		}
+		redBlackTree := gtree.NewRedBlackKVTree[int, *Student](gutil.ComparatorTStr[int], true)
+		for i := 0; i < 10; i++ {
+			if i%2 == 0 {
+				redBlackTree.Set(i, &Student{})
+			} else {
+				var s *Student = nil
+				redBlackTree.Set(i, s)
+			}
+		}
+		t.Assert(redBlackTree.Size(), 5)
+
+		redBlackTree2 := gtree.NewRedBlackKVTreeWithChecker[int, *Student](gutil.ComparatorTStr[int], func(student *Student) bool {
+			return student == nil
+		}, true)
+
+		for i := 0; i < 10; i++ {
+			if i%2 == 0 {
+				redBlackTree2.Set(i, &Student{})
+			} else {
+				var s *Student = nil
+				redBlackTree2.Set(i, s)
+			}
+		}
+		t.Assert(redBlackTree2.Size(), 5)
+	})
+}
diff --git a/container/gtree/gtree_z_redblack_tree_test.go b/container/gtree/gtree_z_redblack_tree_test.go
index 2989b44c5..4708e035f 100644
--- a/container/gtree/gtree_z_redblack_tree_test.go
+++ b/container/gtree/gtree_z_redblack_tree_test.go
@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gtree_test
diff --git a/container/gvar/gvar_map.go b/container/gvar/gvar_map.go
index 3e4d538f6..0321275ed 100644
--- a/container/gvar/gvar_map.go
+++ b/container/gvar/gvar_map.go
@@ -40,18 +40,21 @@ func (v *Var) MapStrVar(option ...MapOption) map[string]*Var {
 }
 
 // MapDeep converts and returns `v` as map[string]any recursively.
+//
 // Deprecated: used Map instead.
 func (v *Var) MapDeep(tags ...string) map[string]any {
 	return gconv.MapDeep(v.Val(), tags...)
 }
 
 // MapStrStrDeep converts and returns `v` as map[string]string recursively.
+//
 // Deprecated: used MapStrStr instead.
 func (v *Var) MapStrStrDeep(tags ...string) map[string]string {
 	return gconv.MapStrStrDeep(v.Val(), tags...)
 }
 
 // MapStrVarDeep converts and returns `v` as map[string]*Var recursively.
+//
 // Deprecated: used MapStrVar instead.
 func (v *Var) MapStrVarDeep(tags ...string) map[string]*Var {
 	m := v.MapDeep(tags...)
@@ -72,6 +75,7 @@ func (v *Var) Maps(option ...MapOption) []map[string]any {
 }
 
 // MapsDeep converts `value` to []map[string]any recursively.
+//
 // Deprecated: used Maps instead.
 func (v *Var) MapsDeep(tags ...string) []map[string]any {
 	return gconv.MapsDeep(v.Val(), tags...)
diff --git a/container/gvar/gvar_slice.go b/container/gvar/gvar_slice.go
index 629249c4f..fc3e10457 100644
--- a/container/gvar/gvar_slice.go
+++ b/container/gvar/gvar_slice.go
@@ -8,6 +8,11 @@ package gvar
 
 import "github.com/gogf/gf/v2/util/gconv"
 
+// Bools converts and returns `v` as []bool.
+func (v *Var) Bools() []bool {
+	return gconv.Bools(v.Val())
+}
+
 // Ints converts and returns `v` as []int.
 func (v *Var) Ints() []int {
 	return gconv.Ints(v.Val())
diff --git a/container/gvar/gvar_vars.go b/container/gvar/gvar_vars.go
index af52f9c69..101e2f0b8 100644
--- a/container/gvar/gvar_vars.go
+++ b/container/gvar/gvar_vars.go
@@ -15,14 +15,25 @@ type Vars []*Var
 
 // Strings converts and returns `vs` as []string.
 func (vs Vars) Strings() (s []string) {
+	s = make([]string, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.String())
 	}
 	return s
 }
 
+// Bools converts and returns `vs` as []bool.
+func (vs Vars) Bools() (s []bool) {
+	s = make([]bool, 0, len(vs))
+	for _, v := range vs {
+		s = append(s, v.Bool())
+	}
+	return s
+}
+
 // Interfaces converts and returns `vs` as []any.
 func (vs Vars) Interfaces() (s []any) {
+	s = make([]any, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Val())
 	}
@@ -31,6 +42,7 @@ func (vs Vars) Interfaces() (s []any) {
 
 // Float32s converts and returns `vs` as []float32.
 func (vs Vars) Float32s() (s []float32) {
+	s = make([]float32, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Float32())
 	}
@@ -39,6 +51,7 @@ func (vs Vars) Float32s() (s []float32) {
 
 // Float64s converts and returns `vs` as []float64.
 func (vs Vars) Float64s() (s []float64) {
+	s = make([]float64, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Float64())
 	}
@@ -47,6 +60,7 @@ func (vs Vars) Float64s() (s []float64) {
 
 // Ints converts and returns `vs` as []Int.
 func (vs Vars) Ints() (s []int) {
+	s = make([]int, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Int())
 	}
@@ -55,6 +69,7 @@ func (vs Vars) Ints() (s []int) {
 
 // Int8s converts and returns `vs` as []int8.
 func (vs Vars) Int8s() (s []int8) {
+	s = make([]int8, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Int8())
 	}
@@ -63,6 +78,7 @@ func (vs Vars) Int8s() (s []int8) {
 
 // Int16s converts and returns `vs` as []int16.
 func (vs Vars) Int16s() (s []int16) {
+	s = make([]int16, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Int16())
 	}
@@ -71,6 +87,7 @@ func (vs Vars) Int16s() (s []int16) {
 
 // Int32s converts and returns `vs` as []int32.
 func (vs Vars) Int32s() (s []int32) {
+	s = make([]int32, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Int32())
 	}
@@ -79,6 +96,7 @@ func (vs Vars) Int32s() (s []int32) {
 
 // Int64s converts and returns `vs` as []int64.
 func (vs Vars) Int64s() (s []int64) {
+	s = make([]int64, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Int64())
 	}
@@ -87,6 +105,7 @@ func (vs Vars) Int64s() (s []int64) {
 
 // Uints converts and returns `vs` as []uint.
 func (vs Vars) Uints() (s []uint) {
+	s = make([]uint, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Uint())
 	}
@@ -95,6 +114,7 @@ func (vs Vars) Uints() (s []uint) {
 
 // Uint8s converts and returns `vs` as []uint8.
 func (vs Vars) Uint8s() (s []uint8) {
+	s = make([]uint8, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Uint8())
 	}
@@ -103,6 +123,7 @@ func (vs Vars) Uint8s() (s []uint8) {
 
 // Uint16s converts and returns `vs` as []uint16.
 func (vs Vars) Uint16s() (s []uint16) {
+	s = make([]uint16, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Uint16())
 	}
@@ -111,6 +132,7 @@ func (vs Vars) Uint16s() (s []uint16) {
 
 // Uint32s converts and returns `vs` as []uint32.
 func (vs Vars) Uint32s() (s []uint32) {
+	s = make([]uint32, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Uint32())
 	}
@@ -119,6 +141,7 @@ func (vs Vars) Uint32s() (s []uint32) {
 
 // Uint64s converts and returns `vs` as []uint64.
 func (vs Vars) Uint64s() (s []uint64) {
+	s = make([]uint64, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Uint64())
 	}
diff --git a/container/gvar/gvar_z_unit_slice_test.go b/container/gvar/gvar_z_unit_slice_test.go
index 46531f036..26c218e96 100644
--- a/container/gvar/gvar_z_unit_slice_test.go
+++ b/container/gvar/gvar_z_unit_slice_test.go
@@ -21,6 +21,24 @@ func TestVar_Ints(t *testing.T) {
 	})
 }
 
+func TestVar_Bools(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var arr = []bool{true, false, true, false}
+		objOne := gvar.New(arr, true)
+		t.AssertEQ(objOne.Bools(), arr)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		var arr = []int{1, 0, 1, 0}
+		objOne := gvar.New(arr, true)
+		t.AssertEQ(objOne.Bools(), []bool{true, false, true, false})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		var arr = []string{"true", "false", "1", "0"}
+		objOne := gvar.New(arr, true)
+		t.AssertEQ(objOne.Bools(), []bool{true, false, true, false})
+	})
+}
+
 func TestVar_Uints(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var arr = []int{1, 2, 3, 4, 5}
diff --git a/container/gvar/gvar_z_unit_vars_test.go b/container/gvar/gvar_z_unit_vars_test.go
index 4933f540c..7db2cb421 100644
--- a/container/gvar/gvar_z_unit_vars_test.go
+++ b/container/gvar/gvar_z_unit_vars_test.go
@@ -22,6 +22,7 @@ func TestVars(t *testing.T) {
 			gvar.New(3),
 		}
 		t.AssertEQ(vs.Strings(), []string{"1", "2", "3"})
+		t.AssertEQ(vs.Bools(), []bool{true, true, true})
 		t.AssertEQ(vs.Interfaces(), []any{1, 2, 3})
 		t.AssertEQ(vs.Float32s(), []float32{1, 2, 3})
 		t.AssertEQ(vs.Float64s(), []float64{1, 2, 3})
@@ -38,6 +39,46 @@ func TestVars(t *testing.T) {
 	})
 }
 
+func TestVars_Bools(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test with various boolean-like values
+		var vs = gvar.Vars{
+			gvar.New(true),
+			gvar.New(false),
+			gvar.New(1),
+			gvar.New(0),
+			gvar.New("true"),
+			gvar.New("false"),
+			gvar.New("1"),
+			gvar.New("0"),
+		}
+		expected := []bool{true, false, true, false, true, false, true, false}
+		t.AssertEQ(vs.Bools(), expected)
+	})
+}
+
+func TestVars_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test with empty Vars
+		var vs = gvar.Vars{}
+		t.AssertEQ(vs.Strings(), []string{})
+		t.AssertEQ(vs.Bools(), []bool{})
+		t.AssertEQ(vs.Interfaces(), []any{})
+		t.AssertEQ(vs.Ints(), []int{})
+		t.AssertEQ(vs.Float64s(), []float64{})
+	})
+}
+
+func TestVars_SingleElement(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test with single element
+		var vs = gvar.Vars{gvar.New(42)}
+		t.AssertEQ(vs.Strings(), []string{"42"})
+		t.AssertEQ(vs.Bools(), []bool{true})
+		t.AssertEQ(vs.Ints(), []int{42})
+	})
+}
+
 func TestVars_Scan(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		type User struct {
diff --git a/contrib/config/apollo/apollo.go b/contrib/config/apollo/apollo.go
index 9fb76f92c..0b20df937 100644
--- a/contrib/config/apollo/apollo.go
+++ b/contrib/config/apollo/apollo.go
@@ -19,9 +19,20 @@ import (
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gcfg"
 	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
+var (
+	// Compile-time checking for interface implementation.
+	_ gcfg.Adapter        = (*Client)(nil)
+	_ gcfg.WatcherAdapter = (*Client)(nil)
+)
+
+const (
+	apolloNamespaceDelimiter = ","
+)
+
 // Config is the configuration object for apollo client.
 type Config struct {
 	AppID             string `v:"required"` // See apolloConfig.Config.
@@ -38,9 +49,10 @@ type Config struct {
 
 // Client implements gcfg.Adapter implementing using apollo service.
 type Client struct {
-	config Config        // Config object when created.
-	client agollo.Client // Apollo client.
-	value  *g.Var        // Configmap content cached. It is `*gjson.Json` value internally.
+	config   Config                // Config object when created.
+	client   agollo.Client         // Apollo client.
+	value    *g.Var                // Configmap content cached. It is `*gjson.Json` value internally.
+	watchers *gcfg.WatcherRegistry // Watchers for watching file changes.
 }
 
 // New creates and returns gcfg.Adapter implementing using apollo service.
@@ -54,8 +66,9 @@ func New(ctx context.Context, config Config) (adapter gcfg.Adapter, err error) {
 		config.NamespaceName = storage.GetDefaultNamespace()
 	}
 	client := &Client{
-		config: config,
-		value:  g.NewVar(nil, true),
+		config:   config,
+		value:    g.NewVar(nil, true),
+		watchers: gcfg.NewWatcherRegistry(),
 	}
 	// Apollo client.
 	client.client, err = agollo.StartWithConfig(func() (*apolloConfig.AppConfig, error) {
@@ -89,11 +102,19 @@ func (c *Client) Available(ctx context.Context, resource ...string) (ok bool) {
 	if len(resource) == 0 && !c.value.IsNil() {
 		return true
 	}
-	var namespace = c.config.NamespaceName
+
+	namespaces := gstr.SplitAndTrim(c.config.NamespaceName, apolloNamespaceDelimiter)
 	if len(resource) > 0 {
-		namespace = resource[0]
+		namespaces = resource
 	}
-	return c.client.GetConfig(namespace) != nil
+
+	for _, namespace := range namespaces {
+		if c.client.GetConfig(namespace) == nil {
+			return false
+		}
+	}
+
+	return true
 }
 
 // Get retrieves and returns value by specified `pattern` in current resource.
@@ -132,18 +153,52 @@ func (c *Client) OnNewestChange(event *storage.FullChangeEvent) {
 }
 
 func (c *Client) updateLocalValue(ctx context.Context) (err error) {
-	var j = gjson.New(nil)
-	cache := c.client.GetConfigCache(c.config.NamespaceName)
-	cache.Range(func(key, value any) bool {
-		err = j.Set(gconv.String(key), value)
-		if err != nil {
-			return false
-		}
-		return true
-	})
-	cache.Clear()
+	j := gjson.New(nil)
+	content := gjson.New(nil, true)
+
+	for _, namespace := range gstr.SplitAndTrim(c.config.NamespaceName, apolloNamespaceDelimiter) {
+		cache := c.client.GetConfigCache(namespace)
+		cache.Range(func(key, value any) bool {
+			err = j.Set(gconv.String(key), value)
+			if err != nil {
+				return false
+			}
+			err = content.Set(gconv.String(key), value)
+			return err == nil
+		})
+		cache.Clear()
+	}
+
 	if err == nil {
 		c.value.Set(j)
+		adapterCtx := NewAdapterCtx(ctx).WithOperation(gcfg.OperationUpdate).WithNamespace(c.config.NamespaceName).
+			WithAppId(c.config.AppID).WithCluster(c.config.Cluster).WithContent(content)
+		c.notifyWatchers(adapterCtx.Ctx)
 	}
 	return
 }
+
+// AddWatcher adds a watcher for the specified configuration file.
+func (c *Client) AddWatcher(name string, f gcfg.WatcherFunc) {
+	c.watchers.Add(name, f)
+}
+
+// RemoveWatcher removes the watcher for the specified configuration file.
+func (c *Client) RemoveWatcher(name string) {
+	c.watchers.Remove(name)
+}
+
+// GetWatcherNames returns all watcher names.
+func (c *Client) GetWatcherNames() []string {
+	return c.watchers.GetNames()
+}
+
+// IsWatching checks whether the watcher with the specified name is registered.
+func (c *Client) IsWatching(name string) bool {
+	return c.watchers.IsWatching(name)
+}
+
+// notifyWatchers notifies all watchers.
+func (c *Client) notifyWatchers(ctx context.Context) {
+	c.watchers.Notify(ctx)
+}
diff --git a/contrib/config/apollo/apollo_adapter_ctx.go b/contrib/config/apollo/apollo_adapter_ctx.go
new file mode 100644
index 000000000..e2c0274bc
--- /dev/null
+++ b/contrib/config/apollo/apollo_adapter_ctx.go
@@ -0,0 +1,132 @@
+// 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 apollo implements gcfg.Adapter using apollo service.
+package apollo
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/os/gcfg"
+	"github.com/gogf/gf/v2/os/gctx"
+)
+
+const (
+	// ContextKeyNamespace is the context key for namespace
+	ContextKeyNamespace gctx.StrKey = "namespace"
+	// ContextKeyAppId is the context key for appId
+	ContextKeyAppId gctx.StrKey = "appId"
+	// ContextKeyCluster is the context key for cluster
+	ContextKeyCluster gctx.StrKey = "cluster"
+)
+
+// ApolloAdapterCtx is the context adapter for Apollo configuration
+type ApolloAdapterCtx struct {
+	Ctx context.Context
+}
+
+// NewAdapterCtxWithCtx creates and returns a new ApolloAdapterCtx with the given context.
+func NewAdapterCtxWithCtx(ctx context.Context) *ApolloAdapterCtx {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return &ApolloAdapterCtx{Ctx: ctx}
+}
+
+// NewAdapterCtx creates and returns a new ApolloAdapterCtx.
+// If context is provided, it will be used; otherwise, a background context is created.
+func NewAdapterCtx(ctx ...context.Context) *ApolloAdapterCtx {
+	if len(ctx) > 0 {
+		return NewAdapterCtxWithCtx(ctx[0])
+	}
+	return NewAdapterCtxWithCtx(context.Background())
+}
+
+// GetAdapterCtx creates a new ApolloAdapterCtx with the given context
+func GetAdapterCtx(ctx context.Context) *ApolloAdapterCtx {
+	return NewAdapterCtxWithCtx(ctx)
+}
+
+// WithOperation sets the operation in the context
+func (a *ApolloAdapterCtx) WithOperation(operation gcfg.OperationType) *ApolloAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, gcfg.ContextKeyOperation, operation)
+	return a
+}
+
+// WithNamespace sets the namespace in the context
+func (a *ApolloAdapterCtx) WithNamespace(namespace string) *ApolloAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyNamespace, namespace)
+	return a
+}
+
+// WithAppId sets the appId in the context
+func (a *ApolloAdapterCtx) WithAppId(appId string) *ApolloAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyAppId, appId)
+	return a
+}
+
+// WithCluster sets the cluster in the context
+func (a *ApolloAdapterCtx) WithCluster(cluster string) *ApolloAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyCluster, cluster)
+	return a
+}
+
+// WithContent sets the content in the context
+func (a *ApolloAdapterCtx) WithContent(content *gjson.Json) *ApolloAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, gcfg.ContextKeyContent, content)
+	return a
+}
+
+// GetNamespace retrieves the namespace from the context
+func (a *ApolloAdapterCtx) GetNamespace() string {
+	if v := a.Ctx.Value(ContextKeyNamespace); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetAppId retrieves the appId from the context
+func (a *ApolloAdapterCtx) GetAppId() string {
+	if v := a.Ctx.Value(ContextKeyAppId); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetCluster retrieves the cluster from the context
+func (a *ApolloAdapterCtx) GetCluster() string {
+	if v := a.Ctx.Value(ContextKeyCluster); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetContent retrieves the content from the context
+func (a *ApolloAdapterCtx) GetContent() *gjson.Json {
+	if v := a.Ctx.Value(gcfg.ContextKeyContent); v != nil {
+		if s, ok := v.(*gjson.Json); ok {
+			return s
+		}
+	}
+	return gjson.New(nil)
+}
+
+// GetOperation retrieves the operation from the context
+func (a *ApolloAdapterCtx) GetOperation() gcfg.OperationType {
+	if v := a.Ctx.Value(gcfg.ContextKeyOperation); v != nil {
+		if s, ok := v.(gcfg.OperationType); ok {
+			return s
+		}
+	}
+	return ""
+}
diff --git a/contrib/config/apollo/go.mod b/contrib/config/apollo/go.mod
index 7174beff7..4782834cf 100644
--- a/contrib/config/apollo/go.mod
+++ b/contrib/config/apollo/go.mod
@@ -4,13 +4,13 @@ go 1.23.0
 
 require (
 	github.com/apolloconfig/agollo/v4 v4.3.1
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -20,15 +20,15 @@ require (
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/mitchellh/mapstructure v1.4.1 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
 	github.com/pelletier/go-toml v1.9.3 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	github.com/spf13/afero v1.6.0 // indirect
 	github.com/spf13/cast v1.3.1 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
@@ -36,13 +36,13 @@ require (
 	github.com/spf13/viper v1.8.1 // indirect
 	github.com/subosito/gotenv v1.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/ini.v1 v1.62.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
diff --git a/contrib/config/apollo/go.sum b/contrib/config/apollo/go.sum
index a99e717c5..cec04686a 100644
--- a/contrib/config/apollo/go.sum
+++ b/contrib/config/apollo/go.sum
@@ -64,8 +64,8 @@ github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSV
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
@@ -204,9 +204,10 @@ github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPK
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -228,8 +229,8 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pelletier/go-toml v1.9.3 h1:zeC5b1GviRUyKYd6OJPvBU/mcVDVoL1OhT17FCt5dSQ=
 github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
@@ -239,13 +240,12 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
@@ -269,8 +269,8 @@ github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81P
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
 github.com/tevid/gohamcrest v1.1.1 h1:ou+xSqlIw1xfGTg1uq1nif/htZ2S3EzRqLm2BP+tYU0=
@@ -292,14 +292,16 @@ go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
 go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
@@ -383,8 +385,8 @@ golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -449,6 +451,7 @@ golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
@@ -460,8 +463,8 @@ golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
diff --git a/contrib/config/consul/consul.go b/contrib/config/consul/consul.go
index 1d63ce431..1fe1a54d2 100644
--- a/contrib/config/consul/consul.go
+++ b/contrib/config/consul/consul.go
@@ -21,6 +21,12 @@ import (
 	"github.com/gogf/gf/v2/os/glog"
 )
 
+var (
+	// Compile-time checking for interface implementation.
+	_ gcfg.Adapter        = (*Client)(nil)
+	_ gcfg.WatcherAdapter = (*Client)(nil)
+)
+
 // Config is the configuration object for consul client.
 type Config struct {
 	// api.Config in consul package
@@ -41,6 +47,8 @@ type Client struct {
 	client *api.Client
 	// Configmap content cached. It is `*gjson.Json` value internally.
 	value *g.Var
+	// Watchers for watching file changes.
+	watchers *gcfg.WatcherRegistry
 }
 
 // New creates and returns gcfg.Adapter implementing using consul service.
@@ -55,8 +63,9 @@ func New(ctx context.Context, config Config) (adapter gcfg.Adapter, err error) {
 	}
 
 	client := &Client{
-		config: config,
-		value:  g.NewVar(nil, true),
+		config:   config,
+		value:    g.NewVar(nil, true),
+		watchers: gcfg.NewWatcherRegistry(),
 	}
 
 	client.client, err = api.NewClient(&config.ConsulConfig)
@@ -156,13 +165,26 @@ func (c *Client) addWatcher() (err error) {
 		if v, ok = raw.(*api.KVPair); !ok {
 			return
 		}
-
-		if err = c.doUpdate(v.Value); err != nil {
+		err = c.doUpdate(v.Value)
+		if err != nil {
 			c.config.Logger.Errorf(
 				context.Background(),
 				"watch config from consul path %+v update failed: %s",
 				c.config.Path, err,
 			)
+		} else {
+			var m *gjson.Json
+			m, err = gjson.LoadContent(v.Value, true)
+			if err != nil {
+				c.config.Logger.Errorf(
+					context.Background(),
+					"watch config from consul path %+v parse failed: %s",
+					c.config.Path, err,
+				)
+			} else {
+				adapterCtx := NewAdapterCtx().WithOperation(gcfg.OperationUpdate).WithPath(c.config.Path).WithContent(m)
+				c.notifyWatchers(adapterCtx.Ctx)
+			}
 		}
 	}
 
@@ -173,6 +195,7 @@ func (c *Client) addWatcher() (err error) {
 	return nil
 }
 
+// startAsynchronousWatch starts the asynchronous watch.
 func (c *Client) startAsynchronousWatch(plan *watch.Plan) {
 	if err := plan.Run(c.config.ConsulConfig.Address); err != nil {
 		c.config.Logger.Errorf(
@@ -182,3 +205,28 @@ func (c *Client) startAsynchronousWatch(plan *watch.Plan) {
 		)
 	}
 }
+
+// AddWatcher adds a watcher for the specified configuration file.
+func (c *Client) AddWatcher(name string, f gcfg.WatcherFunc) {
+	c.watchers.Add(name, f)
+}
+
+// RemoveWatcher removes the watcher for the specified configuration file.
+func (c *Client) RemoveWatcher(name string) {
+	c.watchers.Remove(name)
+}
+
+// GetWatcherNames returns all watcher names.
+func (c *Client) GetWatcherNames() []string {
+	return c.watchers.GetNames()
+}
+
+// IsWatching checks whether the watcher with the specified name is registered.
+func (c *Client) IsWatching(name string) bool {
+	return c.watchers.IsWatching(name)
+}
+
+// notifyWatchers notifies all watchers.
+func (c *Client) notifyWatchers(ctx context.Context) {
+	c.watchers.Notify(ctx)
+}
diff --git a/contrib/config/consul/consul_adapter_ctx.go b/contrib/config/consul/consul_adapter_ctx.go
new file mode 100644
index 000000000..48554ad88
--- /dev/null
+++ b/contrib/config/consul/consul_adapter_ctx.go
@@ -0,0 +1,96 @@
+// 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 consul implements gcfg.Adapter using consul service.
+package consul
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/os/gcfg"
+	"github.com/gogf/gf/v2/os/gctx"
+)
+
+const (
+	// ContextKeyPath is the context key for path
+	ContextKeyPath gctx.StrKey = "path"
+)
+
+// ConsulAdapterCtx is the context adapter for Consul configuration
+type ConsulAdapterCtx struct {
+	Ctx context.Context
+}
+
+// NewAdapterCtxWithCtx creates and returns a new ConsulAdapterCtx with the given context.
+func NewAdapterCtxWithCtx(ctx context.Context) *ConsulAdapterCtx {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return &ConsulAdapterCtx{Ctx: ctx}
+}
+
+// NewAdapterCtx creates and returns a new ConsulAdapterCtx.
+// If context is provided, it will be used; otherwise, a background context is created.
+func NewAdapterCtx(ctx ...context.Context) *ConsulAdapterCtx {
+	if len(ctx) > 0 {
+		return NewAdapterCtxWithCtx(ctx[0])
+	}
+	return NewAdapterCtxWithCtx(context.Background())
+}
+
+// GetAdapterCtx creates a new ConsulAdapterCtx with the given context
+func GetAdapterCtx(ctx context.Context) *ConsulAdapterCtx {
+	return NewAdapterCtxWithCtx(ctx)
+}
+
+// WithOperation sets the operation in the context
+func (a *ConsulAdapterCtx) WithOperation(operation gcfg.OperationType) *ConsulAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, gcfg.ContextKeyOperation, operation)
+	return a
+}
+
+// WithPath sets the path in the context
+func (a *ConsulAdapterCtx) WithPath(path string) *ConsulAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyPath, path)
+	return a
+}
+
+// WithContent sets the content in the context
+func (a *ConsulAdapterCtx) WithContent(content *gjson.Json) *ConsulAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, gcfg.ContextKeyContent, content)
+	return a
+}
+
+// GetContent retrieves the content from the context
+func (a *ConsulAdapterCtx) GetContent() *gjson.Json {
+	if v := a.Ctx.Value(gcfg.ContextKeyContent); v != nil {
+		if s, ok := v.(*gjson.Json); ok {
+			return s
+		}
+	}
+	return gjson.New(nil)
+}
+
+// GetOperation retrieves the operation from the context
+func (a *ConsulAdapterCtx) GetOperation() gcfg.OperationType {
+	if v := a.Ctx.Value(gcfg.ContextKeyOperation); v != nil {
+		if s, ok := v.(gcfg.OperationType); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetPath retrieves the path from the context
+func (a *ConsulAdapterCtx) GetPath() string {
+	if v := a.Ctx.Value(ContextKeyPath); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
diff --git a/contrib/config/consul/go.mod b/contrib/config/consul/go.mod
index 930f0a272..7c7003c95 100644
--- a/contrib/config/consul/go.mod
+++ b/contrib/config/consul/go.mod
@@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/config/consul/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 	github.com/hashicorp/consul/api v1.24.0
 	github.com/hashicorp/go-cleanhttp v0.5.2
 )
@@ -12,7 +12,7 @@ require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/armon/go-metrics v0.4.1 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -23,27 +23,27 @@ require (
 	github.com/hashicorp/go-hclog v1.5.0 // indirect
 	github.com/hashicorp/go-immutable-radix v1.3.1 // indirect
 	github.com/hashicorp/go-rootcerts v1.0.2 // indirect
-	github.com/hashicorp/golang-lru v1.0.2 // indirect
+	github.com/hashicorp/golang-lru v0.5.4 // indirect
 	github.com/hashicorp/serf v0.10.1 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/exp v0.0.0-20230817173708-d852ddb80c63 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/exp v0.0.0-20230321023759-10a507213a29 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/config/consul/go.sum b/contrib/config/consul/go.sum
index da613101b..249c6265c 100644
--- a/contrib/config/consul/go.sum
+++ b/contrib/config/consul/go.sum
@@ -24,8 +24,8 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
 github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
@@ -97,8 +97,8 @@ github.com/hashicorp/go-uuid v1.0.3/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/b
 github.com/hashicorp/go-version v1.2.1 h1:zEfKbn2+PDgroKdiOzqiE8rsmLqU2uwi5PB5pBJ3TkI=
 github.com/hashicorp/go-version v1.2.1/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c=
-github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
+github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc=
+github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
 github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
 github.com/hashicorp/mdns v1.0.4/go.mod h1:mtBihi+LeNXGtG8L9dX59gAEa12BDtBQSp4v/YAJqrc=
 github.com/hashicorp/memberlist v0.5.0 h1:EtYPN8DpAURiapus508I4n9CzHs2W+8NZGbmmR/prTM=
@@ -124,13 +124,14 @@ github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVc
 github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -154,8 +155,8 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0MwY=
 github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
@@ -179,11 +180,10 @@ github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8b
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 h1:nn5Wsu0esKSJiIVhscUtVbo7ada43DJhG55ua/hjS5I=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
@@ -197,26 +197,28 @@ github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXf
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY=
-golang.org/x/exp v0.0.0-20230817173708-d852ddb80c63 h1:m64FZMko/V45gv0bNmrNYoDEq8U5YUhetc9cBWKS1TQ=
-golang.org/x/exp v0.0.0-20230817173708-d852ddb80c63/go.mod h1:0v4NqG35kSWCMzLaMeX+IQrlSnVE/bqGSyC2cz/9Le8=
+golang.org/x/exp v0.0.0-20230321023759-10a507213a29 h1:ooxPy7fPvB4kwsA2h+iBNHkAbp/4JxTSwCmvdjEYmug=
+golang.org/x/exp v0.0.0-20230321023759-10a507213a29/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@@ -224,8 +226,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -250,6 +252,7 @@ golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
@@ -258,8 +261,8 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 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.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/contrib/config/kubecm/go.mod b/contrib/config/kubecm/go.mod
index 5dd2b9cb0..243d4f33b 100644
--- 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.24.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 	k8s.io/api v0.33.4
 	k8s.io/apimachinery v0.33.4
 	k8s.io/client-go v0.33.4
@@ -14,7 +14,7 @@ require (
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/emicklei/go-restful/v3 v3.11.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/fxamacker/cbor/v2 v2.7.0 // indirect
@@ -33,7 +33,7 @@ require (
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
@@ -41,24 +41,24 @@ require (
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	go.yaml.in/yaml/v2 v2.4.2 // indirect
-	golang.org/x/net v0.43.0 // indirect
-	golang.org/x/oauth2 v0.30.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/oauth2 v0.27.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/term v0.34.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
-	golang.org/x/time v0.12.0 // indirect
-	google.golang.org/protobuf v1.36.8 // indirect
-	gopkg.in/evanphx/json-patch.v4 v4.13.0 // indirect
+	golang.org/x/term v0.32.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
+	golang.org/x/time v0.9.0 // indirect
+	google.golang.org/protobuf v1.36.5 // indirect
+	gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	k8s.io/klog/v2 v2.130.1 // indirect
@@ -67,7 +67,7 @@ require (
 	sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 // indirect
 	sigs.k8s.io/randfill v1.0.0 // indirect
 	sigs.k8s.io/structured-merge-diff/v4 v4.6.0 // indirect
-	sigs.k8s.io/yaml v1.6.0 // indirect
+	sigs.k8s.io/yaml v1.4.0 // indirect
 )
 
 replace github.com/gogf/gf/v2 => ../../../
diff --git a/contrib/config/kubecm/go.sum b/contrib/config/kubecm/go.sum
index a535d09d7..51d81f574 100644
--- a/contrib/config/kubecm/go.sum
+++ b/contrib/config/kubecm/go.sum
@@ -8,8 +8,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/emicklei/go-restful/v3 v3.11.0 h1:rAQeMHw1c7zTmncogyy8VvRZwtkmkZ4FxERmMY4rD+g=
 github.com/emicklei/go-restful/v3 v3.11.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -64,8 +64,9 @@ github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8S
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
 github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -81,19 +82,20 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/onsi/ginkgo/v2 v2.21.0 h1:7rg/4f3rB88pb5obDgNZrNHrQ4e6WpjonchcpuBRnZM=
 github.com/onsi/ginkgo/v2 v2.21.0/go.mod h1:7Du3c42kxCUegi0IImZ1wUQzMBVecgIHjR1C+NkhLQo=
 github.com/onsi/gomega v1.35.1 h1:Cwbd75ZBPxFSuZ6T+rN/WCb/gOc6YgFBXLlZLhC7Ds4=
 github.com/onsi/gomega v1.35.1/go.mod h1:PvZbdDc8J6XJEpDK4HCuRBm8a6Fzp9/DmhC9C7yFlog=
+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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
@@ -105,28 +107,26 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
 github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI=
-go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU=
-go.yaml.in/yaml/v3 v3.0.3 h1:bXOww4E/J3f66rav3pX3m8w6jDE4knZjGOw8b5Y6iNE=
-go.yaml.in/yaml/v3 v3.0.3/go.mod h1:tBHosrYAkRZjRAOREWbDnBXUf08JOwYq++0QNwQiWzI=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
@@ -136,44 +136,45 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
-golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=
-golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/oauth2 v0.27.0 h1:da9Vo7/tDv5RH/7nZDz1eMGS/q1Vv1N/7FCrBhI9I3M=
+golang.org/x/oauth2 v0.27.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4=
-golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
 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.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
-golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
-golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/time v0.9.0 h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY=
+golang.org/x/time v0.9.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.35.0 h1:mBffYraMEf7aa0sB+NuKnuCy8qI/9Bughn8dC2Gu5r0=
-golang.org/x/tools v0.35.0/go.mod h1:NKdj5HkL/73byiZSJjqJgKn3ep7KjFkBOkR/Hps3VPw=
+golang.org/x/tools v0.26.0 h1:v/60pFQmzmT9ExmjDv2gGIfi3OqfKoEP6I5+umXlbnQ=
+golang.org/x/tools v0.26.0/go.mod h1:TPVVj70c7JJ3WCazhD8OdXcZg/og+b9+tH/KxylGwH0=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
-google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
+google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=
+google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/evanphx/json-patch.v4 v4.13.0 h1:czT3CmqEaQ1aanPc5SdlgQrrEIb8w/wwCvWWnfEbYzo=
-gopkg.in/evanphx/json-patch.v4 v4.13.0/go.mod h1:p8EYWUEYMpynmqDbY58zCKCFZw8pRWMG4EsWvDvM72M=
+gopkg.in/evanphx/json-patch.v4 v4.12.0 h1:n6jtcsulIzXPJaxegRbvFNNrZDjbij7ny3gmSPG+6V4=
+gopkg.in/evanphx/json-patch.v4 v4.12.0/go.mod h1:p8EYWUEYMpynmqDbY58zCKCFZw8pRWMG4EsWvDvM72M=
 gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc=
 gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -198,6 +199,5 @@ sigs.k8s.io/randfill v1.0.0 h1:JfjMILfT8A6RbawdsK2JXGBR5AQVfd+9TbzrlneTyrU=
 sigs.k8s.io/randfill v1.0.0/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY=
 sigs.k8s.io/structured-merge-diff/v4 v4.6.0 h1:IUA9nvMmnKWcj5jl84xn+T5MnlZKThmUW1TdblaLVAc=
 sigs.k8s.io/structured-merge-diff/v4 v4.6.0/go.mod h1:dDy58f92j70zLsuZVuUX5Wp9vtxXpaZnkPGWeqDfCps=
+sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E=
 sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY=
-sigs.k8s.io/yaml v1.6.0 h1:G8fkbMSAFqgEFgh4b1wmtzDnioxFCUgTZhlbj5P9QYs=
-sigs.k8s.io/yaml v1.6.0/go.mod h1:796bPqUfzR/0jLAl6XjHl3Ck7MiyVv8dbTdyT3/pMf4=
diff --git a/contrib/config/kubecm/kubecm.go b/contrib/config/kubecm/kubecm.go
index d15481710..86c7a3b42 100644
--- a/contrib/config/kubecm/kubecm.go
+++ b/contrib/config/kubecm/kubecm.go
@@ -23,11 +23,18 @@ import (
 	"github.com/gogf/gf/v2/util/gutil"
 )
 
+var (
+	// Compile-time checking for interface implementation.
+	_ gcfg.Adapter        = (*Client)(nil)
+	_ gcfg.WatcherAdapter = (*Client)(nil)
+)
+
 // Client implements gcfg.Adapter.
 type Client struct {
-	config Config                // Config object when created.
-	client *kubernetes.Clientset // Kubernetes client.
-	value  *g.Var                // Configmap content cached. It is `*gjson.Json` value internally.
+	config   Config                // Config object when created.
+	client   *kubernetes.Clientset // Kubernetes client.
+	value    *g.Var                // Configmap content cached. It is `*gjson.Json` value internally.
+	watchers *gcfg.WatcherRegistry // Watchers for watching file changes.
 }
 
 // Config for Client.
@@ -61,9 +68,10 @@ func New(ctx context.Context, config Config) (adapter gcfg.Adapter, err error) {
 		}
 	}
 	adapter = &Client{
-		config: config,
-		client: config.KubeClient,
-		value:  g.NewVar(nil, true),
+		config:   config,
+		client:   config.KubeClient,
+		value:    g.NewVar(nil, true),
+		watchers: gcfg.NewWatcherRegistry(),
 	}
 	return
 }
@@ -128,6 +136,7 @@ func (c *Client) updateLocalValueAndWatch(ctx context.Context) (err error) {
 	return nil
 }
 
+// doUpdate retrieves and caches the configmap content.
 func (c *Client) doUpdate(ctx context.Context, namespace string) (err error) {
 	cm, err := c.client.CoreV1().ConfigMaps(namespace).Get(ctx, c.config.ConfigMap, kubeMetaV1.GetOptions{})
 	if err != nil {
@@ -145,9 +154,19 @@ func (c *Client) doUpdate(ctx context.Context, namespace string) (err error) {
 		)
 	}
 	c.value.Set(j)
+	var content *gjson.Json
+	if content, err = gjson.LoadContent([]byte(cm.Data[c.config.DataItem])); err != nil {
+		return gerror.Wrapf(
+			err,
+			`parse config map item from %s[%s] failed`, c.config.ConfigMap, c.config.DataItem,
+		)
+	}
+	adapterCtx := NewAdapterCtx(ctx).WithOperation(gcfg.OperationUpdate).WithNamespace(namespace).WithConfigMap(c.config.ConfigMap).WithDataItem(c.config.DataItem).WithContent(content)
+	c.notifyWatchers(adapterCtx.Ctx)
 	return nil
 }
 
+// doWatch watches the configmap content.
 func (c *Client) doWatch(ctx context.Context, namespace string) (err error) {
 	if !c.config.Watch {
 		return nil
@@ -168,6 +187,7 @@ func (c *Client) doWatch(ctx context.Context, namespace string) (err error) {
 	return nil
 }
 
+// startAsynchronousWatch starts an asynchronous watch for the specified configuration file.
 func (c *Client) startAsynchronousWatch(ctx context.Context, namespace string, watchHandler watch.Interface) {
 	for {
 		event := <-watchHandler.ResultChan()
@@ -177,3 +197,28 @@ func (c *Client) startAsynchronousWatch(ctx context.Context, namespace string, w
 		}
 	}
 }
+
+// AddWatcher adds a watcher for the specified configuration file.
+func (c *Client) AddWatcher(name string, f gcfg.WatcherFunc) {
+	c.watchers.Add(name, f)
+}
+
+// RemoveWatcher removes the watcher for the specified configuration file.
+func (c *Client) RemoveWatcher(name string) {
+	c.watchers.Remove(name)
+}
+
+// GetWatcherNames returns all watcher names.
+func (c *Client) GetWatcherNames() []string {
+	return c.watchers.GetNames()
+}
+
+// IsWatching checks whether the watcher with the specified name is registered.
+func (c *Client) IsWatching(name string) bool {
+	return c.watchers.IsWatching(name)
+}
+
+// notifyWatchers notifies all watchers.
+func (c *Client) notifyWatchers(ctx context.Context) {
+	c.watchers.Notify(ctx)
+}
diff --git a/contrib/config/kubecm/kubecm_adapter_ctx.go b/contrib/config/kubecm/kubecm_adapter_ctx.go
new file mode 100644
index 000000000..c4be351df
--- /dev/null
+++ b/contrib/config/kubecm/kubecm_adapter_ctx.go
@@ -0,0 +1,132 @@
+// 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 kubecm implements gcfg.Adapter using kubecm service.
+package kubecm
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/os/gcfg"
+	"github.com/gogf/gf/v2/os/gctx"
+)
+
+const (
+	// ContextKeyNamespace is the context key for namespace
+	ContextKeyNamespace gctx.StrKey = "namespace"
+	// ContextKeyConfigMap is the context key for configmap
+	ContextKeyConfigMap gctx.StrKey = "configMap"
+	// ContextKeyDataItem is the context key for dataitem
+	ContextKeyDataItem gctx.StrKey = "dataItem"
+)
+
+// KubecmAdapterCtx is the context adapter for kubecm configuration
+type KubecmAdapterCtx struct {
+	Ctx context.Context
+}
+
+// NewKubecmAdapterCtx creates and returns a new KubecmAdapterCtx with the given context.
+func NewKubecmAdapterCtx(ctx context.Context) *KubecmAdapterCtx {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return &KubecmAdapterCtx{Ctx: ctx}
+}
+
+// NewAdapterCtx creates and returns a new KubecmAdapterCtx.
+// If context is provided, it will be used; otherwise, a background context is created.
+func NewAdapterCtx(ctx ...context.Context) *KubecmAdapterCtx {
+	if len(ctx) > 0 {
+		return NewKubecmAdapterCtx(ctx[0])
+	}
+	return NewKubecmAdapterCtx(context.Background())
+}
+
+// GetAdapterCtx creates a new KubecmAdapterCtx with the given context
+func GetAdapterCtx(ctx context.Context) *KubecmAdapterCtx {
+	return NewKubecmAdapterCtx(ctx)
+}
+
+// WithOperation sets the operation in the context
+func (a *KubecmAdapterCtx) WithOperation(operation gcfg.OperationType) *KubecmAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, gcfg.ContextKeyOperation, operation)
+	return a
+}
+
+// WithNamespace sets the namespace in the context
+func (a *KubecmAdapterCtx) WithNamespace(namespace string) *KubecmAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyNamespace, namespace)
+	return a
+}
+
+// WithConfigMap sets the configmap in the context
+func (a *KubecmAdapterCtx) WithConfigMap(configMap string) *KubecmAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyConfigMap, configMap)
+	return a
+}
+
+// WithDataItem sets the dataitem in the context
+func (a *KubecmAdapterCtx) WithDataItem(dataItem string) *KubecmAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyDataItem, dataItem)
+	return a
+}
+
+// WithContent sets the content in the context
+func (a *KubecmAdapterCtx) WithContent(content *gjson.Json) *KubecmAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, gcfg.ContextKeyContent, content)
+	return a
+}
+
+// GetOperation retrieves the operation from the context
+func (a *KubecmAdapterCtx) GetOperation() gcfg.OperationType {
+	if v := a.Ctx.Value(gcfg.ContextKeyOperation); v != nil {
+		if s, ok := v.(gcfg.OperationType); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetNamespace retrieves the namespace from the context
+func (a *KubecmAdapterCtx) GetNamespace() string {
+	if v := a.Ctx.Value(ContextKeyNamespace); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetConfigMap retrieves the configmap from the context
+func (a *KubecmAdapterCtx) GetConfigMap() string {
+	if v := a.Ctx.Value(ContextKeyConfigMap); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetDataItem retrieves the dataitem from the context
+func (a *KubecmAdapterCtx) GetDataItem() string {
+	if v := a.Ctx.Value(ContextKeyDataItem); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetContent retrieves the content from the context
+func (a *KubecmAdapterCtx) GetContent() *gjson.Json {
+	if v := a.Ctx.Value(gcfg.ContextKeyContent); v != nil {
+		if s, ok := v.(*gjson.Json); ok {
+			return s
+		}
+	}
+	return gjson.New(nil)
+}
diff --git a/contrib/config/nacos/go.mod b/contrib/config/nacos/go.mod
index 47b10a91f..851f2a78e 100644
--- a/contrib/config/nacos/go.mod
+++ b/contrib/config/nacos/go.mod
@@ -3,23 +3,39 @@ module github.com/gogf/gf/contrib/config/nacos/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
-	github.com/nacos-group/nacos-sdk-go/v2 v2.2.5
+	github.com/gogf/gf/v2 v2.9.8
+	github.com/nacos-group/nacos-sdk-go/v2 v2.3.3
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
-	github.com/alibabacloud-go/debug v0.0.0-20190504072949-9472017b5c68 // indirect
-	github.com/alibabacloud-go/tea v1.1.17 // indirect
+	github.com/alibabacloud-go/alibabacloud-gateway-pop v0.0.6 // indirect
+	github.com/alibabacloud-go/alibabacloud-gateway-spi v0.0.5 // indirect
+	github.com/alibabacloud-go/darabonba-array v0.1.0 // indirect
+	github.com/alibabacloud-go/darabonba-encode-util v0.0.2 // indirect
+	github.com/alibabacloud-go/darabonba-map v0.0.2 // indirect
+	github.com/alibabacloud-go/darabonba-openapi/v2 v2.0.10 // indirect
+	github.com/alibabacloud-go/darabonba-signature-util v0.0.7 // indirect
+	github.com/alibabacloud-go/darabonba-string v1.0.2 // indirect
+	github.com/alibabacloud-go/debug v1.0.1 // indirect
+	github.com/alibabacloud-go/endpoint-util v1.1.0 // indirect
+	github.com/alibabacloud-go/kms-20160120/v3 v3.2.3 // indirect
+	github.com/alibabacloud-go/openapi-util v0.1.0 // indirect
+	github.com/alibabacloud-go/tea v1.2.2 // indirect
 	github.com/alibabacloud-go/tea-utils v1.4.4 // indirect
-	github.com/aliyun/alibaba-cloud-sdk-go v1.62.589 // indirect
-	github.com/aliyun/alibabacloud-dkms-gcs-go-sdk v0.2.2 // indirect
-	github.com/aliyun/alibabacloud-dkms-transfer-go-sdk v0.1.7 // indirect
+	github.com/alibabacloud-go/tea-utils/v2 v2.0.7 // indirect
+	github.com/alibabacloud-go/tea-xml v1.1.3 // indirect
+	github.com/aliyun/alibaba-cloud-sdk-go v1.61.1800 // indirect
+	github.com/aliyun/alibabacloud-dkms-gcs-go-sdk v0.5.1 // indirect
+	github.com/aliyun/alibabacloud-dkms-transfer-go-sdk v0.1.8 // indirect
+	github.com/aliyun/aliyun-secretsmanager-client-go v1.1.5 // indirect
+	github.com/aliyun/credentials-go v1.4.3 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/buger/jsonparser v1.1.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/deckarep/golang-set v1.7.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -32,41 +48,42 @@ require (
 	github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/opentracing/opentracing-go v1.2.1-0.20220228012449-10b1cf09e00b // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/orcaman/concurrent-map v0.0.0-20210501183033-44dafcb38ecc // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/prometheus/client_golang v1.19.1 // indirect
-	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.55.0 // indirect
-	github.com/prometheus/procfs v0.15.1 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/prometheus/client_golang v1.12.2 // indirect
+	github.com/prometheus/client_model v0.2.0 // indirect
+	github.com/prometheus/common v0.32.1 // indirect
+	github.com/prometheus/procfs v0.7.3 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
+	github.com/tjfoc/gmsm v1.4.1 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	go.uber.org/atomic v1.10.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	go.uber.org/atomic v1.7.0 // indirect
 	go.uber.org/multierr v1.6.0 // indirect
 	go.uber.org/zap v1.21.0 // indirect
-	golang.org/x/crypto v0.41.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
-	golang.org/x/sync v0.16.0 // indirect
+	golang.org/x/crypto v0.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/sync v0.14.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	golang.org/x/time v0.1.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d // indirect
-	google.golang.org/grpc v1.59.0 // indirect
-	google.golang.org/protobuf v1.34.2 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 // indirect
+	google.golang.org/grpc v1.67.3 // indirect
+	google.golang.org/protobuf v1.36.5 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
-	gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect
+	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/config/nacos/go.sum b/contrib/config/nacos/go.sum
index 300ab855f..3d3d332ab 100644
--- a/contrib/config/nacos/go.sum
+++ b/contrib/config/nacos/go.sum
@@ -1,76 +1,245 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
+cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
+cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
+cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
+cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
+cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
+cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
+cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
+cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
+cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
+cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
+cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
+cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
+cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
+cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
 github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/HdrHistogram/hdrhistogram-go v1.1.2/go.mod h1:yDgFjdqOqDEKOvasDdhWNXYg9BVp4O+o5f6V/ehm6Oo=
-github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw=
-github.com/alibabacloud-go/debug v0.0.0-20190504072949-9472017b5c68 h1:NqugFkGxx1TXSh/pBcU00Y6bljgDPaFdh5MUSeJ7e50=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
+github.com/alibabacloud-go/alibabacloud-gateway-pop v0.0.6 h1:eIf+iGJxdU4U9ypaUfbtOWCsZSbTb8AUHvyPrxu6mAA=
+github.com/alibabacloud-go/alibabacloud-gateway-pop v0.0.6/go.mod h1:4EUIoxs/do24zMOGGqYVWgw0s9NtiylnJglOeEB5UJo=
+github.com/alibabacloud-go/alibabacloud-gateway-spi v0.0.4/go.mod h1:sCavSAvdzOjul4cEqeVtvlSaSScfNsTQ+46HwlTL1hc=
+github.com/alibabacloud-go/alibabacloud-gateway-spi v0.0.5 h1:zE8vH9C7JiZLNJJQ5OwjU9mSi4T9ef9u3BURT6LCLC8=
+github.com/alibabacloud-go/alibabacloud-gateway-spi v0.0.5/go.mod h1:tWnyE9AjF8J8qqLk645oUmVUnFybApTQWklQmi5tY6g=
+github.com/alibabacloud-go/darabonba-array v0.1.0 h1:vR8s7b1fWAQIjEjWnuF0JiKsCvclSRTfDzZHTYqfufY=
+github.com/alibabacloud-go/darabonba-array v0.1.0/go.mod h1:BLKxr0brnggqOJPqT09DFJ8g3fsDshapUD3C3aOEFaI=
+github.com/alibabacloud-go/darabonba-encode-util v0.0.2 h1:1uJGrbsGEVqWcWxrS9MyC2NG0Ax+GpOM5gtupki31XE=
+github.com/alibabacloud-go/darabonba-encode-util v0.0.2/go.mod h1:JiW9higWHYXm7F4PKuMgEUETNZasrDM6vqVr/Can7H8=
+github.com/alibabacloud-go/darabonba-map v0.0.2 h1:qvPnGB4+dJbJIxOOfawxzF3hzMnIpjmafa0qOTp6udc=
+github.com/alibabacloud-go/darabonba-map v0.0.2/go.mod h1:28AJaX8FOE/ym8OUFWga+MtEzBunJwQGceGQlvaPGPc=
+github.com/alibabacloud-go/darabonba-openapi/v2 v2.0.9/go.mod h1:bb+Io8Sn2RuM3/Rpme6ll86jMyFSrD1bxeV/+v61KeU=
+github.com/alibabacloud-go/darabonba-openapi/v2 v2.0.10 h1:GEYkMApgpKEVDn6z12DcH1EGYpDYRB8JxsazM4Rywak=
+github.com/alibabacloud-go/darabonba-openapi/v2 v2.0.10/go.mod h1:26a14FGhZVELuz2cc2AolvW4RHmIO3/HRwsdHhaIPDE=
+github.com/alibabacloud-go/darabonba-signature-util v0.0.7 h1:UzCnKvsjPFzApvODDNEYqBHMFt1w98wC7FOo0InLyxg=
+github.com/alibabacloud-go/darabonba-signature-util v0.0.7/go.mod h1:oUzCYV2fcCH797xKdL6BDH8ADIHlzrtKVjeRtunBNTQ=
+github.com/alibabacloud-go/darabonba-string v1.0.2 h1:E714wms5ibdzCqGeYJ9JCFywE5nDyvIXIIQbZVFkkqo=
+github.com/alibabacloud-go/darabonba-string v1.0.2/go.mod h1:93cTfV3vuPhhEwGGpKKqhVW4jLe7tDpo3LUM0i0g6mA=
 github.com/alibabacloud-go/debug v0.0.0-20190504072949-9472017b5c68/go.mod h1:6pb/Qy8c+lqua8cFpEy7g39NRRqOWc3rOwAy8m5Y2BY=
+github.com/alibabacloud-go/debug v1.0.0/go.mod h1:8gfgZCCAC3+SCzjWtY053FrOcd4/qlH6IHTI4QyICOc=
+github.com/alibabacloud-go/debug v1.0.1 h1:MsW9SmUtbb1Fnt3ieC6NNZi6aEwrXfDksD4QA6GSbPg=
+github.com/alibabacloud-go/debug v1.0.1/go.mod h1:8gfgZCCAC3+SCzjWtY053FrOcd4/qlH6IHTI4QyICOc=
+github.com/alibabacloud-go/endpoint-util v1.1.0 h1:r/4D3VSw888XGaeNpP994zDUaxdgTSHBbVfZlzf6b5Q=
+github.com/alibabacloud-go/endpoint-util v1.1.0/go.mod h1:O5FuCALmCKs2Ff7JFJMudHs0I5EBgecXXxZRyswlEjE=
+github.com/alibabacloud-go/kms-20160120/v3 v3.2.3 h1:vamGcYQFwXVqR6RWcrVTTqlIXZVsYjaA7pZbx+Xw6zw=
+github.com/alibabacloud-go/kms-20160120/v3 v3.2.3/go.mod h1:3rIyughsFDLie1ut9gQJXkWkMg/NfXBCk+OtXnPu3lw=
+github.com/alibabacloud-go/openapi-util v0.1.0 h1:0z75cIULkDrdEhkLWgi9tnLe+KhAFE/r5Pb3312/eAY=
+github.com/alibabacloud-go/openapi-util v0.1.0/go.mod h1:sQuElr4ywwFRlCCberQwKRFhRzIyG4QTP/P4y1CJ6Ws=
 github.com/alibabacloud-go/tea v1.1.0/go.mod h1:IkGyUSX4Ba1V+k4pCtJUc6jDpZLFph9QMy2VUPTwukg=
-github.com/alibabacloud-go/tea v1.1.17 h1:05R5DnaJXe9sCNIe8KUgWHC/z6w/VZIwczgUwzRnul8=
+github.com/alibabacloud-go/tea v1.1.7/go.mod h1:/tmnEaQMyb4Ky1/5D+SE1BAsa5zj/KeGOFfwYm3N/p4=
+github.com/alibabacloud-go/tea v1.1.8/go.mod h1:/tmnEaQMyb4Ky1/5D+SE1BAsa5zj/KeGOFfwYm3N/p4=
+github.com/alibabacloud-go/tea v1.1.11/go.mod h1:/tmnEaQMyb4Ky1/5D+SE1BAsa5zj/KeGOFfwYm3N/p4=
 github.com/alibabacloud-go/tea v1.1.17/go.mod h1:nXxjm6CIFkBhwW4FQkNrolwbfon8Svy6cujmKFUq98A=
+github.com/alibabacloud-go/tea v1.1.20/go.mod h1:nXxjm6CIFkBhwW4FQkNrolwbfon8Svy6cujmKFUq98A=
+github.com/alibabacloud-go/tea v1.2.1/go.mod h1:qbzof29bM/IFhLMtJPrgTGK3eauV5J2wSyEUo4OEmnA=
+github.com/alibabacloud-go/tea v1.2.2 h1:aTsR6Rl3ANWPfqeQugPglfurloyBJY85eFy7Gc1+8oU=
+github.com/alibabacloud-go/tea v1.2.2/go.mod h1:CF3vOzEMAG+bR4WOql8gc2G9H3EkH3ZLAQdpmpXMgwk=
+github.com/alibabacloud-go/tea-utils v1.3.1/go.mod h1:EI/o33aBfj3hETm4RLiAxF/ThQdSngxrpF8rKUDJjPE=
 github.com/alibabacloud-go/tea-utils v1.4.4 h1:lxCDvNCdTo9FaXKKq45+4vGETQUKNOW/qKTcX9Sk53o=
 github.com/alibabacloud-go/tea-utils v1.4.4/go.mod h1:KNcT0oXlZZxOXINnZBs6YvgOd5aYp9U67G+E3R8fcQw=
+github.com/alibabacloud-go/tea-utils/v2 v2.0.3/go.mod h1:sj1PbjPodAVTqGTA3olprfeeqqmwD0A5OQz94o9EuXQ=
+github.com/alibabacloud-go/tea-utils/v2 v2.0.5/go.mod h1:dL6vbUT35E4F4bFTHL845eUloqaerYBYPsdWR2/jhe4=
+github.com/alibabacloud-go/tea-utils/v2 v2.0.6/go.mod h1:qxn986l+q33J5VkialKMqT/TTs3E+U9MJpd001iWQ9I=
+github.com/alibabacloud-go/tea-utils/v2 v2.0.7 h1:WDx5qW3Xa5ZgJ1c8NfqJkF6w+AU5wB8835UdhPr6Ax0=
+github.com/alibabacloud-go/tea-utils/v2 v2.0.7/go.mod h1:qxn986l+q33J5VkialKMqT/TTs3E+U9MJpd001iWQ9I=
+github.com/alibabacloud-go/tea-xml v1.1.3 h1:7LYnm+JbOq2B+T/B0fHC4Ies4/FofC4zHzYtqw7dgt0=
+github.com/alibabacloud-go/tea-xml v1.1.3/go.mod h1:Rq08vgCcCAjHyRi/M7xlHKUykZCEtyBy9+DPF6GgEu8=
+github.com/aliyun/alibaba-cloud-sdk-go v1.61.1800 h1:ie/8RxBOfKZWcrbYSJi2Z8uX8TcOlSMwPlEJh83OeOw=
 github.com/aliyun/alibaba-cloud-sdk-go v1.61.1800/go.mod h1:RcDobYh8k5VP6TNybz9m++gL3ijVI5wueVr0EM10VsU=
-github.com/aliyun/alibaba-cloud-sdk-go v1.62.589 h1:G0ct80P/GKraO8BIZnkuzzNho/3x2QoWnXWdEmW+1Ok=
-github.com/aliyun/alibaba-cloud-sdk-go v1.62.589/go.mod h1:CJJYa1ZMxjlN/NbXEwmejEnBkhi0DV+Yb3B2lxf+74o=
-github.com/aliyun/alibabacloud-dkms-gcs-go-sdk v0.2.2 h1:rWkH6D2XlXb/Y+tNAQROxBzp3a0p92ni+pXcaHBe/WI=
-github.com/aliyun/alibabacloud-dkms-gcs-go-sdk v0.2.2/go.mod h1:GDtq+Kw+v0fO+j5BrrWiUHbBq7L+hfpzpPfXKOZMFE0=
-github.com/aliyun/alibabacloud-dkms-transfer-go-sdk v0.1.7 h1:olLiPI2iM8Hqq6vKnSxpM3awCrm9/BeOgHpzQkOYnI4=
-github.com/aliyun/alibabacloud-dkms-transfer-go-sdk v0.1.7/go.mod h1:oDg1j4kFxnhgftaiLJABkGeSvuEvSF5Lo6UmRAMruX4=
+github.com/aliyun/alibabacloud-dkms-gcs-go-sdk v0.5.1 h1:nJYyoFP+aqGKgPs9JeZgS1rWQ4NndNR0Zfhh161ZltU=
+github.com/aliyun/alibabacloud-dkms-gcs-go-sdk v0.5.1/go.mod h1:WzGOmFFTlUzXM03CJnHWMQ85UN6QGpOXZocCjwkiyOg=
+github.com/aliyun/alibabacloud-dkms-transfer-go-sdk v0.1.8 h1:QeUdR7JF7iNCvO/81EhxEr3wDwxk4YBoYZOq6E0AjHI=
+github.com/aliyun/alibabacloud-dkms-transfer-go-sdk v0.1.8/go.mod h1:xP0KIZry6i7oGPF24vhAPr1Q8vLZRcMcxtft5xDKwCU=
+github.com/aliyun/aliyun-secretsmanager-client-go v1.1.5 h1:8S0mtD101RDYa0LXwdoqgN0RxdMmmJYjq8g2mk7/lQ4=
+github.com/aliyun/aliyun-secretsmanager-client-go v1.1.5/go.mod h1:M19fxYz3gpm0ETnoKweYyYtqrtnVtrpKFpwsghbw+cQ=
+github.com/aliyun/credentials-go v1.1.2/go.mod h1:ozcZaMR5kLM7pwtCMEpVmQ242suV6qTJya2bDq4X1Tw=
+github.com/aliyun/credentials-go v1.3.1/go.mod h1:8jKYhQuDawt8x2+fusqa1Y6mPxemTsBEN04dgcAcYz0=
+github.com/aliyun/credentials-go v1.3.6/go.mod h1:1LxUuX7L5YrZUWzBrRyk0SwSdH4OmPrib8NVePL3fxM=
+github.com/aliyun/credentials-go v1.3.10/go.mod h1:Jm6d+xIgwJVLVWT561vy67ZRP4lPTQxMbEYRuT2Ti1U=
+github.com/aliyun/credentials-go v1.4.3 h1:N3iHyvHRMyOwY1+0qBLSf3hb5JFiOujVSVuEpgeGttY=
+github.com/aliyun/credentials-go v1.4.3/go.mod h1:Jm6d+xIgwJVLVWT561vy67ZRP4lPTQxMbEYRuT2Ti1U=
 github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
 github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
 github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/clbanning/mxj/v2 v2.5.5/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyME=
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/deckarep/golang-set v1.7.1 h1:SCQV0S6gTtp6itiFrTqI+pfmJ4LN85S1YzhDf9rTHJQ=
+github.com/deckarep/golang-set v1.7.1/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
-github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
 github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
 github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/goji/httpauth v0.0.0-20160601135302-2da839ab0f4d/go.mod h1:nnjvkQ9ptGaCkuDUx6wNykzzlUixGxvkme+H/lnzb+A=
-github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
 github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
 github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gopherjs/gopherjs v0.0.0-20200217142428-fce0ec30dd00/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtgzltlQbOBae4=
 github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af h1:pmfjZENx5imkbgOkpRUYLnmbU7UEFbjtDA2hxJ1ichM=
 github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
 github.com/json-iterator/go v1.1.5/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
@@ -80,12 +249,15 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -93,62 +265,97 @@ github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lN
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
-github.com/nacos-group/nacos-sdk-go/v2 v2.2.5 h1:r0wwT7PayEjvEHzWXwr1ROi/JSqzujM4w+1L5ikThzQ=
-github.com/nacos-group/nacos-sdk-go/v2 v2.2.5/go.mod h1:OObBon0prVJVPoIbSZxpEkFiBfL0d1LcBtuAMiNn+8c=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/nacos-group/nacos-sdk-go/v2 v2.3.3 h1:lvkBZcYkKENLVR1ubO+vGxTP2L4VtVSArLvYZKuu4Pk=
+github.com/nacos-group/nacos-sdk-go/v2 v2.3.3/go.mod h1:ygUBdt7eGeYBt6Lz2HO3wx7crKXk25Mp80568emGMWU=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
-github.com/opentracing/opentracing-go v1.2.1-0.20220228012449-10b1cf09e00b h1:FfH+VrHHk6Lxt9HdVS0PXzSXFyS2NbZKXv33FYPol0A=
-github.com/opentracing/opentracing-go v1.2.1-0.20220228012449-10b1cf09e00b/go.mod h1:AC62GU6hc0BrNm+9RK9VSiwa/EUe1bkIeFORAMcHvJU=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/orcaman/concurrent-map v0.0.0-20210501183033-44dafcb38ecc h1:Ak86L+yDSOzKFa7WM5bf5itSOo1e3Xh8bm5YCMUXIjQ=
+github.com/orcaman/concurrent-map v0.0.0-20210501183033-44dafcb38ecc/go.mod h1:Lu3tH6HLW3feq74c2GC+jIMS/K2CFcDWnWD9XkenwhI=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 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/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
-github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
-github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
-github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
-github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=
-github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8=
-github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
-github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
+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=
+github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
+github.com/prometheus/client_golang v1.12.2 h1:51L9cDoUHVrXx4zWYlcLQIZ+d+VXHgqnYKkIuq4g/34=
+github.com/prometheus/client_golang v1.12.2/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
+github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
+github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
+github.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4=
+github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU=
+github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/assertions v1.1.0/go.mod h1:tcbTF8ujkAEcZ8TElKY+i30BzYlVhC/LOxJk7iOWnoo=
+github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/uber/jaeger-client-go v2.30.0+incompatible h1:D6wyKGCecFaSRUpo8lCVbaOOb6ThwMmTEbhRwtKR97o=
-github.com/uber/jaeger-client-go v2.30.0+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk=
-github.com/uber/jaeger-lib v2.4.1+incompatible h1:td4jdvLcExb4cBISKIpHuGoVXh+dVKhn2Um6rjCsSsg=
-github.com/uber/jaeger-lib v2.4.1+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/tjfoc/gmsm v1.3.2/go.mod h1:HaUcFuY0auTiaHB9MHFGCPx5IaLhTUd2atbCFBQXn9w=
+github.com/tjfoc/gmsm v1.4.1 h1:aMe1GlZb+0bLjn+cKTPEvvn9oUEBlJitaZiiBwsbgho=
+github.com/tjfoc/gmsm v1.4.1/go.mod h1:j4INPkHWMrhJb38G+J6W4Tw0AbuN8Thu3PbdVYhVcTE=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.30/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
+go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
-go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
-go.uber.org/atomic v1.10.0 h1:9qC72Qh0+3MqyJbAn8YU5xVq1frD8bn3JtD2oXtafVQ=
-go.uber.org/atomic v1.10.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
@@ -156,93 +363,366 @@ go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4=
 go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
 go.uber.org/zap v1.21.0 h1:WefMeulhovoZ2sYXz7st6K0sLj7bBhpiFaud4r4zST8=
 go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191219195013-becbf705a915/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
-golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
-golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20201012173705-84dcc777aaee/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I=
+golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
+golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
 golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
-golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
+golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
+golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
 golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
 golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20201010224723-4f7140c49acb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.11.0/go.mod h1:2L/ixqYpgIVXmeoSA/4Lu7BzTG4KIyPIryS4IsOd1oQ=
+golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
+golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
-golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
+golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200509044756-6aff5f38e54f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.9.0/go.mod h1:M6DEAAIenWoTxdKrOltXcmDY3rSplQUkrvaDU5FcQyo=
+golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
+golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
+golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
+golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.1.0 h1:xYY+Bajn2a7VBmTM5GikTmnK8ZuX8YgnQCqZpbBNtmA=
 golang.org/x/time v0.1.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190206041539-40960b6deb8e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200509030707-2212a7e161a5/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
 golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo=
-gonum.org/v1/gonum v0.8.2/go.mod h1:oe/vMfY3deqTw+1EZJhuvEW2iwGF1bW9wwu7XCu0+v0=
-gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw=
-gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d h1:uvYuEyMHKNt+lT4K3bN6fGswmK8qSvcreM3BwjDh+y4=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d/go.mod h1:+Bk1OCOj40wS2hwAMA+aCW9ypzm63QTBBHp6lQ3p+9M=
-google.golang.org/grpc v1.59.0 h1:Z5Iec2pjwb+LEOqzpB2MR12/eKFhDPhuqW91O+4bwUk=
-google.golang.org/grpc v1.59.0/go.mod h1:aUPDwccQo6OTjy7Hct4AfBPD1GptF4fyUjIkQ9YtF98=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
+google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
+google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 h1:e7S5W7MGGLaSu8j3YjdezkZ+m1/Nm0uRVRMEMGk26Xs=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.67.3 h1:OgPcDAFKHnH8X3O4WcO4XUc8GRDeKsKReqbQtiCj7N8=
+google.golang.org/grpc v1.67.3/go.mod h1:YGaHCc6Oap+FzBJTZLBzkGSYt/cvGPFTPxkn7QfSU8s=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=
+google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/ini.v1 v1.56.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/ini.v1 v1.66.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
 gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
-gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
-gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
+gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8=
+gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
diff --git a/contrib/config/nacos/nacos.go b/contrib/config/nacos/nacos.go
index 1788b1ed5..611297f2d 100644
--- a/contrib/config/nacos/nacos.go
+++ b/contrib/config/nacos/nacos.go
@@ -21,6 +21,12 @@ import (
 	"github.com/gogf/gf/v2/os/gcfg"
 )
 
+var (
+	// Compile-time checking for interface implementation.
+	_ gcfg.Adapter        = (*Client)(nil)
+	_ gcfg.WatcherAdapter = (*Client)(nil)
+)
+
 // Config is the configuration object for nacos client.
 type Config struct {
 	ServerConfigs  []constant.ServerConfig                     `v:"required"` // See constant.ServerConfig
@@ -32,9 +38,10 @@ type Config struct {
 
 // Client implements gcfg.Adapter implementing using nacos service.
 type Client struct {
-	config Config                      // Config object when created.
-	client config_client.IConfigClient // Nacos config client.
-	value  *g.Var                      // Configmap content cached. It is `*gjson.Json` value internally.
+	config   Config                      // Config object when created.
+	client   config_client.IConfigClient // Nacos config client.
+	value    *g.Var                      // Configmap content cached. It is `*gjson.Json` value internally.
+	watchers *gcfg.WatcherRegistry       // Watchers for watching file changes.
 }
 
 // New creates and returns gcfg.Adapter implementing using nacos service.
@@ -46,8 +53,9 @@ func New(ctx context.Context, config Config) (adapter gcfg.Adapter, err error) {
 	}
 
 	client := &Client{
-		config: config,
-		value:  g.NewVar(nil, true),
+		config:   config,
+		value:    g.NewVar(nil, true),
+		watchers: gcfg.NewWatcherRegistry(),
 	}
 
 	client.client, err = clients.CreateConfigClient(map[string]any{
@@ -127,10 +135,13 @@ func (c *Client) addWatcher() error {
 		return nil
 	}
 	c.config.ConfigParam.OnChange = func(namespace, group, dataId, data string) {
-		c.doUpdate(data)
+		_ = c.doUpdate(data)
 		if c.config.OnConfigChange != nil {
 			go c.config.OnConfigChange(namespace, group, dataId, data)
 		}
+		adapterCtx := NewAdapterCtx().WithOperation(gcfg.OperationUpdate).WithNamespace(namespace).
+			WithGroup(group).WithDataId(dataId).WithContent(data)
+		c.notifyWatchers(adapterCtx.Ctx)
 	}
 
 	if err := c.client.ListenConfig(c.config.ConfigParam); err != nil {
@@ -139,3 +150,28 @@ func (c *Client) addWatcher() error {
 
 	return nil
 }
+
+// AddWatcher adds a watcher for the specified configuration file.
+func (c *Client) AddWatcher(name string, f gcfg.WatcherFunc) {
+	c.watchers.Add(name, f)
+}
+
+// RemoveWatcher removes the watcher for the specified configuration file.
+func (c *Client) RemoveWatcher(name string) {
+	c.watchers.Remove(name)
+}
+
+// GetWatcherNames returns all watcher names.
+func (c *Client) GetWatcherNames() []string {
+	return c.watchers.GetNames()
+}
+
+// IsWatching checks whether the watcher with the specified name is registered.
+func (c *Client) IsWatching(name string) bool {
+	return c.watchers.IsWatching(name)
+}
+
+// notifyWatchers notifies all watchers.
+func (c *Client) notifyWatchers(ctx context.Context) {
+	c.watchers.Notify(ctx)
+}
diff --git a/contrib/config/nacos/nacos_adapter_ctx.go b/contrib/config/nacos/nacos_adapter_ctx.go
new file mode 100644
index 000000000..43880ff2c
--- /dev/null
+++ b/contrib/config/nacos/nacos_adapter_ctx.go
@@ -0,0 +1,131 @@
+// 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 nacos implements gcfg.Adapter using nacos service.
+package nacos
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/os/gcfg"
+	"github.com/gogf/gf/v2/os/gctx"
+)
+
+const (
+	// ContextKeyNamespace is the context key for namespace
+	ContextKeyNamespace gctx.StrKey = "namespace"
+	// ContextKeyGroup is the context key for group
+	ContextKeyGroup gctx.StrKey = "group"
+	// ContextKeyDataId is the context key for dataId
+	ContextKeyDataId gctx.StrKey = "dataId"
+)
+
+// NacosAdapterCtx is the context adapter for Nacos configuration
+type NacosAdapterCtx struct {
+	Ctx context.Context
+}
+
+// NewAdapterCtxWithCtx creates and returns a new NacosAdapterCtx with the given context.
+func NewAdapterCtxWithCtx(ctx context.Context) *NacosAdapterCtx {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return &NacosAdapterCtx{Ctx: ctx}
+}
+
+// NewAdapterCtx creates and returns a new NacosAdapterCtx.
+// If context is provided, it will be used; otherwise, a background context is created.
+func NewAdapterCtx(ctx ...context.Context) *NacosAdapterCtx {
+	if len(ctx) > 0 {
+		return NewAdapterCtxWithCtx(ctx[0])
+	}
+	return NewAdapterCtxWithCtx(context.Background())
+}
+
+// GetAdapterCtx creates a new NacosAdapterCtx with the given context
+func GetAdapterCtx(ctx context.Context) *NacosAdapterCtx {
+	return NewAdapterCtxWithCtx(ctx)
+}
+
+// WithOperation sets the operation in the context
+func (n *NacosAdapterCtx) WithOperation(operation gcfg.OperationType) *NacosAdapterCtx {
+	n.Ctx = context.WithValue(n.Ctx, gcfg.ContextKeyOperation, operation)
+	return n
+}
+
+// WithNamespace sets the namespace in the context
+func (n *NacosAdapterCtx) WithNamespace(namespace string) *NacosAdapterCtx {
+	n.Ctx = context.WithValue(n.Ctx, ContextKeyNamespace, namespace)
+	return n
+}
+
+// WithGroup sets the group in the context
+func (n *NacosAdapterCtx) WithGroup(group string) *NacosAdapterCtx {
+	n.Ctx = context.WithValue(n.Ctx, ContextKeyGroup, group)
+	return n
+}
+
+// WithDataId sets the dataId in the context
+func (n *NacosAdapterCtx) WithDataId(dataId string) *NacosAdapterCtx {
+	n.Ctx = context.WithValue(n.Ctx, ContextKeyDataId, dataId)
+	return n
+}
+
+// WithContent sets the content in the context
+func (n *NacosAdapterCtx) WithContent(content string) *NacosAdapterCtx {
+	n.Ctx = context.WithValue(n.Ctx, gcfg.ContextKeyContent, content)
+	return n
+}
+
+// GetNamespace retrieves the namespace from the context
+func (n *NacosAdapterCtx) GetNamespace() string {
+	if v := n.Ctx.Value(ContextKeyNamespace); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetGroup retrieves the group from the context
+func (n *NacosAdapterCtx) GetGroup() string {
+	if v := n.Ctx.Value(ContextKeyGroup); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetDataId retrieves the dataId from the context
+func (n *NacosAdapterCtx) GetDataId() string {
+	if v := n.Ctx.Value(ContextKeyDataId); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetContent retrieves the content from the context
+func (n *NacosAdapterCtx) GetContent() string {
+	if v := n.Ctx.Value(gcfg.ContextKeyContent); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetOperation retrieves the operation from the context
+func (n *NacosAdapterCtx) GetOperation() gcfg.OperationType {
+	if v := n.Ctx.Value(gcfg.ContextKeyOperation); v != nil {
+		if s, ok := v.(gcfg.OperationType); ok {
+			return s
+		}
+	}
+	return ""
+}
diff --git a/contrib/config/nacos/nacos_test.go b/contrib/config/nacos/nacos_test.go
index 473a81747..1178d2cfe 100644
--- a/contrib/config/nacos/nacos_test.go
+++ b/contrib/config/nacos/nacos_test.go
@@ -7,6 +7,7 @@
 package nacos_test
 
 import (
+	"context"
 	"net/url"
 	"testing"
 	"time"
@@ -16,6 +17,7 @@ import (
 
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gcfg"
 	"github.com/gogf/gf/v2/os/gctx"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/guid"
@@ -70,12 +72,22 @@ func TestNacosOnConfigChangeFunc(t *testing.T) {
 			ConfigParam:   configParam,
 			Watch:         true,
 			OnConfigChange: func(namespace, group, dataId, data string) {
-				gtest.Assert("public", namespace)
-				gtest.Assert("test", group)
-				gtest.Assert("config.toml", dataId)
-				gtest.Assert("gf", g.Cfg().MustGet(gctx.GetInitCtx(), "app.name").String())
+				t.Assert(namespace, "public")
+				t.Assert(group, "test")
+				t.Assert(dataId, "config.toml")
+				t.Assert(g.Cfg().MustGet(gctx.GetInitCtx(), "app.name").String(), "gf")
 			},
 		})
+		if watcherAdapter, ok := adapter.(gcfg.WatcherAdapter); ok {
+			watcherAdapter.AddWatcher("test", func(ctx context.Context) {
+				adapterCtx := nacos.GetAdapterCtx(ctx)
+				t.Assert(adapterCtx.GetNamespace(), "public")
+				t.Assert(adapterCtx.GetGroup(), "test")
+				t.Assert(adapterCtx.GetDataId(), "config.toml")
+				t.Assert(adapterCtx.GetOperation(), gcfg.OperationUpdate)
+				t.Assert(g.Cfg().MustGet(gctx.GetInitCtx(), "app.name").String(), "gf")
+			})
+		}
 		g.Cfg().SetAdapter(adapter)
 		t.Assert(g.Cfg().Available(ctx), true)
 		appName, err := g.Cfg().Get(ctx, "app.name")
@@ -97,5 +109,8 @@ func TestNacosOnConfigChangeFunc(t *testing.T) {
 		t.AssertNil(err)
 		_, err = g.Client().Post(ctx, configPublishUrl+"&content="+url.QueryEscape(res2))
 		t.AssertNil(err)
+		if watcherAdapter, ok := adapter.(gcfg.WatcherAdapter); ok {
+			t.Assert(watcherAdapter.GetWatcherNames()[0], "test")
+		}
 	})
 }
diff --git a/contrib/config/polaris/go.mod b/contrib/config/polaris/go.mod
index 5e1b018e4..316e98a12 100644
--- a/contrib/config/polaris/go.mod
+++ b/contrib/config/polaris/go.mod
@@ -3,60 +3,60 @@ module github.com/gogf/gf/contrib/config/polaris/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 	github.com/polarismesh/polaris-go v1.6.1
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cespare/xxhash/v2 v2.1.2 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/dlclark/regexp2 v1.11.2 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/dlclark/regexp2 v1.7.0 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/golang/protobuf v1.5.4 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
-	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/errwrap v1.0.0 // indirect
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/natefinch/lumberjack v2.0.0+incompatible // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/polarismesh/specification v1.5.5-alpha.1 // indirect
-	github.com/prometheus/client_golang v1.19.1 // indirect
-	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.55.0 // indirect
-	github.com/prometheus/procfs v0.15.1 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/prometheus/client_golang v1.12.2 // indirect
+	github.com/prometheus/client_model v0.2.0 // indirect
+	github.com/prometheus/common v0.32.1 // indirect
+	github.com/prometheus/procfs v0.7.3 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
 	go.uber.org/atomic v1.7.0 // indirect
 	go.uber.org/multierr v1.6.0 // indirect
 	go.uber.org/zap v1.21.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d // indirect
-	google.golang.org/grpc v1.59.0 // indirect
-	google.golang.org/protobuf v1.34.2 // indirect
+	golang.org/x/text v0.25.0 // indirect
+	google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a // indirect
+	google.golang.org/grpc v1.51.0 // indirect
+	google.golang.org/protobuf v1.28.1 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/contrib/config/polaris/go.sum b/contrib/config/polaris/go.sum
index 1be90b589..f87d16b3f 100644
--- a/contrib/config/polaris/go.sum
+++ b/contrib/config/polaris/go.sum
@@ -188,9 +188,8 @@ github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6r
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
 github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
@@ -209,11 +208,10 @@ github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWH
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dlclark/regexp2 v1.7.0 h1:7lJfhqlPssTb1WQx4yvTHN0uElPEv52sbaECrAQxjAo=
 github.com/dlclark/regexp2 v1.7.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
-github.com/dlclark/regexp2 v1.11.2 h1:/u628IuisSTwri5/UKloiIsH8+qF2Pu7xEQX+yIKg68=
-github.com/dlclark/regexp2 v1.11.2/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
@@ -274,9 +272,8 @@ github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
-github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/gonum/blas v0.0.0-20181208220705-f22b278b28ac/go.mod h1:P32wAyui1PQ58Oce/KYkOqQv8cVw1zAapXOl+dRFGbc=
 github.com/gonum/floats v0.0.0-20181209220543-c233463c7e82/go.mod h1:PxC8OnwL11+aosOB5+iEPoV3picfs8tUpkVd0pDo+Kg=
@@ -344,9 +341,8 @@ github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/ad
 github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtgzltlQbOBae4=
 github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
 github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
+github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
-github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
-github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
 github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
 github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
@@ -377,12 +373,14 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
@@ -392,8 +390,6 @@ github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lN
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/natefinch/lumberjack v2.0.0+incompatible h1:4QJd3OLAMgj7ph+yZTuX13Ld4UpgHp07nNdFX7mqFfM=
@@ -402,8 +398,8 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -418,35 +414,30 @@ github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXP
 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=
 github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
+github.com/prometheus/client_golang v1.12.2 h1:51L9cDoUHVrXx4zWYlcLQIZ+d+VXHgqnYKkIuq4g/34=
 github.com/prometheus/client_golang v1.12.2/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
-github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
-github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
 github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
-github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
 github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
+github.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4=
 github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
-github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=
-github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU=
 github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
-github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
-github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
@@ -468,8 +459,8 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -485,14 +476,16 @@ go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
 go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
 go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
@@ -595,8 +588,8 @@ golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
 golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -704,6 +697,7 @@ golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
@@ -721,8 +715,8 @@ golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -936,9 +930,8 @@ google.golang.org/genproto v0.0.0-20220919141832-68c03719ef51/go.mod h1:0Nb8Qy+S
 google.golang.org/genproto v0.0.0-20220920201722-2b89144ce006/go.mod h1:ht8XFiar2npT/g4vkk7O0WYS1sHOHbdujxbEp7CJWbw=
 google.golang.org/genproto v0.0.0-20220926165614-551eb538f295/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI=
 google.golang.org/genproto v0.0.0-20220926220553-6981cbe3cfce/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI=
+google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a h1:GH6UPn3ixhWcKDhpnEC55S75cerLPdpp3hrhfKYjZgw=
 google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d h1:uvYuEyMHKNt+lT4K3bN6fGswmK8qSvcreM3BwjDh+y4=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d/go.mod h1:+Bk1OCOj40wS2hwAMA+aCW9ypzm63QTBBHp6lQ3p+9M=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
@@ -973,9 +966,8 @@ google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACu
 google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
 google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
 google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
+google.golang.org/grpc v1.51.0 h1:E1eGv1FTqoLIdnBCZufiSHgKjlqG6fKFf6pPWtMTh8U=
 google.golang.org/grpc v1.51.0/go.mod h1:wgNDFcnuBGmxLKI/qn4T+m5BtEBYXJPvibbUPsAIPww=
-google.golang.org/grpc v1.59.0 h1:Z5Iec2pjwb+LEOqzpB2MR12/eKFhDPhuqW91O+4bwUk=
-google.golang.org/grpc v1.59.0/go.mod h1:aUPDwccQo6OTjy7Hct4AfBPD1GptF4fyUjIkQ9YtF98=
 google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
@@ -991,9 +983,8 @@ google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp0
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
 google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/contrib/config/polaris/polaris.go b/contrib/config/polaris/polaris.go
index 5ab4f5548..ade79f43d 100644
--- a/contrib/config/polaris/polaris.go
+++ b/contrib/config/polaris/polaris.go
@@ -21,6 +21,12 @@ import (
 	"github.com/gogf/gf/v2/text/gstr"
 )
 
+var (
+	// Compile-time checking for interface implementation.
+	_ gcfg.Adapter        = (*Client)(nil)
+	_ gcfg.WatcherAdapter = (*Client)(nil)
+)
+
 // Config is the configuration for polaris.
 type Config struct {
 	// The namespace of the configuration.
@@ -39,9 +45,10 @@ type Config struct {
 
 // Client implements gcfg.Adapter implementing using polaris service.
 type Client struct {
-	config Config
-	client model.ConfigFile
-	value  *g.Var
+	config   Config
+	client   model.ConfigFile
+	value    *g.Var
+	watchers *gcfg.WatcherRegistry
 }
 
 const defaultLogDir = "/tmp/polaris/log"
@@ -54,8 +61,9 @@ func New(ctx context.Context, config Config) (adapter gcfg.Adapter, err error) {
 	}
 	var (
 		client = &Client{
-			config: config,
-			value:  g.NewVar(nil, true),
+			config:   config,
+			value:    g.NewVar(nil, true),
+			watchers: gcfg.NewWatcherRegistry(),
 		}
 		configAPI polaris.ConfigAPI
 	)
@@ -142,18 +150,24 @@ func (c *Client) updateLocalValueAndWatch(ctx context.Context) (err error) {
 	return nil
 }
 
+// doUpdate retrieves and caches the configmap content.
 func (c *Client) doUpdate(ctx context.Context) (err error) {
 	if !c.client.HasContent() {
 		return gerror.New("config file is empty")
 	}
 	var j *gjson.Json
-	if j, err = gjson.LoadContent([]byte(c.client.GetContent())); err != nil {
+	content := c.client.GetContent()
+	if j, err = gjson.LoadContent([]byte(content)); err != nil {
 		return gerror.Wrap(err, `parse config map item from polaris failed`)
 	}
 	c.value.Set(j)
+	adapterCtx := NewAdapterCtx(ctx).WithNamespace(c.config.Namespace).WithFileGroup(c.config.FileGroup).
+		WithFileName(c.config.FileName).WithOperation(gcfg.OperationUpdate).WithContent(content)
+	c.notifyWatchers(adapterCtx.Ctx)
 	return nil
 }
 
+// doWatch watches the configmap content.
 func (c *Client) doWatch(ctx context.Context) (err error) {
 	if !c.config.Watch {
 		return nil
@@ -165,11 +179,34 @@ func (c *Client) doWatch(ctx context.Context) (err error) {
 	return nil
 }
 
+// startAsynchronousWatch starts the asynchronous watch for the specified configuration file.
 func (c *Client) startAsynchronousWatch(ctx context.Context, changeChan <-chan model.ConfigFileChangeEvent) {
-	for {
-		select {
-		case <-changeChan:
-			_ = c.doUpdate(ctx)
-		}
+	for range changeChan {
+		_ = c.doUpdate(ctx)
 	}
 }
+
+// AddWatcher adds a watcher for the specified configuration file.
+func (c *Client) AddWatcher(name string, f gcfg.WatcherFunc) {
+	c.watchers.Add(name, f)
+}
+
+// RemoveWatcher removes the watcher for the specified configuration file.
+func (c *Client) RemoveWatcher(name string) {
+	c.watchers.Remove(name)
+}
+
+// GetWatcherNames returns all watcher names.
+func (c *Client) GetWatcherNames() []string {
+	return c.watchers.GetNames()
+}
+
+// IsWatching checks whether the watcher with the specified name is registered.
+func (c *Client) IsWatching(name string) bool {
+	return c.watchers.IsWatching(name)
+}
+
+// notifyWatchers notifies all watchers.
+func (c *Client) notifyWatchers(ctx context.Context) {
+	c.watchers.Notify(ctx)
+}
diff --git a/contrib/config/polaris/polaris_adapter_ctx.go b/contrib/config/polaris/polaris_adapter_ctx.go
new file mode 100644
index 000000000..d954f72c7
--- /dev/null
+++ b/contrib/config/polaris/polaris_adapter_ctx.go
@@ -0,0 +1,129 @@
+// 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 implements gcfg.Adapter using polaris service.
+package polaris
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/os/gcfg"
+	"github.com/gogf/gf/v2/os/gctx"
+)
+
+const (
+	// ContextKeyNamespace is the context key for namespace
+	ContextKeyNamespace gctx.StrKey = "namespace"
+	// ContextKeyFileGroup is the context key for group
+	ContextKeyFileGroup gctx.StrKey = "fileGroup"
+)
+
+// PolarisAdapterCtx is the context adapter for polaris configuration
+type PolarisAdapterCtx struct {
+	Ctx context.Context
+}
+
+// NewAdapterCtxWithCtx creates and returns a new PolarisAdapterCtx with the given context.
+func NewAdapterCtxWithCtx(ctx context.Context) *PolarisAdapterCtx {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return &PolarisAdapterCtx{Ctx: ctx}
+}
+
+// NewAdapterCtx creates and returns a new PolarisAdapterCtx.
+// If context is provided, it will be used; otherwise, a background context is created.
+func NewAdapterCtx(ctx ...context.Context) *PolarisAdapterCtx {
+	if len(ctx) > 0 {
+		return NewAdapterCtxWithCtx(ctx[0])
+	}
+	return NewAdapterCtxWithCtx(context.Background())
+}
+
+// GetAdapterCtx creates a new PolarisAdapterCtx with the given context
+func GetAdapterCtx(ctx context.Context) *PolarisAdapterCtx {
+	return NewAdapterCtxWithCtx(ctx)
+}
+
+// WithOperation sets the operation in the context
+func (n *PolarisAdapterCtx) WithOperation(operation gcfg.OperationType) *PolarisAdapterCtx {
+	n.Ctx = context.WithValue(n.Ctx, gcfg.ContextKeyOperation, operation)
+	return n
+}
+
+// WithNamespace sets the namespace in the context
+func (n *PolarisAdapterCtx) WithNamespace(namespace string) *PolarisAdapterCtx {
+	n.Ctx = context.WithValue(n.Ctx, ContextKeyNamespace, namespace)
+	return n
+}
+
+// WithFileGroup sets the group in the context
+func (n *PolarisAdapterCtx) WithFileGroup(fileGroup string) *PolarisAdapterCtx {
+	n.Ctx = context.WithValue(n.Ctx, ContextKeyFileGroup, fileGroup)
+	return n
+}
+
+// WithFileName sets the fileName in the context
+func (n *PolarisAdapterCtx) WithFileName(fileName string) *PolarisAdapterCtx {
+	n.Ctx = context.WithValue(n.Ctx, gcfg.ContextKeyFileName, fileName)
+	return n
+}
+
+// WithContent sets the content in the context
+func (n *PolarisAdapterCtx) WithContent(content string) *PolarisAdapterCtx {
+	n.Ctx = context.WithValue(n.Ctx, gcfg.ContextKeyContent, content)
+	return n
+}
+
+// GetNamespace retrieves the namespace from the context
+func (n *PolarisAdapterCtx) GetNamespace() string {
+	if v := n.Ctx.Value(ContextKeyNamespace); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetFileGroup retrieves the group from the context
+func (n *PolarisAdapterCtx) GetFileGroup() string {
+	if v := n.Ctx.Value(ContextKeyFileGroup); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetFileName retrieves the fileName from the context
+func (n *PolarisAdapterCtx) GetFileName() string {
+	if v := n.Ctx.Value(gcfg.ContextKeyFileName); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetContent retrieves the content from the context
+func (n *PolarisAdapterCtx) GetContent() string {
+	if v := n.Ctx.Value(gcfg.ContextKeyContent); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetOperation retrieves the operation from the context
+func (n *PolarisAdapterCtx) GetOperation() gcfg.OperationType {
+	if v := n.Ctx.Value(gcfg.ContextKeyOperation); v != nil {
+		if s, ok := v.(gcfg.OperationType); ok {
+			return s
+		}
+	}
+	return ""
+}
diff --git a/contrib/drivers/README.MD b/contrib/drivers/README.MD
index eaf4966f7..29827f019 100644
--- a/contrib/drivers/README.MD
+++ b/contrib/drivers/README.MD
@@ -1,4 +1,3 @@
-[简体中文](README.zh_CN.MD)
 
 # Database drivers
 
@@ -9,15 +8,20 @@ Powerful database drivers for package gdb.
 Let's take `mysql` for example.
 
 ```shell
-go get -u github.com/gogf/gf/contrib/drivers/mysql/v2
-# Easy to copy
-go get -u github.com/gogf/gf/contrib/drivers/clickhouse/v2
-go get -u github.com/gogf/gf/contrib/drivers/dm/v2
-go get -u github.com/gogf/gf/contrib/drivers/mssql/v2
-go get -u github.com/gogf/gf/contrib/drivers/oracle/v2
-go get -u github.com/gogf/gf/contrib/drivers/pgsql/v2
-go get -u github.com/gogf/gf/contrib/drivers/sqlite/v2
-go get -u github.com/gogf/gf/contrib/drivers/sqlitecgo/v2
+go get github.com/gogf/gf/contrib/drivers/mysql/v2@latest
+
+# Easy for copying:
+go get github.com/gogf/gf/contrib/drivers/clickhouse/v2@latest
+go get github.com/gogf/gf/contrib/drivers/dm/v2@latest
+go get github.com/gogf/gf/contrib/drivers/gaussdb/v2@latest
+go get github.com/gogf/gf/contrib/drivers/mariadb/v2@latest
+go get github.com/gogf/gf/contrib/drivers/mssql/v2@latest
+go get github.com/gogf/gf/contrib/drivers/oceanbase/v2@latest
+go get github.com/gogf/gf/contrib/drivers/oracle/v2@latest
+go get github.com/gogf/gf/contrib/drivers/pgsql/v2@latest
+go get github.com/gogf/gf/contrib/drivers/sqlite/v2@latest
+go get github.com/gogf/gf/contrib/drivers/sqlitecgo/v2@latest
+go get github.com/gogf/gf/contrib/drivers/tidb/v2@latest
 ```
 
 Choose and import the driver to your project:
@@ -44,12 +48,36 @@ func main() {
 
 ## Supported Drivers
 
-### MySQL/MariaDB/TiDB
+### MySQL
 
 ```go
 import _ "github.com/gogf/gf/contrib/drivers/mysql/v2"
 ```
 
+### MariaDB
+
+```go
+import _ "github.com/gogf/gf/contrib/drivers/mariadb/v2"
+```
+
+### TiDB
+
+```go
+import _ "github.com/gogf/gf/contrib/drivers/tidb/v2"
+```
+
+### OceanBase
+
+```go
+import _ "github.com/gogf/gf/contrib/drivers/oceanbase/v2"
+```
+
+### GaussDB
+
+```go
+import _ "github.com/gogf/gf/contrib/drivers/gaussdb/v2"
+```
+
 ### SQLite
 
 ```go
@@ -58,7 +86,7 @@ import _ "github.com/gogf/gf/contrib/drivers/sqlite/v2"
 
 #### cgo version
 
-When the target is a 32-bit Windows system, the cgo version needs to be used.
+When the target is a `32-bit` Windows system, the `cgo` version needs to be used.
 
 ```go
 import _ "github.com/gogf/gf/contrib/drivers/sqlitecgo/v2"
@@ -70,10 +98,6 @@ import _ "github.com/gogf/gf/contrib/drivers/sqlitecgo/v2"
 import _ "github.com/gogf/gf/contrib/drivers/pgsql/v2"
 ```
 
-Note:
-
-- It does not support `Replace` features.
-
 ### SQL Server
 
 ```go
@@ -82,10 +106,10 @@ import _ "github.com/gogf/gf/contrib/drivers/mssql/v2"
 
 Note:
 
-- It does not support `Replace` features.
-- It does not support `LastInsertId`.
+- `InsertIgnore` returns error if there is no primary key or unique index submitted with record.
 - 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.
+- 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
 
@@ -95,8 +119,8 @@ import _ "github.com/gogf/gf/contrib/drivers/oracle/v2"
 
 Note:
 
-- It does not support `Replace` features.
 - It does not support `LastInsertId`.
+- `InsertIgnore` returns error if there is no primary key or unique index submitted with record.
 
 ### ClickHouse
 
@@ -106,7 +130,7 @@ import _ "github.com/gogf/gf/contrib/drivers/clickhouse/v2"
 
 Note:
 
-- It does not support `InsertIgnore/InsertGetId` features.
+- It does not support `InsertIgnore/InsertAndGetId` features.
 - It does not support `Save/Replace` features.
 - It does not support `Transaction` feature.
 - It does not support `RowsAffected` feature.
@@ -119,7 +143,7 @@ import _ "github.com/gogf/gf/contrib/drivers/dm/v2"
 
 Note:
 
-- It does not support `Replace` features.
+- `InsertIgnore` returns error if there is no primary key or unique index submitted with record.
 
 ## Custom Drivers
 
diff --git a/contrib/drivers/README.zh_CN.MD b/contrib/drivers/README.zh_CN.MD
deleted file mode 100644
index 27699c0b5..000000000
--- a/contrib/drivers/README.zh_CN.MD
+++ /dev/null
@@ -1,125 +0,0 @@
-# 数据库驱动程序
-
-用于gdb包的数据库驱动程序。
-
-## 安装
-
-以 `mysql` 为例。
-
-```shell
-go get -u github.com/gogf/gf/contrib/drivers/mysql/v2
-# 方便复制
-go get -u github.com/gogf/gf/contrib/drivers/clickhouse/v2
-go get -u github.com/gogf/gf/contrib/drivers/dm/v2
-go get -u github.com/gogf/gf/contrib/drivers/mssql/v2
-go get -u github.com/gogf/gf/contrib/drivers/oracle/v2
-go get -u github.com/gogf/gf/contrib/drivers/pgsql/v2
-go get -u github.com/gogf/gf/contrib/drivers/sqlite/v2
-go get -u github.com/gogf/gf/contrib/drivers/sqlitecgo/v2
-```
-
-选择并将驱动程序导入到您的项目中：
-
-```go
-import _ "github.com/gogf/gf/contrib/drivers/mysql/v2"
-```
-
-通常在 `main.go` 的顶部导入：
-
-```go
-package main
-
-import (
-	_ "github.com/gogf/gf/contrib/drivers/mysql/v2"
-
-	// 其他导入的包。
-)
-
-func main() {
-	// 主要逻辑。
-}
-```
-
-## 支持的驱动程序
-
-### MySQL/MariaDB/TiDB
-
-```go
-import _ "github.com/gogf/gf/contrib/drivers/mysql/v2"
-```
-
-### SQLite
-
-```go
-import _ "github.com/gogf/gf/contrib/drivers/sqlite/v2"
-```
-
-#### cgo 版本
-
-32位Windows请使用cgo版本
-
-```go
-import _ "github.com/gogf/gf/contrib/drivers/sqlitecgo/v2"
-```
-
-### PostgreSQL
-
-```go
-import _ "github.com/gogf/gf/contrib/drivers/pgsql/v2"
-```
-
-注意：
-
-- 不支持 `Replace` 功能。
-
-### SQL Server
-
-```go
-import _ "github.com/gogf/gf/contrib/drivers/mssql/v2"
-```
-
-注意：
-
-- 不支持 `Replace` 功能。
-- 不支持 `LastInsertId`。
-- 仅支持服务器版本 >= `SQL Server2005`
-- 仅支持 datetime2 和 datetimeoffset 类型来自动处理 created_at/updated_at/deleted_at 列，因为 datetime 类型在将列值作为字符串传递时不支持微秒精度。
-
-### Oracle
-
-```go
-import _ "github.com/gogf/gf/contrib/drivers/oracle/v2"
-```
-
-注意：
-
-- 不支持 `Replace` 功能。
-- 不支持 `LastInsertId`。
-
-### ClickHouse
-
-```go
-import _ "github.com/gogf/gf/contrib/drivers/clickhouse/v2"
-```
-
-注意：
-
-- 不支持 `InsertIgnore/InsertGetId` 功能。
-- 不支持 `Save/Replace` 功能。
-- 不支持 `Transaction` 功能。
-- 不支持 `RowsAffected` 功能。
-
-### DM
-
-```go
-import _ "github.com/gogf/gf/contrib/drivers/dm/v2"
-```
-
-注意：
-
-- 不支持 `Replace` 功能。
-
-## 自定义驱动程序
-
-自定义驱动程序非常快速和简单，您可以参考当前驱动程序的源代码来进行开发。
-如果您有关于支持新驱动程序的PR（Pull Request），我们将非常感激地接受您的提交到当前仓库。
\ No newline at end of file
diff --git a/contrib/drivers/clickhouse/clickhouse.go b/contrib/drivers/clickhouse/clickhouse.go
index e0dbc24fa..2452c931c 100644
--- a/contrib/drivers/clickhouse/clickhouse.go
+++ b/contrib/drivers/clickhouse/clickhouse.go
@@ -15,7 +15,7 @@ import (
 	"github.com/gogf/gf/v2/os/gctx"
 )
 
-// Driver is the driver for postgresql database.
+// Driver is the driver for clickhouse database.
 type Driver struct {
 	*gdb.Core
 }
@@ -29,12 +29,11 @@ var (
 )
 
 const (
-	updateFilterPattern              = `(?i)UPDATE[\s]+?(\w+[\.]?\w+)[\s]+?SET`
-	deleteFilterPattern              = `(?i)DELETE[\s]+?FROM[\s]+?(\w+[\.]?\w+)`
-	filterTypePattern                = `(?i)^UPDATE|DELETE`
-	replaceSchemaPattern             = `@(.+?)/([\w\.\-]+)+`
-	needParsedSqlInCtx   gctx.StrKey = "NeedParsedSql"
-	driverName                       = "clickhouse"
+	updateFilterPattern             = `(?i)UPDATE[\s]+?(\w+[\.]?\w+)[\s]+?SET`
+	deleteFilterPattern             = `(?i)DELETE[\s]+?FROM[\s]+?(\w+[\.]?\w+)`
+	filterTypePattern               = `(?i)^UPDATE|DELETE`
+	needParsedSqlInCtx  gctx.StrKey = "NeedParsedSql"
+	driverName                      = "clickhouse"
 )
 
 func init() {
diff --git a/contrib/drivers/clickhouse/clickhouse_convert.go b/contrib/drivers/clickhouse/clickhouse_convert.go
index e4392bcec..ccde35141 100644
--- a/contrib/drivers/clickhouse/clickhouse_convert.go
+++ b/contrib/drivers/clickhouse/clickhouse_convert.go
@@ -26,6 +26,7 @@ func (d *Driver) ConvertValueForField(ctx context.Context, fieldType string, fie
 		if itemValue.IsZero() {
 			return nil, nil
 		}
+		return itemValue, nil
 
 	case uuid.UUID:
 		return itemValue, nil
@@ -48,15 +49,13 @@ func (d *Driver) ConvertValueForField(ctx context.Context, fieldType string, fie
 		return itemValue.Time, nil
 
 	case *gtime.Time:
-		// for gtime type, needs to get time.Time
-		if itemValue != nil {
-			return itemValue.Time, nil
-		}
 		// If the time is zero, it then updates it to nil,
 		// which will insert/update the value to database as "null".
 		if itemValue == nil || itemValue.IsZero() {
 			return nil, nil
 		}
+		// for gtime type, needs to get time.Time
+		return itemValue.Time, nil
 
 	case decimal.Decimal:
 		return itemValue, nil
@@ -81,5 +80,4 @@ func (d *Driver) ConvertValueForField(ctx context.Context, fieldType string, fie
 		}
 		return convertedValue, nil
 	}
-	return fieldValue, nil
 }
diff --git a/contrib/drivers/clickhouse/clickhouse_do_filter.go b/contrib/drivers/clickhouse/clickhouse_do_filter.go
index 0bac9fbea..04fa04ee5 100644
--- a/contrib/drivers/clickhouse/clickhouse_do_filter.go
+++ b/contrib/drivers/clickhouse/clickhouse_do_filter.go
@@ -73,13 +73,11 @@ func (d *Driver) DoFilter(
 		}
 		return newSql, args, nil
 
+	default:
+		return originSql, args, nil
 	}
-	return originSql, args, nil
 }
 
 func (d *Driver) getNeedParsedSqlFromCtx(ctx context.Context) bool {
-	if ctx.Value(needParsedSqlInCtx) != nil {
-		return true
-	}
-	return false
+	return ctx.Value(needParsedSqlInCtx) != nil
 }
diff --git a/contrib/drivers/clickhouse/clickhouse_do_insert.go b/contrib/drivers/clickhouse/clickhouse_do_insert.go
index 6a3f4b7c2..a71276913 100644
--- a/contrib/drivers/clickhouse/clickhouse_do_insert.go
+++ b/contrib/drivers/clickhouse/clickhouse_do_insert.go
@@ -16,13 +16,12 @@ import (
 )
 
 // DoInsert inserts or updates data for given table.
+// The list parameter must contain at least one record, which was previously validated.
 func (d *Driver) DoInsert(
 	ctx context.Context, link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
 ) (result sql.Result, err error) {
-	var (
-		keys        []string // Field names.
-		valueHolder = make([]string, 0)
-	)
+	var keys, valueHolder []string
+
 	// Handle the field names and placeholders.
 	for k := range list[0] {
 		keys = append(keys, k)
@@ -56,7 +55,12 @@ func (d *Driver) DoInsert(
 	if err != nil {
 		return
 	}
-	for i := 0; i < len(list); i++ {
+
+	defer func() {
+		_ = stmt.Close()
+	}()
+
+	for i := range len(list) {
 		// Values that will be committed to underlying database driver.
 		params := make([]any, 0)
 		for _, k := range keys {
diff --git a/contrib/drivers/clickhouse/clickhouse_z_unit_db_test.go b/contrib/drivers/clickhouse/clickhouse_z_unit_db_test.go
index fc8d62fb8..05e1cbc69 100644
--- a/contrib/drivers/clickhouse/clickhouse_z_unit_db_test.go
+++ b/contrib/drivers/clickhouse/clickhouse_z_unit_db_test.go
@@ -303,6 +303,8 @@ func Test_DB_Tables(t *testing.T) {
 			createTable(v)
 		}
 
+		defer dropTable(tables...)
+
 		result, err := db.Tables(ctx)
 		gtest.AssertNil(err)
 
diff --git a/contrib/drivers/clickhouse/clickhouse_z_unit_init_test.go b/contrib/drivers/clickhouse/clickhouse_z_unit_init_test.go
index ab775d818..f7bffd155 100644
--- a/contrib/drivers/clickhouse/clickhouse_z_unit_init_test.go
+++ b/contrib/drivers/clickhouse/clickhouse_z_unit_init_test.go
@@ -52,8 +52,10 @@ func createInitTable(table ...string) string {
 	return createInitTableWithDb(db, table...)
 }
 
-func dropTable(table string) {
-	dropTableWithDb(db, table)
+func dropTable(tables ...string) {
+	for _, table := range tables {
+		dropTableWithDb(db, table)
+	}
 }
 
 func createTableWithDb(db gdb.DB, table ...string) (name string) {
diff --git a/contrib/drivers/clickhouse/clickhouse_z_unit_test.go b/contrib/drivers/clickhouse/clickhouse_z_unit_test.go
index e2b7f2ac2..a496db0e8 100644
--- a/contrib/drivers/clickhouse/clickhouse_z_unit_test.go
+++ b/contrib/drivers/clickhouse/clickhouse_z_unit_test.go
@@ -8,7 +8,6 @@ package clickhouse
 
 import (
 	"context"
-	"fmt"
 	"testing"
 	"time"
 
@@ -166,22 +165,22 @@ func createClickhouseExampleTable(connect gdb.DB) error {
 }
 
 func dropClickhouseTableVisits(conn gdb.DB) {
-	sqlStr := fmt.Sprintf("DROP TABLE IF EXISTS `visits`")
+	sqlStr := "DROP TABLE IF EXISTS `visits`"
 	_, _ = conn.Exec(context.Background(), sqlStr)
 }
 
 func dropClickhouseTableDim(conn gdb.DB) {
-	sqlStr := fmt.Sprintf("DROP TABLE IF EXISTS `dim`")
+	sqlStr := "DROP TABLE IF EXISTS `dim`"
 	_, _ = conn.Exec(context.Background(), sqlStr)
 }
 
 func dropClickhouseTableFact(conn gdb.DB) {
-	sqlStr := fmt.Sprintf("DROP TABLE IF EXISTS `fact`")
+	sqlStr := "DROP TABLE IF EXISTS `fact`"
 	_, _ = conn.Exec(context.Background(), sqlStr)
 }
 
 func dropClickhouseExampleTable(conn gdb.DB) {
-	sqlStr := fmt.Sprintf("DROP TABLE IF EXISTS `data_type`")
+	sqlStr := "DROP TABLE IF EXISTS `data_type`"
 	_, _ = conn.Exec(context.Background(), sqlStr)
 }
 
diff --git a/contrib/drivers/clickhouse/go.mod b/contrib/drivers/clickhouse/go.mod
index 9aee2bc46..37940d8e5 100644
--- a/contrib/drivers/clickhouse/go.mod
+++ b/contrib/drivers/clickhouse/go.mod
@@ -4,7 +4,7 @@ go 1.23.0
 
 require (
 	github.com/ClickHouse/clickhouse-go/v2 v2.0.15
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 	github.com/google/uuid v1.6.0
 	github.com/shopspring/decimal v1.3.1
 )
@@ -12,7 +12,7 @@ require (
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -20,23 +20,23 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
 	github.com/paulmach/orb v0.7.1 // indirect
 	github.com/pierrec/lz4/v4 v4.1.14 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/drivers/clickhouse/go.sum b/contrib/drivers/clickhouse/go.sum
index 0994055f6..32c19a9f2 100644
--- a/contrib/drivers/clickhouse/go.sum
+++ b/contrib/drivers/clickhouse/go.sum
@@ -9,8 +9,8 @@ github.com/cloudflare/golz4 v0.0.0-20150217214814-ef862a3cdc58/go.mod h1:EOBUe0h
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -51,8 +51,9 @@ github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -63,8 +64,8 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/paulmach/orb v0.7.1 h1:Zha++Z5OX/l168sqHK3k4z18LDvr+YAO/VjK0ReQ9rU=
 github.com/paulmach/orb v0.7.1/go.mod h1:FWRlTgl88VI1RBx/MkrwWDRhQ96ctqMCh8boXhmqB/A=
 github.com/paulmach/protoscan v0.2.1/go.mod h1:SpcSwydNLrxUGSDvXvO0P7g7AuhJ7lcKfDlhJCDw2gY=
@@ -73,11 +74,10 @@ github.com/pierrec/lz4/v4 v4.1.14 h1:+fL8AQEZtz/ijeNnpduH0bROTu0O3NZAlPjQxGn8LwE
 github.com/pierrec/lz4/v4 v4.1.14/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/shirou/gopsutil v2.19.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
 github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
 github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4/go.mod h1:qsXQc7+bwAM3Q1u/4XEfrquwF8Lw7D7y5cD8CuHnfIc=
@@ -88,8 +88,8 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/tklauser/go-sysconf v0.3.10/go.mod h1:C8XykCvCb+Gn0oNCWPIlcb0RuglQTYaQ2hGm7jmxEFk=
 github.com/tklauser/numcpus v0.4.0/go.mod h1:1+UI3pD8NW14VMwdgJNJ1ESk2UnwhAnz5hMwiKKqXCQ=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -98,15 +98,17 @@ github.com/yusufpapurcu/wmi v1.2.2/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQ
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
 go.opentelemetry.io/otel v1.7.0/go.mod h1:5BdUoMIz5WEs0vt0CUEMtSSaTSHBBVwrhnz7+nrD5xk=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
 go.opentelemetry.io/otel/trace v1.7.0/go.mod h1:fzLSB9nqR2eXzxPXb2JW9IKE+ScyXA48yyE4TNvoHqU=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
@@ -118,8 +120,8 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -130,13 +132,14 @@ golang.org/x/sys v0.0.0-20191220220014-0732a990476f/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220429233432-b5fbb4746d32/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 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.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
diff --git a/contrib/drivers/dm/dm.go b/contrib/drivers/dm/dm.go
index 3bfb01cb9..6b45a51de 100644
--- a/contrib/drivers/dm/dm.go
+++ b/contrib/drivers/dm/dm.go
@@ -14,6 +14,7 @@ import (
 	"github.com/gogf/gf/v2/frame/g"
 )
 
+// Driver is the driver for dm database.
 type Driver struct {
 	*gdb.Core
 }
diff --git a/contrib/drivers/dm/dm_do_filter.go b/contrib/drivers/dm/dm_do_filter.go
index 9c1a5c578..3da1a20a0 100644
--- a/contrib/drivers/dm/dm_do_filter.go
+++ b/contrib/drivers/dm/dm_do_filter.go
@@ -20,7 +20,7 @@ func (d *Driver) DoFilter(
 	ctx context.Context, link gdb.Link, sql string, args []any,
 ) (newSql string, newArgs []any, err error) {
 	// There should be no need to capitalize, because it has been done from field processing before
-	newSql, _ = gregex.ReplaceString(`["\n\t]`, "", sql)
+	newSql, _ = gregex.ReplaceString(`["]`, "", sql)
 	newSql = gstr.ReplaceI(gstr.ReplaceI(newSql, "GROUP_CONCAT", "LISTAGG"), "SEPARATOR", ",")
 
 	// TODO The current approach is too rough. We should deal with the GROUP_CONCAT function and the
diff --git a/contrib/drivers/dm/dm_do_insert.go b/contrib/drivers/dm/dm_do_insert.go
index 1218ab900..7f0aef7b4 100644
--- a/contrib/drivers/dm/dm_do_insert.go
+++ b/contrib/drivers/dm/dm_do_insert.go
@@ -20,6 +20,7 @@ import (
 )
 
 // DoInsert inserts or updates data for given table.
+// The list parameter must contain at least one record, which was previously validated.
 func (d *Driver) DoInsert(
 	ctx context.Context, link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
 ) (result sql.Result, err error) {
@@ -28,44 +29,92 @@ func (d *Driver) DoInsert(
 		return d.doSave(ctx, link, table, list, option)
 
 	case gdb.InsertOptionReplace:
-		// TODO:: Should be Supported
-		return nil, gerror.NewCode(
-			gcode.CodeNotSupported, `Replace operation is not supported by dm driver`,
-		)
-	}
+		// dm does not support REPLACE INTO syntax, use SAVE instead.
+		return d.doSave(ctx, link, table, list, option)
 
-	return d.Core.DoInsert(ctx, link, table, list, option)
+	case gdb.InsertOptionIgnore:
+		// dm does not support INSERT IGNORE syntax, use MERGE instead.
+		return d.doInsertIgnore(ctx, link, table, list, option)
+
+	default:
+		// DM database supports IDENTITY auto-increment columns natively.
+		// The driver automatically returns LastInsertId through sql.Result.
+		//
+		// Note: DM IDENTITY columns cannot accept explicit ID values unless
+		// IDENTITY_INSERT is enabled. When using tables with IDENTITY columns,
+		// avoid providing explicit ID values in the data.
+		return d.Core.DoInsert(ctx, link, table, list, option)
+	}
 }
 
 // doSave support upsert for dm
 func (d *Driver) doSave(ctx context.Context,
 	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
 ) (result sql.Result, err error) {
-	if len(option.OnConflict) == 0 {
-		return nil, gerror.NewCode(
-			gcode.CodeMissingParameter, `Please specify conflict columns`,
-		)
-	}
+	return d.doMergeInsert(ctx, link, table, list, option, true)
+}
 
-	if len(list) == 0 {
-		return nil, gerror.NewCode(
-			gcode.CodeInvalidRequest, `Save operation list is empty by oracle driver`,
-		)
+// doInsertIgnore implements INSERT IGNORE operation using MERGE statement for DM database.
+// It only inserts records when there's no conflict on primary/unique keys.
+func (d *Driver) doInsertIgnore(ctx context.Context,
+	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
+) (result sql.Result, err error) {
+	return d.doMergeInsert(ctx, link, table, list, option, false)
+}
+
+// doMergeInsert implements MERGE-based insert operations for DM database.
+// When withUpdate is true, it performs upsert (insert or update).
+// When withUpdate is false, it performs insert ignore (insert only when no conflict).
+func (d *Driver) doMergeInsert(
+	ctx context.Context,
+	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption, withUpdate bool,
+) (result sql.Result, err error) {
+	// If OnConflict is not specified, automatically get the primary key of the table
+	conflictKeys := option.OnConflict
+	if len(conflictKeys) == 0 {
+		primaryKeys, err := d.Core.GetPrimaryKeys(ctx, table)
+		if err != nil {
+			return nil, gerror.WrapCode(
+				gcode.CodeInternalError,
+				err,
+				`failed to get primary keys for table`,
+			)
+		}
+		foundPrimaryKey := false
+		for _, primaryKey := range primaryKeys {
+			for dataKey := range list[0] {
+				if strings.EqualFold(dataKey, primaryKey) {
+					foundPrimaryKey = true
+					break
+				}
+			}
+			if foundPrimaryKey {
+				break
+			}
+		}
+		if !foundPrimaryKey {
+			return nil, gerror.NewCodef(
+				gcode.CodeMissingParameter,
+				`Replace/Save/InsertIgnore operation requires conflict detection: `+
+					`either specify OnConflict() columns or ensure table '%s' has a primary key in the data`,
+				table,
+			)
+		}
+		// TODO consider composite primary keys.
+		conflictKeys = primaryKeys
 	}
 
 	var (
-		one          = list[0]
-		oneLen       = len(one)
-		charL, charR = d.GetChars()
+		one            = list[0]
+		oneLen         = len(one)
+		charL, charR   = d.GetChars()
+		conflictKeySet = gset.NewStrSet(false)
 
-		conflictKeys   = option.OnConflict
-		conflictKeySet = gset.New(false)
-
-		// queryHolders:	Handle data with Holder that need to be upsert
-		// queryValues:		Handle data that need to be upsert
+		// queryHolders:	Handle data with Holder that need to be merged
+		// queryValues:		Handle data that need to be merged
 		// insertKeys:		Handle valid keys that need to be inserted
 		// insertValues:	Handle values that need to be inserted
-		// updateValues:	Handle values that need to be updated
+		// updateValues:	Handle values that need to be updated (only when withUpdate=true)
 		queryHolders = make([]string, oneLen)
 		queryValues  = make([]any, oneLen)
 		insertKeys   = make([]string, oneLen)
@@ -86,9 +135,9 @@ func (d *Driver) doSave(ctx context.Context,
 		insertKeys[index] = keyWithChar
 		insertValues[index] = fmt.Sprintf("T2.%s", keyWithChar)
 
-		// filter conflict keys in updateValues.
-		// And the key is not a soft created field.
-		if !(conflictKeySet.Contains(key) || d.Core.IsSoftCreatedFieldName(key)) {
+		// Build updateValues only when withUpdate is true
+		// Filter conflict keys and soft created fields from updateValues
+		if withUpdate && !(conflictKeySet.Contains(key) || d.Core.IsSoftCreatedFieldName(key)) {
 			updateValues = append(
 				updateValues,
 				fmt.Sprintf(`T1.%s = T2.%s`, keyWithChar, keyWithChar),
@@ -97,8 +146,10 @@ func (d *Driver) doSave(ctx context.Context,
 		index++
 	}
 
-	batchResult := new(gdb.SqlResult)
-	sqlStr := parseSqlForUpsert(table, queryHolders, insertKeys, insertValues, updateValues, conflictKeys)
+	var (
+		batchResult = new(gdb.SqlResult)
+		sqlStr      = parseSqlForMerge(table, queryHolders, insertKeys, insertValues, updateValues, conflictKeys)
+	)
 	r, err := d.DoExec(ctx, link, sqlStr, queryValues...)
 	if err != nil {
 		return r, err
@@ -112,40 +163,40 @@ func (d *Driver) doSave(ctx context.Context,
 	return batchResult, nil
 }
 
-// parseSqlForUpsert
-// MERGE INTO {{table}} T1
-// USING ( SELECT {{queryHolders}} FROM DUAL T2
-// ON (T1.{{duplicateKey}} = T2.{{duplicateKey}} AND ...)
-// WHEN NOT MATCHED THEN
-// INSERT {{insertKeys}} VALUES {{insertValues}}
-// WHEN MATCHED THEN
-// UPDATE SET {{updateValues}}
-func parseSqlForUpsert(table string,
+// parseSqlForMerge generates MERGE statement for DM database.
+// When updateValues is empty, it only inserts (INSERT IGNORE behavior).
+// When updateValues is provided, it performs upsert (INSERT or UPDATE).
+// Examples:
+// - INSERT IGNORE: MERGE INTO table T1 USING (...) T2 ON (...) WHEN NOT MATCHED THEN INSERT(...) VALUES (...)
+// - UPSERT: MERGE INTO table T1 USING (...) T2 ON (...) WHEN NOT MATCHED THEN INSERT(...) VALUES (...) WHEN MATCHED THEN UPDATE SET ...
+func parseSqlForMerge(table string,
 	queryHolders, insertKeys, insertValues, updateValues, duplicateKey []string,
 ) (sqlStr string) {
 	var (
 		queryHolderStr  = strings.Join(queryHolders, ",")
 		insertKeyStr    = strings.Join(insertKeys, ",")
 		insertValueStr  = strings.Join(insertValues, ",")
-		updateValueStr  = strings.Join(updateValues, ",")
 		duplicateKeyStr string
-		pattern         = gstr.Trim(`MERGE INTO %s T1 USING (SELECT %s FROM DUAL) T2 ON (%s) WHEN NOT MATCHED THEN INSERT(%s) VALUES (%s) WHEN MATCHED THEN UPDATE SET %s;`)
 	)
 
+	// Build ON condition
 	for index, keys := range duplicateKey {
 		if index != 0 {
 			duplicateKeyStr += " AND "
 		}
-		duplicateTmp := fmt.Sprintf("T1.%s = T2.%s", keys, keys)
-		duplicateKeyStr += duplicateTmp
+		duplicateKeyStr += fmt.Sprintf("T1.%s = T2.%s", keys, keys)
 	}
 
-	return fmt.Sprintf(pattern,
-		table,
-		queryHolderStr,
-		duplicateKeyStr,
-		insertKeyStr,
-		insertValueStr,
-		updateValueStr,
-	)
+	// Build SQL based on whether UPDATE is needed
+	pattern := gstr.Trim(`MERGE INTO %s T1 USING (SELECT %s FROM DUAL) T2 ON (%s) WHEN NOT MATCHED THEN INSERT(%s) VALUES (%s)`)
+	if len(updateValues) > 0 {
+		// Upsert: INSERT or UPDATE
+		pattern += gstr.Trim(`WHEN MATCHED THEN UPDATE SET %s`)
+		return fmt.Sprintf(
+			pattern, table, queryHolderStr, duplicateKeyStr, insertKeyStr, insertValueStr,
+			strings.Join(updateValues, ","),
+		)
+	}
+	// Insert Ignore: INSERT only
+	return fmt.Sprintf(pattern, table, queryHolderStr, duplicateKeyStr, insertKeyStr, insertValueStr)
 }
diff --git a/contrib/drivers/dm/dm_table_fields.go b/contrib/drivers/dm/dm_table_fields.go
index 892973d37..137047366 100644
--- a/contrib/drivers/dm/dm_table_fields.go
+++ b/contrib/drivers/dm/dm_table_fields.go
@@ -11,12 +11,21 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/gogf/gf/v2/container/gmap"
 	"github.com/gogf/gf/v2/database/gdb"
 	"github.com/gogf/gf/v2/util/gutil"
 )
 
+// escapeSingleQuote escapes single quotes in the string to prevent SQL injection.
+// In SQL, single quotes are escaped by doubling them (two single quotes).
+func escapeSingleQuote(s string) string {
+	return strings.ReplaceAll(s, "'", "''")
+}
+
 const (
-	tableFieldsSqlTmp = `SELECT * FROM ALL_TAB_COLUMNS WHERE Table_Name= '%s' AND OWNER = '%s'`
+	tableFieldsSqlTmp         = `SELECT c.COLUMN_NAME, c.DATA_TYPE, c.DATA_LENGTH, c.DATA_DEFAULT, c.NULLABLE, cc.COMMENTS FROM ALL_TAB_COLUMNS c LEFT JOIN ALL_COL_COMMENTS cc ON c.COLUMN_NAME = cc.COLUMN_NAME AND c.TABLE_NAME = cc.TABLE_NAME AND c.OWNER = cc.OWNER WHERE c.TABLE_NAME = '%s' AND c.OWNER = '%s'`
+	tableFieldsPkSqlSchemaTmp = `SELECT COLS.COLUMN_NAME AS PRIMARY_KEY_COLUMN FROM USER_CONSTRAINTS CONS JOIN USER_CONS_COLUMNS COLS ON CONS.CONSTRAINT_NAME = COLS.CONSTRAINT_NAME WHERE CONS.TABLE_NAME = '%s' AND CONS.CONSTRAINT_TYPE = 'P'`
+	tableFieldsPkSqlDBATmp    = `SELECT COLS.COLUMN_NAME AS PRIMARY_KEY_COLUMN FROM DBA_CONSTRAINTS CONS JOIN DBA_CONS_COLUMNS COLS ON CONS.CONSTRAINT_NAME = COLS.CONSTRAINT_NAME WHERE CONS.TABLE_NAME = '%s' AND CONS.OWNER = '%s' AND CONS.CONSTRAINT_TYPE = 'P'`
 )
 
 // TableFields retrieves and returns the fields' information of specified table of current schema.
@@ -24,8 +33,9 @@ func (d *Driver) TableFields(
 	ctx context.Context, table string, schema ...string,
 ) (fields map[string]*gdb.TableField, err error) {
 	var (
-		result gdb.Result
-		link   gdb.Link
+		result   gdb.Result
+		pkResult gdb.Result
+		link     gdb.Link
 		// When no schema is specified, the configuration item is returned by default
 		usedSchema = gutil.GetOrDefaultStr(d.GetSchema(), schema...)
 	)
@@ -38,14 +48,35 @@ func (d *Driver) TableFields(
 		ctx, link,
 		fmt.Sprintf(
 			tableFieldsSqlTmp,
-			strings.ToUpper(table),
-			strings.ToUpper(d.GetSchema()),
+			escapeSingleQuote(strings.ToUpper(table)),
+			escapeSingleQuote(strings.ToUpper(d.GetSchema())),
 		),
 	)
 	if err != nil {
 		return nil, err
 	}
+	// Query the primary key field
+	pkResult, err = d.DoSelect(
+		ctx, link,
+		fmt.Sprintf(tableFieldsPkSqlSchemaTmp, escapeSingleQuote(strings.ToUpper(table))),
+	)
+	if err != nil {
+		return nil, err
+	}
+	if pkResult.IsEmpty() {
+		pkResult, err = d.DoSelect(
+			ctx, link,
+			fmt.Sprintf(tableFieldsPkSqlDBATmp, escapeSingleQuote(strings.ToUpper(table)), escapeSingleQuote(strings.ToUpper(d.GetSchema()))),
+		)
+		if err != nil {
+			return nil, err
+		}
+	}
 	fields = make(map[string]*gdb.TableField)
+	pkFields := gmap.NewStrStrMap()
+	for _, pk := range pkResult {
+		pkFields.Set(pk["PRIMARY_KEY_COLUMN"].String(), "PRI")
+	}
 	for i, m := range result {
 		// m[NULLABLE] returns "N" "Y"
 		// "N" means not null
@@ -54,15 +85,29 @@ func (d *Driver) TableFields(
 		if m["NULLABLE"].String() != "N" {
 			nullable = true
 		}
+
+		// Build field type with length/precision
+		// For NUMBER(p,s): use DATA_PRECISION and DATA_SCALE
+		// For VARCHAR2/CHAR: use DATA_LENGTH
+		var (
+			fieldType  string
+			dataType   = m["DATA_TYPE"].String()
+			dataLength = m["DATA_LENGTH"].Int()
+		)
+		if dataLength > 0 {
+			fieldType = fmt.Sprintf("%s(%d)", dataType, dataLength)
+		} else {
+			fieldType = dataType
+		}
 		fields[m["COLUMN_NAME"].String()] = &gdb.TableField{
 			Index:   i,
 			Name:    m["COLUMN_NAME"].String(),
-			Type:    m["DATA_TYPE"].String(),
+			Type:    fieldType,
 			Null:    nullable,
 			Default: m["DATA_DEFAULT"].Val(),
-			// Key:     m["Key"].String(),
+			Key:     pkFields.Get(m["COLUMN_NAME"].String()),
 			// Extra:   m["Extra"].String(),
-			// Comment: m["Comment"].String(),
+			Comment: m["COMMENTS"].String(),
 		}
 	}
 	return fields, nil
diff --git a/contrib/drivers/dm/dm_z_unit_basic_test.go b/contrib/drivers/dm/dm_z_unit_basic_test.go
index 7e0f9c976..be8a53945 100644
--- a/contrib/drivers/dm/dm_z_unit_basic_test.go
+++ b/contrib/drivers/dm/dm_z_unit_basic_test.go
@@ -7,7 +7,6 @@
 package dm_test
 
 import (
-	"database/sql"
 	"fmt"
 	"strings"
 	"testing"
@@ -28,10 +27,7 @@ func Test_DB_Ping(t *testing.T) {
 }
 
 func TestTables(t *testing.T) {
-	tables := []string{"A_tables", "A_tables2"}
-	for _, v := range tables {
-		createInitTable(v)
-	}
+	tables := createInitTables(2)
 	gtest.C(t, func(t *gtest.T) {
 		result, err := db.Tables(ctx)
 		gtest.AssertNil(err)
@@ -39,7 +35,7 @@ func TestTables(t *testing.T) {
 		for i := 0; i < len(tables); i++ {
 			find := false
 			for j := 0; j < len(result); j++ {
-				if strings.ToUpper(tables[i]) == result[j] {
+				if strings.ToUpper(tables[i]) == strings.ToUpper(result[j]) {
 					find = true
 					break
 				}
@@ -52,7 +48,7 @@ func TestTables(t *testing.T) {
 		for i := 0; i < len(tables); i++ {
 			find := false
 			for j := 0; j < len(result); j++ {
-				if strings.ToUpper(tables[i]) == result[j] {
+				if strings.ToUpper(tables[i]) == strings.ToUpper(result[j]) {
 					find = true
 					break
 				}
@@ -83,17 +79,14 @@ func TestTableFields(t *testing.T) {
 	createInitTable(tables)
 	gtest.C(t, func(t *gtest.T) {
 		var expect = map[string][]any{
-			"ID":           {"BIGINT", false},
-			"ACCOUNT_NAME": {"VARCHAR", false},
-			"PWD_RESET":    {"TINYINT", false},
-			"ATTR_INDEX":   {"INT", true},
-			"DELETED":      {"INT", false},
-			"CREATED_TIME": {"TIMESTAMP", false},
+			"ID":           {"BIGINT(8)", false},
+			"ACCOUNT_NAME": {"VARCHAR(128)", false},
+			"PWD_RESET":    {"TINYINT(1)", false},
+			"ATTR_INDEX":   {"INT(4)", true},
+			"DELETED":      {"INT(4)", false},
+			"CREATED_TIME": {"TIMESTAMP(8)", false},
 		}
 
-		_, err := dbErr.TableFields(ctx, "Fields")
-		gtest.AssertNE(err, nil)
-
 		res, err := db.TableFields(ctx, tables)
 		gtest.AssertNil(err)
 
@@ -114,6 +107,14 @@ func TestTableFields(t *testing.T) {
 	})
 }
 
+func TestTableFields_WithWrongPassword(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// dbErr is configured with wrong password, so it should return an error
+		_, err := dbErr.TableFields(ctx, "Fields")
+		gtest.AssertNE(err, nil)
+	})
+}
+
 func Test_DB_Query(t *testing.T) {
 	tableName := "A_tables"
 	createInitTable(tableName)
@@ -138,110 +139,6 @@ func Test_DB_Query(t *testing.T) {
 	})
 }
 
-func TestModelSave(t *testing.T) {
-	table := createTable()
-	defer dropTable(table)
-	gtest.C(t, func(t *gtest.T) {
-		type User struct {
-			Id          int
-			AccountName string
-			AttrIndex   int
-		}
-		var (
-			user   User
-			count  int
-			result sql.Result
-			err    error
-		)
-		db.SetDebug(true)
-
-		result, err = db.Model(table).Data(g.Map{
-			"id":          1,
-			"accountName": "ac1",
-			"attrIndex":   100,
-		}).OnConflict("id").Save()
-
-		t.AssertNil(err)
-		n, _ := result.RowsAffected()
-		t.Assert(n, 1)
-
-		err = db.Model(table).Scan(&user)
-		t.AssertNil(err)
-		t.Assert(user.Id, 1)
-		t.Assert(user.AccountName, "ac1")
-		t.Assert(user.AttrIndex, 100)
-
-		_, err = db.Model(table).Data(g.Map{
-			"id":          1,
-			"accountName": "ac2",
-			"attrIndex":   200,
-		}).OnConflict("id").Save()
-		t.AssertNil(err)
-
-		err = db.Model(table).Scan(&user)
-		t.AssertNil(err)
-		t.Assert(user.AccountName, "ac2")
-		t.Assert(user.AttrIndex, 200)
-
-		count, err = db.Model(table).Count()
-		t.AssertNil(err)
-		t.Assert(count, 1)
-	})
-}
-
-func TestModelInsert(t *testing.T) {
-	// g.Model.insert not lost default not null coloumn
-	table := "A_tables"
-	createInitTable(table)
-	gtest.C(t, func(t *gtest.T) {
-		i := 200
-		data := User{
-			ID:          int64(i),
-			AccountName: fmt.Sprintf(`A%dtwo`, i),
-			PwdReset:    0,
-			AttrIndex:   99,
-			CreatedTime: time.Now(),
-			UpdatedTime: time.Now(),
-		}
-		// _, err := db.Schema(TestDBName).Model(table).Data(data).Insert()
-		_, err := db.Model(table).Insert(&data)
-		gtest.AssertNil(err)
-	})
-
-	gtest.C(t, func(t *gtest.T) {
-		i := 201
-		data := User{
-			ID:          int64(i),
-			AccountName: fmt.Sprintf(`A%dtwoONE`, i),
-			PwdReset:    1,
-			CreatedTime: time.Now(),
-			AttrIndex:   98,
-			UpdatedTime: time.Now(),
-		}
-		// _, err := db.Schema(TestDBName).Model(table).Data(data).Insert()
-		_, err := db.Model(table).Data(&data).Insert()
-		gtest.AssertNil(err)
-	})
-}
-
-func TestDBInsert(t *testing.T) {
-	table := "A_tables"
-	createInitTable("A_tables")
-	gtest.C(t, func(t *gtest.T) {
-		i := 300
-		data := g.Map{
-			"ID":           i,
-			"ACCOUNT_NAME": fmt.Sprintf(`A%dthress`, i),
-			"PWD_RESET":    3,
-			"ATTR_INDEX":   98,
-			"CREATED_TIME": gtime.Now(),
-			"UPDATED_TIME": gtime.Now(),
-		}
-		_, err := db.Insert(ctx, table, &data)
-		gtest.AssertNil(err)
-	})
-}
-
 func Test_DB_Exec(t *testing.T) {
 	createInitTable("A_tables")
 	gtest.C(t, func(t *gtest.T) {
diff --git a/contrib/drivers/dm/dm_z_unit_feature_soft_time_test.go b/contrib/drivers/dm/dm_z_unit_feature_soft_time_test.go
new file mode 100644
index 000000000..d66630f7f
--- /dev/null
+++ b/contrib/drivers/dm/dm_z_unit_feature_soft_time_test.go
@@ -0,0 +1,1400 @@
+// 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 dm_test
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+// CreateAt/UpdateAt/DeleteAt.
+func Test_SoftTime_CreateUpdateDelete1(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        INT NOT NULL,
+  name      VARCHAR(45) DEFAULT NULL,
+  create_at TIMESTAMP(6) DEFAULT NULL,
+  update_at TIMESTAMP(6) DEFAULT NULL,
+  delete_at TIMESTAMP(6) DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, 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, 1)
+
+		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, 1)
+
+		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_SoftTime_CreateUpdateDelete2(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        INT NOT NULL,
+  name      VARCHAR(45) DEFAULT NULL,
+  create_at TIMESTAMP(0) DEFAULT NULL,
+  update_at TIMESTAMP(0) DEFAULT NULL,
+  delete_at TIMESTAMP(0) DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, 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, 1)
+
+		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, 1)
+
+		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)
+	})
+}
+
+// CreatedAt/UpdatedAt/DeletedAt.
+func Test_SoftTime_CreatedUpdatedDeleted_Map(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id         INT NOT NULL,
+  name       VARCHAR(45) DEFAULT NULL,
+  created_at TIMESTAMP(6) DEFAULT NULL,
+  updated_at TIMESTAMP(6) DEFAULT NULL,
+  deleted_at TIMESTAMP(6) DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, 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["DELETED_AT"].String(), "")
+		t.AssertGE(oneInsert["CREATED_AT"].GTime().Timestamp(), gtime.Timestamp()-2)
+		t.AssertGE(oneInsert["UPDATED_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, 1)
+
+		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["DELETED_AT"].String(), "")
+		t.Assert(oneSave["CREATED_AT"].GTime().Timestamp(), oneInsert["CREATED_AT"].GTime().Timestamp())
+		t.AssertNE(oneSave["UPDATED_AT"].GTime().Timestamp(), oneInsert["UPDATED_AT"].GTime().Timestamp())
+		t.AssertGE(oneSave["UPDATED_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["DELETED_AT"].String(), "")
+		t.Assert(oneUpdate["CREATED_AT"].GTime().Timestamp(), oneInsert["CREATED_AT"].GTime().Timestamp())
+		t.AssertGE(oneUpdate["UPDATED_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, 1)
+
+		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["DELETED_AT"].String(), "")
+		t.AssertGE(oneReplace["CREATED_AT"].GTime().Timestamp(), oneInsert["CREATED_AT"].GTime().Timestamp())
+		t.AssertGE(oneReplace["UPDATED_AT"].GTime().Timestamp(), oneInsert["UPDATED_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["DELETED_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)
+	})
+}
+
+// CreatedAt/UpdatedAt/DeletedAt.
+func Test_SoftTime_CreatedUpdatedDeleted_Struct(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id         INT NOT NULL,
+  name       VARCHAR(45) DEFAULT NULL,
+  created_at TIMESTAMP(6) DEFAULT NULL,
+  updated_at TIMESTAMP(6) DEFAULT NULL,
+  deleted_at TIMESTAMP(6) DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, table)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table)
+
+	type User struct {
+		Id        int
+		Name      string
+		CreatedAT *gtime.Time
+		UpdatedAT *gtime.Time
+		DeletedAT *gtime.Time
+	}
+	gtest.C(t, func(t *gtest.T) {
+		// Insert
+		dataInsert := User{
+			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["DELETED_AT"].String(), "")
+		t.AssertGE(oneInsert["CREATED_AT"].GTime().Timestamp(), gtime.Timestamp()-2)
+		t.AssertGE(oneInsert["UPDATED_AT"].GTime().Timestamp(), gtime.Timestamp()-2)
+
+		// For time asserting purpose.
+		time.Sleep(2 * time.Second)
+
+		// Save
+		dataSave := User{
+			Id:   1,
+			Name: "name_10",
+		}
+		r, err = db.Model(table).Data(dataSave).OmitEmpty().Save()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+
+		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["DELETED_AT"].String(), "")
+		t.Assert(oneSave["CREATED_AT"].GTime().Timestamp(), oneInsert["CREATED_AT"].GTime().Timestamp())
+		t.AssertNE(oneSave["UPDATED_AT"].GTime().Timestamp(), oneInsert["UPDATED_AT"].GTime().Timestamp())
+		t.AssertGE(oneSave["UPDATED_AT"].GTime().Timestamp(), gtime.Timestamp()-2)
+
+		// For time asserting purpose.
+		time.Sleep(2 * time.Second)
+
+		// Update
+		dataUpdate := User{
+			Name: "name_1000",
+		}
+		r, err = db.Model(table).Data(dataUpdate).OmitEmpty().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["DELETED_AT"].String(), "")
+		t.Assert(oneUpdate["CREATED_AT"].GTime().Timestamp(), oneInsert["CREATED_AT"].GTime().Timestamp())
+		t.AssertGE(oneUpdate["UPDATED_AT"].GTime().Timestamp(), gtime.Timestamp()-4)
+
+		// Replace
+		dataReplace := User{
+			Id:   1,
+			Name: "name_100",
+		}
+		r, err = db.Model(table).Data(dataReplace).OmitEmpty().Replace()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+
+		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["DELETED_AT"].String(), "")
+		t.AssertGE(oneReplace["CREATED_AT"].GTime().Timestamp(), oneInsert["CREATED_AT"].GTime().Timestamp())
+		t.AssertGE(oneReplace["UPDATED_AT"].GTime().Timestamp(), oneInsert["UPDATED_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["DELETED_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)
+	})
+}
+
+func Test_SoftUpdateTime(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        INT NOT NULL,
+  num       INT DEFAULT NULL,
+  create_at TIMESTAMP(6) DEFAULT NULL,
+  update_at TIMESTAMP(6) DEFAULT NULL,
+  delete_at TIMESTAMP(6) DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, table)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert
+		dataInsert := g.Map{
+			"id":  1,
+			"num": 10,
+		}
+		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["NUM"].Int(), 10)
+
+		// Update.
+		r, err = db.Model(table).Data("num=num+1").Where("id=?", 1).Update()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+	})
+}
+
+func Test_SoftUpdateTime_WithDO(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id         INT NOT NULL,
+  num        INT DEFAULT NULL,
+  created_at TIMESTAMP(6) DEFAULT NULL,
+  updated_at TIMESTAMP(6) DEFAULT NULL,
+  deleted_at TIMESTAMP(6) DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, table)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert
+		dataInsert := g.Map{
+			"id":  1,
+			"num": 10,
+		}
+		r, err := db.Model(table).Data(dataInsert).Insert()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 1)
+
+		oneInserted, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(oneInserted["ID"].Int(), 1)
+		t.Assert(oneInserted["NUM"].Int(), 10)
+
+		// Update.
+		time.Sleep(2 * time.Second)
+		type User struct {
+			g.Meta    `orm:"do:true"`
+			Id        any
+			Num       any
+			CreatedAt any
+			UpdatedAt any
+			DeletedAt any
+		}
+		r, err = db.Model(table).Data(User{
+			Num: 100,
+		}).Where("id=?", 1).Update()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+
+		oneUpdated, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(oneUpdated["NUM"].Int(), 100)
+		t.Assert(oneUpdated["CREATED_AT"].String(), oneInserted["CREATED_AT"].String())
+		t.AssertNE(oneUpdated["UPDATED_AT"].String(), oneInserted["UPDATED_AT"].String())
+	})
+}
+
+func Test_SoftDelete(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        INT NOT NULL,
+  name      VARCHAR(45) DEFAULT NULL,
+  create_at TIMESTAMP(6) DEFAULT NULL,
+  update_at TIMESTAMP(6) DEFAULT NULL,
+  delete_at TIMESTAMP(6) DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, table)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table)
+	// db.SetDebug(true)
+	gtest.C(t, func(t *gtest.T) {
+		for i := 1; i <= 10; i++ {
+			data := g.Map{
+				"id":   i,
+				"name": fmt.Sprintf("name_%d", i),
+			}
+			r, err := db.Model(table).Data(data).Insert()
+			t.AssertNil(err)
+			n, _ := r.RowsAffected()
+			t.Assert(n, 1)
+		}
+	})
+	gtest.C(t, func(t *gtest.T) {
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.AssertNE(one["CREATE_AT"].String(), "")
+		t.AssertNE(one["UPDATE_AT"].String(), "")
+		t.Assert(one["DELETE_AT"].String(), "")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		one, err := db.Model(table).WherePri(10).One()
+		t.AssertNil(err)
+		t.AssertNE(one["CREATE_AT"].String(), "")
+		t.AssertNE(one["UPDATE_AT"].String(), "")
+		t.Assert(one["DELETE_AT"].String(), "")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		ids := g.SliceInt{1, 3, 5}
+		r, err := db.Model(table).Where("id", ids).Delete()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 3)
+
+		count, err := db.Model(table).Where("id", ids).Count()
+		t.AssertNil(err)
+		t.Assert(count, 0)
+
+		all, err := db.Model(table).Unscoped().Where("id", ids).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 3)
+		t.AssertNE(all[0]["CREATE_AT"].String(), "")
+		t.AssertNE(all[0]["UPDATE_AT"].String(), "")
+		t.AssertNE(all[0]["DELETE_AT"].String(), "")
+		t.AssertNE(all[1]["CREATE_AT"].String(), "")
+		t.AssertNE(all[1]["UPDATE_AT"].String(), "")
+		t.AssertNE(all[1]["DELETE_AT"].String(), "")
+		t.AssertNE(all[2]["CREATE_AT"].String(), "")
+		t.AssertNE(all[2]["UPDATE_AT"].String(), "")
+		t.AssertNE(all[2]["DELETE_AT"].String(), "")
+	})
+}
+
+func Test_SoftDelete_Join(t *testing.T) {
+	table1 := "time_test_table1"
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        INT NOT NULL,
+  name      VARCHAR(45) DEFAULT NULL,
+  create_at TIMESTAMP(6) DEFAULT NULL,
+  update_at TIMESTAMP(6) DEFAULT NULL,
+  delete_at TIMESTAMP(6) DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, table1)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table1)
+
+	table2 := "time_test_table2"
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id       INT NOT NULL,
+  name     VARCHAR(45) DEFAULT NULL,
+  createat TIMESTAMP(6) DEFAULT NULL,
+  updateat TIMESTAMP(6) DEFAULT NULL,
+  deleteat TIMESTAMP(6) DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, table2)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table2)
+
+	gtest.C(t, func(t *gtest.T) {
+		// db.SetDebug(true)
+		dataInsert1 := g.Map{
+			"id":   1,
+			"name": "name_1",
+		}
+		r, err := db.Model(table1).Data(dataInsert1).Insert()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 1)
+
+		dataInsert2 := g.Map{
+			"id":   1,
+			"name": "name_2",
+		}
+		r, err = db.Model(table2).Data(dataInsert2).Insert()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+
+		one, err := db.Model(table1, "t1").LeftJoin(table2, "t2", "t2.id=t1.id").Fields("t1.name").One()
+		t.AssertNil(err)
+		t.Assert(one["NAME"], "name_1")
+
+		// Soft deleting.
+		r, err = db.Model(table1).Where(1).Delete()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+
+		one, err = db.Model(table1, "t1").LeftJoin(table2, "t2", "t2.id=t1.id").Fields("t1.name").One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), true)
+
+		one, err = db.Model(table2, "t2").LeftJoin(table1, "t1", "t2.id=t1.id").Fields("t2.name").One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), true)
+	})
+}
+
+func Test_SoftDelete_WhereAndOr(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        INT NOT NULL,
+  name      VARCHAR(45) DEFAULT NULL,
+  create_at TIMESTAMP(6) DEFAULT NULL,
+  update_at TIMESTAMP(6) DEFAULT NULL,
+  delete_at TIMESTAMP(6) DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, table)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table)
+	// db.SetDebug(true)
+	// Add datas.
+	gtest.C(t, func(t *gtest.T) {
+		for i := 1; i <= 10; i++ {
+			data := g.Map{
+				"id":   i,
+				"name": fmt.Sprintf("name_%d", i),
+			}
+			r, err := db.Model(table).Data(data).Insert()
+			t.AssertNil(err)
+			n, _ := r.RowsAffected()
+			t.Assert(n, 1)
+		}
+	})
+	gtest.C(t, func(t *gtest.T) {
+		ids := g.SliceInt{1, 3, 5}
+		r, err := db.Model(table).Where("id", ids).Delete()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 3)
+
+		count, err := db.Model(table).Where("id", 1).WhereOr("id", 3).Count()
+		t.AssertNil(err)
+		t.Assert(count, 0)
+	})
+}
+
+func Test_CreateUpdateTime_Struct(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        INT NOT NULL,
+  name      VARCHAR(45) DEFAULT NULL,
+  create_at TIMESTAMP(6) DEFAULT NULL,
+  update_at TIMESTAMP(6) DEFAULT NULL,
+  delete_at TIMESTAMP(6) DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, table)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table)
+
+	// db.SetDebug(true)
+	// defer db.SetDebug(false)
+
+	type Entity struct {
+		Id       uint64      `orm:"id,primary" json:"id"`
+		Name     string      `orm:"name"       json:"name"`
+		CreateAt *gtime.Time `orm:"create_at"  json:"create_at"`
+		UpdateAt *gtime.Time `orm:"update_at"  json:"update_at"`
+		DeleteAt *gtime.Time `orm:"delete_at"  json:"delete_at"`
+	}
+	gtest.C(t, func(t *gtest.T) {
+		// Insert
+		dataInsert := &Entity{
+			Id:       1,
+			Name:     "name_1",
+			CreateAt: nil,
+			UpdateAt: nil,
+			DeleteAt: nil,
+		}
+		r, err := db.Model(table).Data(dataInsert).OmitEmpty().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)
+
+		time.Sleep(2 * time.Second)
+
+		// Save
+		dataSave := &Entity{
+			Id:       1,
+			Name:     "name_10",
+			CreateAt: nil,
+			UpdateAt: nil,
+			DeleteAt: nil,
+		}
+		r, err = db.Model(table).Data(dataSave).OmitEmpty().Save()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+
+		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)
+
+		time.Sleep(2 * time.Second)
+
+		// Update
+		dataUpdate := &Entity{
+			Id:       1,
+			Name:     "name_1000",
+			CreateAt: nil,
+			UpdateAt: nil,
+			DeleteAt: nil,
+		}
+		r, err = db.Model(table).Data(dataUpdate).WherePri(1).OmitEmpty().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 := &Entity{
+			Id:       1,
+			Name:     "name_100",
+			CreateAt: nil,
+			UpdateAt: nil,
+			DeleteAt: nil,
+		}
+		r, err = db.Model(table).Data(dataReplace).OmitEmpty().Replace()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+
+		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())
+
+		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)
+	})
+}
+
+func Test_SoftTime_CreateUpdateDelete_UnixTimestamp(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        INT NOT NULL,
+  name      VARCHAR(45) DEFAULT NULL,
+  create_at INT DEFAULT NULL,
+  update_at INT DEFAULT NULL,
+  delete_at INT DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, table)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table)
+
+	// insert
+	gtest.C(t, func(t *gtest.T) {
+		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)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["NAME"].String(), "name_1")
+		t.AssertGT(one["CREATE_AT"].Int64(), 0)
+		t.AssertGT(one["UPDATE_AT"].Int64(), 0)
+		t.Assert(one["DELETE_AT"].Int64(), 0)
+		t.Assert(len(one["CREATE_AT"].String()), 10)
+		t.Assert(len(one["UPDATE_AT"].String()), 10)
+	})
+
+	// sleep some seconds to make update time greater than create time.
+	time.Sleep(2 * time.Second)
+
+	// update
+	gtest.C(t, func(t *gtest.T) {
+		// update: map
+		dataInsert := g.Map{
+			"name": "name_11",
+		}
+		r, err := db.Model(table).Data(dataInsert).WherePri(1).Update()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 1)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["NAME"].String(), "name_11")
+		t.AssertGT(one["CREATE_AT"].Int64(), 0)
+		t.AssertGT(one["UPDATE_AT"].Int64(), 0)
+		t.Assert(one["DELETE_AT"].Int64(), 0)
+		t.Assert(len(one["CREATE_AT"].String()), 10)
+		t.Assert(len(one["UPDATE_AT"].String()), 10)
+
+		var (
+			lastCreateTime = one["CREATE_AT"].Int64()
+			lastUpdateTime = one["UPDATE_AT"].Int64()
+		)
+
+		time.Sleep(2 * time.Second)
+
+		// update: string
+		r, err = db.Model(table).Data("name='name_111'").WherePri(1).Update()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+
+		one, err = db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["NAME"].String(), "name_111")
+		t.Assert(one["CREATE_AT"].Int64(), lastCreateTime)
+		t.AssertGT(one["UPDATE_AT"].Int64(), lastUpdateTime)
+		t.Assert(one["DELETE_AT"].Int64(), 0)
+	})
+
+	// delete
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.Model(table).WherePri(1).Delete()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 1)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(len(one), 0)
+
+		one, err = db.Model(table).Unscoped().WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["NAME"].String(), "name_111")
+		t.AssertGT(one["CREATE_AT"].Int64(), 0)
+		t.AssertGT(one["UPDATE_AT"].Int64(), 0)
+		t.AssertGT(one["DELETE_AT"].Int64(), 0)
+	})
+}
+
+func Test_SoftTime_CreateUpdateDelete_Bool_Deleted(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	// do not use BIT(1) but use BIT in dm database as bool type.
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        INT NOT NULL,
+  name      VARCHAR(45) DEFAULT NULL,
+  create_at INT DEFAULT NULL,
+  update_at INT DEFAULT NULL,
+  delete_at BIT DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, table)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table)
+
+	// db.SetDebug(true)
+	// insert
+	gtest.C(t, func(t *gtest.T) {
+		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)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["NAME"].String(), "name_1")
+		t.AssertGT(one["CREATE_AT"].Int64(), 0)
+		t.AssertGT(one["UPDATE_AT"].Int64(), 0)
+		t.Assert(one["DELETE_AT"].Int64(), 0)
+		t.Assert(len(one["CREATE_AT"].String()), 10)
+		t.Assert(len(one["UPDATE_AT"].String()), 10)
+	})
+
+	// delete
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.Model(table).WherePri(1).Delete()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 1)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(len(one), 0)
+
+		one, err = db.Model(table).Unscoped().WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["NAME"].String(), "name_1")
+		t.AssertGT(one["CREATE_AT"].Int64(), 0)
+		t.AssertGT(one["UPDATE_AT"].Int64(), 0)
+		t.Assert(one["DELETE_AT"].Int64(), 1)
+	})
+}
+
+func Test_SoftTime_CreateUpdateDelete_Option_SoftTimeTypeTimestampMilli(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        INT NOT NULL,
+  name      VARCHAR(45) DEFAULT NULL,
+  create_at BIGINT DEFAULT NULL,
+  update_at BIGINT DEFAULT NULL,
+  delete_at BIT DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, table)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table)
+
+	var softTimeOption = gdb.SoftTimeOption{
+		SoftTimeType: gdb.SoftTimeTypeTimestampMilli,
+	}
+
+	// insert
+	gtest.C(t, func(t *gtest.T) {
+		dataInsert := g.Map{
+			"id":   1,
+			"name": "name_1",
+		}
+		r, err := db.Model(table).SoftTime(softTimeOption).Data(dataInsert).Insert()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 1)
+
+		one, err := db.Model(table).SoftTime(softTimeOption).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["NAME"].String(), "name_1")
+		t.Assert(len(one["CREATE_AT"].String()), 13)
+		t.Assert(len(one["UPDATE_AT"].String()), 13)
+		t.Assert(one["DELETE_AT"].Int64(), 0)
+	})
+
+	// delete
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.Model(table).SoftTime(softTimeOption).WherePri(1).Delete()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 1)
+
+		one, err := db.Model(table).SoftTime(softTimeOption).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(len(one), 0)
+
+		one, err = db.Model(table).Unscoped().WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["NAME"].String(), "name_1")
+		t.AssertGT(one["CREATE_AT"].Int64(), 0)
+		t.AssertGT(one["UPDATE_AT"].Int64(), 0)
+		t.Assert(one["DELETE_AT"].Int64(), 1)
+	})
+}
+
+func Test_SoftTime_CreateUpdateDelete_Option_SoftTimeTypeTimestampNano(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        INT NOT NULL,
+  name      VARCHAR(45) DEFAULT NULL,
+  create_at BIGINT DEFAULT NULL,
+  update_at BIGINT DEFAULT NULL,
+  delete_at BIT DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, table)); err != nil {
+		gtest.Error(err)
+	}
+	defer dropTable(table)
+
+	var softTimeOption = gdb.SoftTimeOption{
+		SoftTimeType: gdb.SoftTimeTypeTimestampNano,
+	}
+
+	// insert
+	gtest.C(t, func(t *gtest.T) {
+		dataInsert := g.Map{
+			"id":   1,
+			"name": "name_1",
+		}
+		r, err := db.Model(table).SoftTime(softTimeOption).Data(dataInsert).Insert()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 1)
+
+		one, err := db.Model(table).SoftTime(softTimeOption).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["NAME"].String(), "name_1")
+		t.Assert(len(one["CREATE_AT"].String()), 19)
+		t.Assert(len(one["UPDATE_AT"].String()), 19)
+		t.Assert(one["DELETE_AT"].Int64(), 0)
+	})
+
+	// delete
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.Model(table).SoftTime(softTimeOption).WherePri(1).Delete()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 1)
+
+		one, err := db.Model(table).SoftTime(softTimeOption).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(len(one), 0)
+
+		one, err = db.Model(table).Unscoped().WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["NAME"].String(), "name_1")
+		t.AssertGT(one["CREATE_AT"].Int64(), 0)
+		t.AssertGT(one["UPDATE_AT"].Int64(), 0)
+		t.Assert(one["DELETE_AT"].Int64(), 1)
+	})
+}
+
+func Test_SoftTime_CreateUpdateDelete_Specified(t *testing.T) {
+	table := "soft_time_test_table_" + gtime.TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+CREATE TABLE %s (
+  id        INT NOT NULL,
+  name      VARCHAR(45) DEFAULT NULL,
+  create_at TIMESTAMP(0) DEFAULT NULL,
+  update_at TIMESTAMP(0) DEFAULT NULL,
+  delete_at TIMESTAMP(0) DEFAULT NULL,
+  PRIMARY KEY (id)
+);
+    `, 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",
+			"create_at": gtime.NewFromStr("2024-05-30 20:00:00"),
+			"update_at": gtime.NewFromStr("2024-05-30 20:00:00"),
+		}
+		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.Assert(oneInsert["CREATE_AT"].String(), "2024-05-30 20:00:00")
+		t.Assert(oneInsert["UPDATE_AT"].String(), "2024-05-30 20:00:00")
+
+		// For time asserting purpose.
+		time.Sleep(2 * time.Second)
+
+		// Save
+		dataSave := g.Map{
+			"id":        1,
+			"name":      "name_10",
+			"update_at": gtime.NewFromStr("2024-05-30 20:15:00"),
+		}
+		r, err = db.Model(table).Data(dataSave).Save()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+
+		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"].String(), "2024-05-30 20:00:00")
+		t.Assert(oneSave["UPDATE_AT"].String(), "2024-05-30 20:15:00")
+
+		// For time asserting purpose.
+		time.Sleep(2 * time.Second)
+
+		// Update
+		dataUpdate := g.Map{
+			"name":      "name_1000",
+			"update_at": gtime.NewFromStr("2024-05-30 20:30:00"),
+		}
+		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"].String(), "2024-05-30 20:00:00")
+		t.Assert(oneUpdate["UPDATE_AT"].String(), "2024-05-30 20:30:00")
+
+		// Replace
+		dataReplace := g.Map{
+			"id":        1,
+			"name":      "name_100",
+			"create_at": gtime.NewFromStr("2024-05-30 21:00:00"),
+			"update_at": gtime.NewFromStr("2024-05-30 21:00:00"),
+		}
+		r, err = db.Model(table).Data(dataReplace).Replace()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+
+		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)
+
+		// Insert with delete_at
+		dataInsertDelete := g.Map{
+			"id":        2,
+			"name":      "name_2",
+			"create_at": gtime.NewFromStr("2024-05-30 20:00:00"),
+			"update_at": gtime.NewFromStr("2024-05-30 20:00:00"),
+			"delete_at": gtime.NewFromStr("2024-05-30 20:00:00"),
+		}
+		r, err = db.Model(table).Data(dataInsertDelete).Insert()
+		t.AssertNil(err)
+		n, _ = r.RowsAffected()
+		t.Assert(n, 1)
+
+		// Delete Select
+		oneDelete, err := db.Model(table).WherePri(2).One()
+		t.AssertNil(err)
+		t.Assert(len(oneDelete), 0)
+		oneDeleteUnscoped, err := db.Model(table).Unscoped().WherePri(2).One()
+		t.AssertNil(err)
+		t.Assert(oneDeleteUnscoped["ID"].Int(), 2)
+		t.Assert(oneDeleteUnscoped["NAME"].String(), "name_2")
+		t.Assert(oneDeleteUnscoped["DELETE_AT"].String(), "2024-05-30 20:00:00")
+		t.Assert(oneDeleteUnscoped["CREATE_AT"].String(), "2024-05-30 20:00:00")
+		t.Assert(oneDeleteUnscoped["UPDATE_AT"].String(), "2024-05-30 20:00:00")
+	})
+}
diff --git a/contrib/drivers/dm/dm_z_unit_init_test.go b/contrib/drivers/dm/dm_z_unit_init_test.go
index 5d81f649a..30c8aca85 100644
--- a/contrib/drivers/dm/dm_z_unit_init_test.go
+++ b/contrib/drivers/dm/dm_z_unit_init_test.go
@@ -63,11 +63,10 @@ func init() {
 		Weight:           1,
 		MaxIdleConnCount: 10,
 		MaxOpenConnCount: 10,
-		CreatedAt:        "created_time",
-		UpdatedAt:        "updated_time",
+		// CreatedAt:        "created_time",
+		// UpdatedAt:        "updated_time",
 	}
 
-	// todo
 	nodeLink := gdb.ConfigNode{
 		Type: TestDBType,
 		Name: TestDBName,
@@ -111,6 +110,8 @@ func init() {
 	}
 
 	ctx = context.Background()
+
+	// db.SetDebug(true)
 }
 
 func dropTable(table string) {
@@ -143,7 +144,7 @@ func createTable(table ...string) (name string) {
 	CREATE TABLE "%s"
 (
 "ID" BIGINT NOT NULL,
-"ACCOUNT_NAME" VARCHAR(128) DEFAULT '' NOT NULL,
+"ACCOUNT_NAME" VARCHAR(128) DEFAULT '' NOT NULL COMMENT 'Account Name',
 "PWD_RESET" TINYINT DEFAULT 0 NOT NULL,
 "ENABLED" INT DEFAULT 1 NOT NULL,
 "DELETED" INT DEFAULT 0 NOT NULL,
@@ -156,7 +157,6 @@ NOT CLUSTER PRIMARY KEY("ID")) STORAGE(ON "MAIN", CLUSTERBTR) ;
 	`, name)); err != nil {
 		gtest.Fatal(err)
 	}
-
 	return
 }
 
@@ -169,7 +169,7 @@ func createInitTable(table ...string) (name string) {
 			"account_name": fmt.Sprintf(`name_%d`, i),
 			"pwd_reset":    0,
 			"attr_index":   i,
-			"create_time":  gtime.Now().String(),
+			"created_time": gtime.Now(),
 		})
 	}
 	result, err := db.Schema(TestDBName).Insert(context.Background(), name, array.Slice())
@@ -212,3 +212,41 @@ NOT CLUSTER PRIMARY KEY("ID")) STORAGE(ON "MAIN", CLUSTERBTR) ;
 
 	return name, nil
 }
+
+func createInitTables(len int) []string {
+	tables := make([]string, 0, len)
+	for range len {
+		tables = append(tables, createInitTable())
+	}
+	return tables
+}
+
+// createTableWithIdentity creates a table with IDENTITY column for LastInsertId testing
+func createTableWithIdentity(table ...string) (name string) {
+	if len(table) > 0 {
+		name = table[0]
+	} else {
+		name = fmt.Sprintf("random_%d", gtime.Timestamp())
+	}
+
+	dropTable(name)
+
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+	CREATE TABLE "%s"
+(
+"ID" BIGINT IDENTITY(1, 1) NOT NULL,
+"ACCOUNT_NAME" VARCHAR(128) DEFAULT '' NOT NULL COMMENT 'Account Name',
+"PWD_RESET" TINYINT DEFAULT 0 NOT NULL,
+"ENABLED" INT DEFAULT 1 NOT NULL,
+"DELETED" INT DEFAULT 0 NOT NULL,
+"ATTR_INDEX" INT DEFAULT 0 ,
+"CREATED_BY" VARCHAR(32) DEFAULT '' NOT NULL,
+"CREATED_TIME" TIMESTAMP(6) DEFAULT CURRENT_TIMESTAMP() NOT NULL,
+"UPDATED_BY" VARCHAR(32) DEFAULT '' 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)
+	}
+	return
+}
diff --git a/contrib/drivers/dm/dm_z_unit_issue_test.go b/contrib/drivers/dm/dm_z_unit_issue_test.go
index fece6a618..18497c6cc 100644
--- a/contrib/drivers/dm/dm_z_unit_issue_test.go
+++ b/contrib/drivers/dm/dm_z_unit_issue_test.go
@@ -71,3 +71,93 @@ func Test_Issue2594(t *testing.T) {
 		t.Assert(h1, h2)
 	})
 }
+
+// Test_MultilineSQLStatement tests that multi-line SQL statements are properly supported.
+// This test verifies that newlines and tabs in SQL queries are preserved,
+// which is essential for readability and proper SQL statement handling.
+func Test_MultilineSQLStatement(t *testing.T) {
+	table := "A_tables"
+	createInitTable(table)
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test multi-line SELECT statement with newlines and indentation
+		multilineSql := `
+		SELECT 
+			id,
+			account_name,
+			attr_index
+		FROM A_tables
+		WHERE id = ?
+		AND account_name = ?
+		`
+		result, err := db.GetAll(ctx, multilineSql, 1, "name_1")
+		t.AssertNil(err)
+		t.Assert(len(result), 1)
+		t.Assert(result[0]["ID"].Int(), 1)
+		t.Assert(result[0]["ACCOUNT_NAME"].String(), "name_1")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test multi-line SELECT with tabs
+		multilineSql := `SELECT
+			id,
+			account_name,
+			attr_index
+		FROM A_tables
+		WHERE id IN (?, ?)
+		ORDER BY id`
+		result, err := db.GetAll(ctx, multilineSql, 2, 3)
+		t.AssertNil(err)
+		t.Assert(len(result), 2)
+		t.Assert(result[0]["ID"].Int(), 2)
+		t.Assert(result[1]["ID"].Int(), 3)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test that newlines in values don't cause issues
+		multilineSql := `
+		SELECT * 
+		FROM A_tables 
+		WHERE id = ?`
+		result, err := db.GetAll(ctx, multilineSql, 5)
+		t.AssertNil(err)
+		t.Assert(len(result), 1)
+		t.Assert(result[0]["ID"].Int(), 5)
+		t.Assert(result[0]["ACCOUNT_NAME"].String(), "name_5")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test multi-line INSERT with newlines
+		multilineSql := `
+		INSERT INTO A_tables
+		(ID, ACCOUNT_NAME, ATTR_INDEX, CREATED_TIME, UPDATED_TIME)
+		VALUES
+		(?, ?, ?, ?, ?)`
+		_, err := db.Exec(ctx, multilineSql, 1001, "multiline_insert_test", 100, gtime.Now(), gtime.Now())
+		t.AssertNil(err)
+
+		// Verify the insert worked
+		result, err := db.GetAll(ctx, "SELECT * FROM A_tables WHERE ID = ?", 1001)
+		t.AssertNil(err)
+		t.Assert(len(result), 1)
+		t.Assert(result[0]["ACCOUNT_NAME"].String(), "multiline_insert_test")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test multi-line UPDATE with newlines
+		multilineSql := `
+		UPDATE A_tables
+		SET account_name = ?,
+			attr_index = ?
+		WHERE id = ?`
+		_, err := db.Exec(ctx, multilineSql, "updated_multiline", 999, 1)
+		t.AssertNil(err)
+
+		// Verify the update worked
+		result, err := db.GetAll(ctx, "SELECT * FROM A_tables WHERE ID = ?", 1)
+		t.AssertNil(err)
+		t.Assert(len(result), 1)
+		t.Assert(result[0]["ACCOUNT_NAME"].String(), "updated_multiline")
+	})
+}
diff --git a/contrib/drivers/dm/dm_z_unit_model_test.go b/contrib/drivers/dm/dm_z_unit_model_test.go
new file mode 100644
index 000000000..80f04010b
--- /dev/null
+++ b/contrib/drivers/dm/dm_z_unit_model_test.go
@@ -0,0 +1,185 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package dm_test
+
+import (
+	"database/sql"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_Model_Save(t *testing.T) {
+	table := createTableWithIdentity()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id          int
+			AccountName string
+			AttrIndex   int
+		}
+		var (
+			user   User
+			count  int
+			result sql.Result
+			err    error
+		)
+
+		// First insert: let IDENTITY auto-generate ID - use Insert() instead of Save()
+		// because Save() requires a primary key in the data for conflict detection
+		result, err = db.Model(table).Data(g.Map{
+			"accountName": "ac1",
+			"attrIndex":   100,
+		}).Insert()
+
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+
+		err = db.Model(table).Scan(&user)
+		t.AssertNil(err)
+		t.AssertGT(user.Id, 0) // ID should be auto-generated
+		t.Assert(user.AccountName, "ac1")
+		t.Assert(user.AttrIndex, 100)
+
+		// Second save: update the existing record using the generated ID
+		_, err = db.Model(table).Data(g.Map{
+			"id":          user.Id,
+			"accountName": "ac2",
+			"attrIndex":   200,
+		}).OnConflict("id").Save()
+		t.AssertNil(err)
+
+		err = db.Model(table).Scan(&user)
+		t.AssertNil(err)
+		t.Assert(user.AccountName, "ac2")
+		t.Assert(user.AttrIndex, 200)
+
+		_, err = db.Model(table).Data(g.Map{
+			"id":          user.Id,
+			"accountName": "ac2",
+			"attrIndex":   2000,
+		}).Save()
+		t.AssertNil(err)
+
+		err = db.Model(table).Scan(&user)
+		t.AssertNil(err)
+		t.Assert(user.AccountName, "ac2")
+		t.Assert(user.AttrIndex, 2000)
+
+		count, err = db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, 1)
+	})
+}
+
+func Test_Model_Insert(t *testing.T) {
+	// g.Model.insert not lost default not null column
+	table := "A_tables"
+	createInitTable(table)
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		i := 200
+		data := User{
+			ID:          int64(i),
+			AccountName: fmt.Sprintf(`A%dtwo`, i),
+			PwdReset:    0,
+			AttrIndex:   99,
+			CreatedTime: time.Now(),
+			UpdatedTime: time.Now(),
+		}
+		result, err := db.Model(table).Insert(&data)
+		gtest.AssertNil(err)
+		n, err := result.RowsAffected()
+		gtest.AssertNil(err)
+		gtest.Assert(n, 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		i := 201
+		data := User{
+			ID:          int64(i),
+			AccountName: fmt.Sprintf(`A%dtwoONE`, i),
+			PwdReset:    1,
+			CreatedTime: time.Now(),
+			AttrIndex:   98,
+			UpdatedTime: time.Now(),
+		}
+		result, err := db.Model(table).Data(&data).Insert()
+		gtest.AssertNil(err)
+		n, err := result.RowsAffected()
+		gtest.AssertNil(err)
+		gtest.Assert(n, 1)
+	})
+}
+
+func Test_Model_InsertIgnore(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	// db.SetDebug(true)
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":           1,
+			"account_name": fmt.Sprintf(`name_%d`, 777),
+			"pwd_reset":    0,
+			"attr_index":   777,
+			"created_time": gtime.Now(),
+		}
+		_, err := db.Model(table).Data(data).InsertIgnore()
+		t.AssertNil(err)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["ACCOUNT_NAME"].String(), "name_1")
+
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, TableSize)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			// "id":           1,
+			"account_name": fmt.Sprintf(`name_%d`, 777),
+			"pwd_reset":    0,
+			"attr_index":   777,
+			"created_time": gtime.Now(),
+		}
+		_, err := db.Model(table).Data(data).InsertIgnore()
+		t.AssertNE(err, nil)
+
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, TableSize)
+	})
+}
+
+func Test_Model_InsertAndGetId(t *testing.T) {
+	table := createTableWithIdentity()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			// "id":          1,
+			"account_name": fmt.Sprintf(`name_%d`, 1),
+			"pwd_reset":    0,
+			"attr_index":   1,
+			"created_time": gtime.Now(),
+		}
+		lastId, err := db.Model(table).Data(data).InsertAndGetId()
+		t.AssertNil(err)
+		t.AssertGT(lastId, 0)
+	})
+
+}
diff --git a/contrib/drivers/dm/dm_z_unit_pr_test.go b/contrib/drivers/dm/dm_z_unit_pr_test.go
new file mode 100644
index 000000000..65711f169
--- /dev/null
+++ b/contrib/drivers/dm/dm_z_unit_pr_test.go
@@ -0,0 +1,40 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package dm_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+// PR #4157 WherePri
+func Test_WherePri_PR4157(t *testing.T) {
+	tableName := "A_tables"
+	createInitTable(tableName)
+	defer dropTable(tableName)
+	gtest.C(t, func(t *gtest.T) {
+		var resOne *User
+		err := db.Model(tableName).WherePri(1).Scan(&resOne)
+		t.AssertNil(err)
+		t.AssertNQ(resOne, nil)
+		t.AssertEQ(resOne.ID, int64(1))
+	})
+}
+
+// PR #4157 get table field comments
+func Test_TableFields_Comment_PR4157(t *testing.T) {
+	tableName := "A_tables"
+	schema := "SYSDBA"
+	createInitTable(tableName)
+	defer dropTable(tableName)
+	gtest.C(t, func(t *gtest.T) {
+		fields, err := db.Model().TableFields(tableName, schema)
+		t.AssertNil(err)
+		t.AssertEQ(fields["ACCOUNT_NAME"].Comment, "Account Name")
+	})
+}
diff --git a/contrib/drivers/dm/go.mod b/contrib/drivers/dm/go.mod
index c79aaf1a6..affe6ec4a 100644
--- a/contrib/drivers/dm/go.mod
+++ b/contrib/drivers/dm/go.mod
@@ -6,13 +6,13 @@ replace github.com/gogf/gf/v2 => ../../../
 
 require (
 	gitee.com/chunanyong/dm v1.8.12
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -22,20 +22,20 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/contrib/drivers/dm/go.sum b/contrib/drivers/dm/go.sum
index 6cfa39ab0..ff37f869e 100644
--- a/contrib/drivers/dm/go.sum
+++ b/contrib/drivers/dm/go.sum
@@ -6,8 +6,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -33,8 +33,9 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -43,37 +44,39 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
diff --git a/contrib/drivers/gaussdb/gaussdb.go b/contrib/drivers/gaussdb/gaussdb.go
new file mode 100644
index 000000000..a765360c6
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb.go
@@ -0,0 +1,50 @@
+// 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 gaussdb implements gdb.Driver, which supports operations for database GaussDB.
+package gaussdb
+
+import (
+	_ "gitee.com/opengauss/openGauss-connector-go-pq"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/os/gctx"
+)
+
+// Driver is the driver for GaussDB database.
+type Driver struct {
+	*gdb.Core
+}
+
+const (
+	internalPrimaryKeyInCtx gctx.StrKey = "primary_key"
+	defaultSchema           string      = "public"
+	quoteChar               string      = `"`
+)
+
+func init() {
+	if err := gdb.Register(`gaussdb`, New()); err != nil {
+		panic(err)
+	}
+}
+
+// New create and returns a driver that implements gdb.Driver, which supports operations for PostgreSql.
+func New() gdb.Driver {
+	return &Driver{}
+}
+
+// New creates and returns a database object for postgresql.
+// It implements the interface of gdb.Driver for extra database driver installation.
+func (d *Driver) New(core *gdb.Core, node *gdb.ConfigNode) (gdb.DB, error) {
+	return &Driver{
+		Core: core,
+	}, nil
+}
+
+// GetChars returns the security char for this type of database.
+func (d *Driver) GetChars() (charLeft string, charRight string) {
+	return quoteChar, quoteChar
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_convert.go b/contrib/drivers/gaussdb/gaussdb_convert.go
new file mode 100644
index 000000000..67512f65f
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_convert.go
@@ -0,0 +1,257 @@
+// 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 gaussdb
+
+import (
+	"context"
+	"reflect"
+	"strings"
+
+	pq "gitee.com/opengauss/openGauss-connector-go-pq"
+	"github.com/google/uuid"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"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"
+)
+
+// ConvertValueForField converts value to database acceptable value.
+func (d *Driver) ConvertValueForField(ctx context.Context, fieldType string, fieldValue any) (any, error) {
+	if g.IsNil(fieldValue) {
+		return d.Core.ConvertValueForField(ctx, fieldType, fieldValue)
+	}
+
+	var fieldValueKind = reflect.TypeOf(fieldValue).Kind()
+
+	if fieldValueKind == reflect.Slice {
+		// For pgsql, json or jsonb require '[]'
+		if !gstr.Contains(fieldType, "json") {
+			fieldValue = gstr.ReplaceByMap(gconv.String(fieldValue),
+				map[string]string{
+					"[": "{",
+					"]": "}",
+				},
+			)
+		}
+	}
+	return d.Core.ConvertValueForField(ctx, fieldType, fieldValue)
+}
+
+// CheckLocalTypeForField checks and returns corresponding local golang type for given db type.
+// The parameter `fieldType` is in lower case, like:
+// `int2`, `int4`, `int8`, `_int2`, `_int4`, `_int8`, `_float4`, `_float8`, etc.
+//
+// PostgreSQL type mapping:
+//
+//	| PostgreSQL Type              | Local Go Type |
+//	|------------------------------|---------------|
+//	| int2, int4                   | int           |
+//	| int8                         | int64         |
+//	| uuid                         | uuid.UUID     |
+//	| _int2, _int4                 | []int32       | // Note: pq package does not provide Int16Array; int32 is used for compatibility
+//	| _int8                        | []int64       |
+//	| _float4                      | []float32     |
+//	| _float8                      | []float64     |
+//	| _bool                        | []bool        |
+//	| _varchar, _text              | []string      |
+//	| _char, _bpchar               | []string      |
+//	| _numeric, _decimal, _money   | []float64     |
+//	| _bytea                       | [][]byte      |
+//	| _uuid                        | []uuid.UUID   |
+func (d *Driver) CheckLocalTypeForField(ctx context.Context, fieldType string, fieldValue any) (gdb.LocalType, error) {
+	var typeName string
+	match, _ := gregex.MatchString(`(.+?)\((.+)\)`, fieldType)
+	if len(match) == 3 {
+		typeName = gstr.Trim(match[1])
+	} else {
+		typeName = fieldType
+	}
+	typeName = strings.ToLower(typeName)
+	switch typeName {
+	case "int2", "int4":
+		return gdb.LocalTypeInt, nil
+
+	case "int8":
+		return gdb.LocalTypeInt64, nil
+
+	case "uuid":
+		return gdb.LocalTypeUUID, nil
+
+	case "_int2", "_int4":
+		return gdb.LocalTypeInt32Slice, nil
+
+	case "_int8":
+		return gdb.LocalTypeInt64Slice, nil
+
+	case "_float4":
+		return gdb.LocalTypeFloat32Slice, nil
+
+	case "_float8":
+		return gdb.LocalTypeFloat64Slice, nil
+
+	case "_bool":
+		return gdb.LocalTypeBoolSlice, nil
+
+	case "_varchar", "_text", "_char", "_bpchar":
+		return gdb.LocalTypeStringSlice, nil
+
+	case "_uuid":
+		return gdb.LocalTypeUUIDSlice, nil
+
+	case "_numeric", "_decimal", "_money":
+		return gdb.LocalTypeFloat64Slice, nil
+
+	case "_bytea":
+		return gdb.LocalTypeBytesSlice, nil
+
+	default:
+		return d.Core.CheckLocalTypeForField(ctx, fieldType, fieldValue)
+	}
+}
+
+// ConvertValueForLocal converts value to local Golang type of value according field type name from database.
+// The parameter `fieldType` is in lower case, like:
+// `int2`, `int4`, `int8`, `_int2`, `_int4`, `_int8`, `uuid`, `_uuid`, etc.
+//
+// See: https://www.postgresql.org/docs/current/datatype.html
+//
+// PostgreSQL type mapping:
+//
+//	| PostgreSQL Type | SQL Type                       | pq Type         | Go Type     |
+//	|-----------------|--------------------------------|-----------------|-------------|
+//	| int2            | int2, smallint                 | -               | int         |
+//	| int4            | int4, integer                  | -               | int         |
+//	| int8            | int8, bigint, bigserial        | -               | int64       |
+//	| uuid            | uuid                           | -               | uuid.UUID   |
+//	| _int2           | int2[], smallint[]             | pq.Int32Array   | []int32     |
+//	| _int4           | int4[], integer[]              | pq.Int32Array   | []int32     |
+//	| _int8           | int8[], bigint[]               | pq.Int64Array   | []int64     |
+//	| _float4         | float4[], real[]               | pq.Float32Array | []float32   |
+//	| _float8         | float8[], double precision[]   | pq.Float64Array | []float64   |
+//	| _bool           | boolean[], bool[]              | pq.BoolArray    | []bool      |
+//	| _varchar        | varchar[], character varying[] | pq.StringArray  | []string    |
+//	| _text           | text[]                         | pq.StringArray  | []string    |
+//	| _char, _bpchar  | char[], character[]            | pq.StringArray  | []string    |
+//	| _numeric        | numeric[]                      | pq.Float64Array | []float64   |
+//	| _decimal        | decimal[]                      | pq.Float64Array | []float64   |
+//	| _money          | money[]                        | pq.Float64Array | []float64   |
+//	| _bytea          | bytea[]                        | pq.ByteaArray   | [][]byte    |
+//	| _uuid           | uuid[]                         | pq.StringArray  | []uuid.UUID |
+//
+// Note: PostgreSQL also supports these array types but they are not yet mapped:
+//   - _date (date[]), _timestamp (timestamp[]), _timestamptz (timestamptz[])
+//   - _jsonb (jsonb[]), _json (json[])
+func (d *Driver) ConvertValueForLocal(ctx context.Context, fieldType string, fieldValue any) (any, error) {
+	typeName, _ := gregex.ReplaceString(`\(.+\)`, "", fieldType)
+	typeName = strings.ToLower(typeName)
+
+	// Basic types are mostly handled by Core layer, only handle array types here
+	switch typeName {
+
+	// []int32
+	case "_int2", "_int4":
+		var result pq.Int32Array
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []int32(result), nil
+
+	// []int64
+	case "_int8":
+		var result pq.Int64Array
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []int64(result), nil
+
+	// []float32
+	case "_float4":
+		var result pq.Float32Array
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []float32(result), nil
+
+	// []float64
+	case "_float8":
+		var result pq.Float64Array
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []float64(result), nil
+
+	// []bool
+	case "_bool":
+		var result pq.BoolArray
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []bool(result), nil
+
+	// []string
+	case "_varchar", "_text", "_char", "_bpchar":
+		var result pq.StringArray
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []string(result), nil
+
+	// uuid.UUID
+	case "uuid":
+		var uuidStr string
+		switch v := fieldValue.(type) {
+		case []byte:
+			uuidStr = string(v)
+		case string:
+			uuidStr = v
+		default:
+			uuidStr = gconv.String(fieldValue)
+		}
+		result, err := uuid.Parse(uuidStr)
+		if err != nil {
+			return nil, err
+		}
+		return result, nil
+
+	// []uuid.UUID
+	case "_uuid":
+		var strArray pq.StringArray
+		if err := strArray.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		result := make([]uuid.UUID, len(strArray))
+		for i, s := range strArray {
+			parsed, err := uuid.Parse(s)
+			if err != nil {
+				return nil, err
+			}
+			result[i] = parsed
+		}
+		return result, nil
+
+	// []float64
+	case "_numeric", "_decimal", "_money":
+		var result pq.Float64Array
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []float64(result), nil
+
+	// [][]byte
+	case "_bytea":
+		var result pq.ByteaArray
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return [][]byte(result), nil
+
+	default:
+		return d.Core.ConvertValueForLocal(ctx, fieldType, fieldValue)
+	}
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_do_exec.go b/contrib/drivers/gaussdb/gaussdb_do_exec.go
new file mode 100644
index 000000000..76aad3c4a
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_do_exec.go
@@ -0,0 +1,110 @@
+// 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 gaussdb
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+)
+
+// DoExec commits the sql string and its arguments to underlying driver
+// through given link object and returns the execution result.
+func (d *Driver) DoExec(ctx context.Context, link gdb.Link, sql string, args ...any) (result sql.Result, err error) {
+	var (
+		isUseCoreDoExec bool   = false // Check whether the default method needs to be used
+		primaryKey      string = ""
+		pkField         gdb.TableField
+	)
+
+	// Transaction checks.
+	if link == nil {
+		if tx := gdb.TXFromCtx(ctx, d.GetGroup()); tx != nil {
+			// Firstly, check and retrieve transaction link from context.
+			link = tx
+		} else if link, err = d.MasterLink(); err != nil {
+			// Or else it creates one from master node.
+			return nil, err
+		}
+	} else if !link.IsTransaction() {
+		// If current link is not transaction link, it checks and retrieves transaction from context.
+		if tx := gdb.TXFromCtx(ctx, d.GetGroup()); tx != nil {
+			link = tx
+		}
+	}
+
+	// Check if it is an insert operation with primary key.
+	if value := ctx.Value(internalPrimaryKeyInCtx); value != nil {
+		var ok bool
+		pkField, ok = value.(gdb.TableField)
+		if !ok {
+			isUseCoreDoExec = true
+		}
+	} else {
+		isUseCoreDoExec = true
+	}
+
+	// check if it is an insert operation.
+	if !isUseCoreDoExec && pkField.Name != "" && strings.Contains(sql, "INSERT INTO") {
+		primaryKey = pkField.Name
+		sql += fmt.Sprintf(` RETURNING "%s"`, primaryKey)
+	} else {
+		// use default DoExec
+		return d.Core.DoExec(ctx, link, sql, args...)
+	}
+
+	// Only the insert operation with primary key can execute the following code
+
+	// Sql filtering.
+	sql, args = d.FormatSqlBeforeExecuting(sql, args)
+	sql, args, err = d.DoFilter(ctx, link, sql, args)
+	if err != nil {
+		return nil, err
+	}
+
+	// Link execution.
+	var out gdb.DoCommitOutput
+	out, err = d.DoCommit(ctx, gdb.DoCommitInput{
+		Link:          link,
+		Sql:           sql,
+		Args:          args,
+		Stmt:          nil,
+		Type:          gdb.SqlTypeQueryContext,
+		IsTransaction: link.IsTransaction(),
+	})
+
+	if err != nil {
+		return nil, err
+	}
+	affected := len(out.Records)
+	if affected > 0 {
+		if !strings.Contains(pkField.Type, "int") {
+			return Result{
+				affected:     int64(affected),
+				lastInsertId: 0,
+				lastInsertIdError: gerror.NewCodef(
+					gcode.CodeNotSupported,
+					"LastInsertId is not supported by primary key type: %s", pkField.Type),
+			}, nil
+		}
+
+		if out.Records[affected-1][primaryKey] != nil {
+			lastInsertId := out.Records[affected-1][primaryKey].Int64()
+			return Result{
+				affected:     int64(affected),
+				lastInsertId: lastInsertId,
+			}, nil
+		}
+	}
+
+	return Result{}, nil
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_do_filter.go b/contrib/drivers/gaussdb/gaussdb_do_filter.go
new file mode 100644
index 000000000..6c9d32469
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_do_filter.go
@@ -0,0 +1,62 @@
+// 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 gaussdb
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+)
+
+// DoFilter deals with the sql string before commits it to underlying sql driver.
+func (d *Driver) DoFilter(
+	ctx context.Context, link gdb.Link, sql string, args []any,
+) (newSql string, newArgs []any, err error) {
+	var index int
+	// Convert placeholder char '?' to string "$x".
+	newSql, err = gregex.ReplaceStringFunc(`\?`, sql, func(s string) string {
+		index++
+		return fmt.Sprintf(`$%d`, index)
+	})
+	if err != nil {
+		return "", nil, err
+	}
+	// Handle pgsql jsonb feature support, which contains place-holder char '?'.
+	// Refer:
+	// https://github.com/gogf/gf/issues/1537
+	// https://www.postgresql.org/docs/12/functions-json.html
+	newSql, err = gregex.ReplaceStringFuncMatch(
+		`(::jsonb([^\w\d]*)\$\d)`,
+		newSql,
+		func(match []string) string {
+			return fmt.Sprintf(`::jsonb%s?`, match[2])
+		},
+	)
+	if err != nil {
+		return "", nil, err
+	}
+	newSql, err = gregex.ReplaceString(` LIMIT (\d+),\s*(\d+)`, ` LIMIT $2 OFFSET $1`, newSql)
+	if err != nil {
+		return "", nil, err
+	}
+
+	// Handle gaussdb INSERT IGNORE.
+	// The IGNORE keyword is removed here, converting the statement to a regular INSERT.
+	// The actual "ignore" behavior (i.e., skipping inserts that would violate constraints)
+	// is implemented at the DoInsert level by checking for existence before inserting.
+	if gstr.HasPrefix(newSql, gdb.InsertOperationIgnore) {
+		// Remove the IGNORE operation prefix and keep as regular INSERT
+		newSql = "INSERT" + newSql[len(gdb.InsertOperationIgnore):]
+	}
+
+	newArgs = args
+
+	return d.Core.DoFilter(ctx, link, newSql, newArgs)
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_do_insert.go b/contrib/drivers/gaussdb/gaussdb_do_insert.go
new file mode 100644
index 000000000..753e1ce71
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_do_insert.go
@@ -0,0 +1,535 @@
+// 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 gaussdb
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+
+	"github.com/gogf/gf/v2/container/gset"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+// DoInsert inserts or updates data for given table.
+// The list parameter must contain at least one record, which was previously validated.
+func (d *Driver) DoInsert(
+	ctx context.Context,
+	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
+) (result sql.Result, err error) {
+	switch option.InsertOption {
+	case gdb.InsertOptionSave:
+		return d.doSave(ctx, link, table, list, option)
+
+	case gdb.InsertOptionReplace:
+		// Treat Replace as Save operation
+		return d.doSave(ctx, link, table, list, option)
+
+	// GaussDB does not support InsertIgnore with ON CONFLICT, use MERGE instead
+	case gdb.InsertOptionIgnore:
+		return d.doInsertIgnore(ctx, link, table, list, option)
+
+	case gdb.InsertOptionDefault:
+		// Get table fields to retrieve the primary key TableField object (not just the name)
+		// because DoExec needs the `TableField.Type` to determine if LastInsertId is supported.
+		tableFields, err := d.GetCore().GetDB().TableFields(ctx, table)
+		if err == nil {
+			for _, field := range tableFields {
+				if strings.EqualFold(field.Key, "pri") {
+					pkField := *field
+					ctx = context.WithValue(ctx, internalPrimaryKeyInCtx, pkField)
+					break
+				}
+			}
+		}
+
+	default:
+	}
+	return d.Core.DoInsert(ctx, link, table, list, option)
+}
+
+// doSave implements upsert operation using MERGE statement for GaussDB.
+func (d *Driver) doSave(ctx context.Context,
+	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
+) (result sql.Result, err error) {
+	return d.doMergeInsert(ctx, link, table, list, option, true)
+}
+
+// doInsertIgnore implements INSERT IGNORE operation using MERGE statement for GaussDB.
+// It only inserts records when there's no conflict on primary/unique keys.
+func (d *Driver) doInsertIgnore(ctx context.Context,
+	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
+) (result sql.Result, err error) {
+	return d.doMergeInsert(ctx, link, table, list, option, false)
+}
+
+// doUpdateThenInsert handles upsert when conflict keys need to be updated.
+// GaussDB MERGE cannot update columns in ON clause, so we use UPDATE + INSERT instead.
+func (d *Driver) doUpdateThenInsert(ctx context.Context,
+	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
+) (result sql.Result, err error) {
+	charL, charR := d.GetChars()
+	var (
+		batchResult   = new(gdb.SqlResult)
+		totalAffected int64
+	)
+
+	for _, data := range list {
+		// Build UPDATE statement
+		var (
+			updateFields []string
+			updateValues []any
+			whereFields  []string
+			whereValues  []any
+			valueIndex   = 1
+		)
+
+		// Process OnDuplicateMap to build UPDATE SET clause
+		for updateKey, updateValue := range option.OnDuplicateMap {
+			keyWithChar := charL + updateKey + charR
+			switch v := updateValue.(type) {
+			case gdb.Raw, *gdb.Raw:
+				rawStr := fmt.Sprintf("%v", v)
+				rawStr = strings.ReplaceAll(rawStr, "EXCLUDED.", "")
+				rawStr = strings.ReplaceAll(rawStr, "EXCLUDED ", "")
+				updateFields = append(updateFields, fmt.Sprintf("%s = %s", keyWithChar, rawStr))
+			case gdb.Counter, *gdb.Counter:
+				var counter gdb.Counter
+				if c, ok := v.(gdb.Counter); ok {
+					counter = c
+				} else if c, ok := v.(*gdb.Counter); ok {
+					counter = *c
+				}
+				operator := "+"
+				columnVal := counter.Value
+				if columnVal < 0 {
+					operator = "-"
+					columnVal = -columnVal
+				}
+				fieldWithChar := charL + counter.Field + charR
+				// For UPDATE statement, use the data value instead of referencing another column
+				if dataValue, ok := data[counter.Field]; ok {
+					updateFields = append(updateFields, fmt.Sprintf("%s = $%d %s %v", keyWithChar, valueIndex, operator, columnVal))
+					updateValues = append(updateValues, dataValue)
+					valueIndex++
+				} else {
+					updateFields = append(updateFields, fmt.Sprintf("%s = %s %s %v", keyWithChar, fieldWithChar, operator, columnVal))
+				}
+			default:
+				// Map value to another field name or use the value from data
+				valueStr := gconv.String(updateValue)
+				if dataValue, ok := data[valueStr]; ok {
+					updateFields = append(updateFields, fmt.Sprintf("%s = $%d", keyWithChar, valueIndex))
+					updateValues = append(updateValues, dataValue)
+					valueIndex++
+				} else {
+					updateFields = append(updateFields, fmt.Sprintf("%s = $%d", keyWithChar, valueIndex))
+					updateValues = append(updateValues, updateValue)
+					valueIndex++
+				}
+			}
+		}
+
+		// Build WHERE clause using OnConflict keys
+		for _, conflictKey := range option.OnConflict {
+			if dataValue, ok := data[conflictKey]; ok {
+				keyWithChar := charL + conflictKey + charR
+				whereFields = append(whereFields, fmt.Sprintf("%s = $%d", keyWithChar, valueIndex))
+				whereValues = append(whereValues, dataValue)
+				valueIndex++
+			}
+		}
+
+		if len(updateFields) > 0 && len(whereFields) > 0 {
+			updateSQL := fmt.Sprintf("UPDATE %s SET %s WHERE %s",
+				table,
+				strings.Join(updateFields, ", "),
+				strings.Join(whereFields, " AND "),
+			)
+			updateResult, updateErr := d.DoExec(ctx, link, updateSQL, append(updateValues, whereValues...)...)
+			if updateErr != nil {
+				return nil, updateErr
+			}
+
+			affected, _ := updateResult.RowsAffected()
+			if affected > 0 {
+				// UPDATE successful
+				totalAffected += affected
+				continue
+			}
+		}
+
+		// If UPDATE affected 0 rows, do INSERT
+		var (
+			insertKeys    []string
+			insertHolders []string
+			insertValues  []any
+			insertIndex   = 1
+		)
+		for key, value := range data {
+			keyWithChar := charL + key + charR
+			insertKeys = append(insertKeys, keyWithChar)
+			insertHolders = append(insertHolders, fmt.Sprintf("$%d", insertIndex))
+			insertValues = append(insertValues, value)
+			insertIndex++
+		}
+
+		insertSQL := fmt.Sprintf("INSERT INTO %s (%s) VALUES (%s)",
+			table,
+			strings.Join(insertKeys, ", "),
+			strings.Join(insertHolders, ", "),
+		)
+		insertResult, insertErr := d.DoExec(ctx, link, insertSQL, insertValues...)
+		if insertErr != nil {
+			// Ignore duplicate key errors (race condition: another transaction inserted between our UPDATE and INSERT)
+			if strings.Contains(insertErr.Error(), "duplicate key") ||
+				strings.Contains(insertErr.Error(), "unique constraint") {
+				continue
+			}
+			return nil, insertErr
+		}
+
+		affected, _ := insertResult.RowsAffected()
+		totalAffected += affected
+	}
+
+	batchResult.Result = &gdb.SqlResult{}
+	batchResult.Affected = totalAffected
+	return batchResult, nil
+}
+
+// doMergeInsert implements MERGE-based insert operations for GaussDB.
+// When withUpdate is true, it performs upsert (insert or update).
+// When withUpdate is false, it performs insert ignore (insert only when no conflict).
+func (d *Driver) doMergeInsert(
+	ctx context.Context,
+	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption, withUpdate bool,
+) (result sql.Result, err error) {
+	// For batch operations (multiple records), process each record individually
+	if len(list) > 1 {
+		var (
+			batchResult   = new(gdb.SqlResult)
+			totalAffected int64
+		)
+		for _, record := range list {
+			singleResult, singleErr := d.doMergeInsert(ctx, link, table, gdb.List{record}, option, withUpdate)
+			if singleErr != nil {
+				return nil, singleErr
+			}
+			if n, _ := singleResult.RowsAffected(); n > 0 {
+				totalAffected += n
+			}
+		}
+		batchResult.Result = &gdb.SqlResult{}
+		batchResult.Affected = totalAffected
+		return batchResult, nil
+	}
+
+	// Check if OnDuplicateMap contains conflict keys
+	// GaussDB MERGE statement cannot update columns used in ON clause
+	// If user wants to update conflict keys, we need to use a different approach
+	if withUpdate && len(option.OnDuplicateMap) > 0 && len(option.OnConflict) > 0 {
+		conflictKeySet := gset.NewStrSetFrom(option.OnConflict)
+		hasConflictKeyUpdate := false
+		for updateKey := range option.OnDuplicateMap {
+			if conflictKeySet.Contains(strings.ToLower(updateKey)) ||
+				conflictKeySet.Contains(strings.ToUpper(updateKey)) ||
+				conflictKeySet.Contains(updateKey) {
+				hasConflictKeyUpdate = true
+				break
+			}
+		}
+		if hasConflictKeyUpdate {
+			// Use UPDATE + INSERT approach when conflict keys need to be updated
+			return d.doUpdateThenInsert(ctx, link, table, list, option)
+		}
+	}
+
+	// If OnConflict is not specified, automatically get the primary key of the table
+	conflictKeys := option.OnConflict
+	if len(conflictKeys) == 0 {
+		primaryKeys, err := d.Core.GetPrimaryKeys(ctx, table)
+		if err != nil {
+			return nil, gerror.WrapCode(
+				gcode.CodeInternalError,
+				err,
+				`failed to get primary keys for table`,
+			)
+		}
+		foundPrimaryKey := false
+		for _, primaryKey := range primaryKeys {
+			for dataKey := range list[0] {
+				if strings.EqualFold(dataKey, primaryKey) {
+					foundPrimaryKey = true
+					break
+				}
+			}
+			if foundPrimaryKey {
+				break
+			}
+		}
+		if !foundPrimaryKey {
+			// For InsertIgnore without primary key, try normal insert and ignore duplicate errors
+			// For Save/Replace, primary key is required
+			if !withUpdate {
+				result, err := d.Core.DoInsert(ctx, link, table, list, option)
+				if err != nil {
+					// Ignore duplicate key errors for InsertIgnore
+					if strings.Contains(err.Error(), "duplicate key") ||
+						strings.Contains(err.Error(), "unique constraint") {
+						return result, nil
+					}
+					return result, err
+				}
+				return result, nil
+			}
+			return nil, gerror.NewCodef(
+				gcode.CodeMissingParameter,
+				`Replace/Save operation requires conflict detection: `+
+					`either specify OnConflict() columns or ensure table '%s' has a primary key in the data`,
+				table,
+			)
+		}
+		// TODO consider composite primary keys.
+		conflictKeys = primaryKeys
+	}
+
+	var (
+		one            = list[0]
+		oneLen         = len(one)
+		charL, charR   = d.GetChars()
+		conflictKeySet = gset.NewStrSet(false)
+
+		// queryHolders:	Handle data with Holder that need to be merged
+		// queryValues:		Handle data that need to be merged
+		// insertKeys:		Handle valid keys that need to be inserted
+		// insertValues:	Handle values that need to be inserted
+		// updateValues:	Handle values that need to be updated (only when withUpdate=true)
+		queryHolders = make([]string, oneLen)
+		queryValues  = make([]any, oneLen)
+		insertKeys   = make([]string, oneLen)
+		insertValues = make([]string, oneLen)
+		updateValues []string
+	)
+
+	// conflictKeys slice type conv to set type
+	for _, conflictKey := range conflictKeys {
+		conflictKeySet.Add(strings.ToUpper(conflictKey))
+	}
+
+	index := 0
+	for key, value := range one {
+		keyWithChar := charL + key + charR
+		queryHolders[index] = fmt.Sprintf("$%d AS %s", index+1, keyWithChar)
+		queryValues[index] = value
+		insertKeys[index] = keyWithChar
+		insertValues[index] = fmt.Sprintf("T2.%s", keyWithChar)
+		index++
+	}
+
+	// Build updateValues only when withUpdate is true
+	if withUpdate {
+		// Check if OnDuplicateStr or OnDuplicateMap is specified for custom update logic
+		if option.OnDuplicateStr != "" {
+			// Parse OnDuplicateStr (e.g., "field1,field2" or "field1, field2")
+			fields := gstr.SplitAndTrim(option.OnDuplicateStr, ",")
+			for _, field := range fields {
+				fieldWithChar := charL + field + charR
+				updateValues = append(
+					updateValues,
+					fmt.Sprintf(`T1.%s = T2.%s`, fieldWithChar, fieldWithChar),
+				)
+			}
+		} else if len(option.OnDuplicateMap) > 0 {
+			// Use OnDuplicateMap for custom update mapping
+			for updateKey, updateValue := range option.OnDuplicateMap {
+				// Skip conflict keys - they cannot be updated in MERGE
+				if conflictKeySet.Contains(strings.ToUpper(updateKey)) {
+					continue
+				}
+				keyWithChar := charL + updateKey + charR
+				switch v := updateValue.(type) {
+				case gdb.Raw, *gdb.Raw:
+					// Raw SQL expression
+					// Replace EXCLUDED (PostgreSQL ON CONFLICT syntax) with T2 (MERGE syntax)
+					rawStr := fmt.Sprintf("%v", v)
+					rawStr = strings.ReplaceAll(rawStr, "EXCLUDED.", "T2.")
+					rawStr = strings.ReplaceAll(rawStr, "EXCLUDED ", "T2 ")
+					updateValues = append(
+						updateValues,
+						fmt.Sprintf(`T1.%s = %s`, keyWithChar, rawStr),
+					)
+				case gdb.Counter, *gdb.Counter:
+					// Counter operation
+					var counter gdb.Counter
+					if c, ok := v.(gdb.Counter); ok {
+						counter = c
+					} else if c, ok := v.(*gdb.Counter); ok {
+						counter = *c
+					}
+					operator := "+"
+					columnVal := counter.Value
+					if columnVal < 0 {
+						operator = "-"
+						columnVal = -columnVal
+					}
+					fieldWithChar := charL + counter.Field + charR
+					updateValues = append(
+						updateValues,
+						fmt.Sprintf(`T1.%s = T2.%s %s %v`, keyWithChar, fieldWithChar, operator, columnVal),
+					)
+				default:
+					// Map value to another field name
+					valueStr := gconv.String(updateValue)
+					valueWithChar := charL + valueStr + charR
+					updateValues = append(
+						updateValues,
+						fmt.Sprintf(`T1.%s = T2.%s`, keyWithChar, valueWithChar),
+					)
+				}
+			}
+		} else {
+			// Default: update all fields except conflict keys and soft created fields
+			for key := range one {
+				if conflictKeySet.Contains(strings.ToUpper(key)) || d.Core.IsSoftCreatedFieldName(key) {
+					continue
+				}
+				keyWithChar := charL + key + charR
+				updateValues = append(
+					updateValues,
+					fmt.Sprintf(`T1.%s = T2.%s`, keyWithChar, keyWithChar),
+				)
+			}
+		}
+	}
+
+	var (
+		batchResult = new(gdb.SqlResult)
+		sqlStr      string
+	)
+
+	// For InsertIgnore (withUpdate=false), we need to check if record exists first
+	if !withUpdate {
+		// Build WHERE clause to check if record exists
+		var whereConditions []string
+		var checkValues []any
+		checkIndex := 1
+		for _, key := range conflictKeys {
+			if value, ok := one[key]; ok {
+				keyWithChar := charL + key + charR
+				whereConditions = append(whereConditions, fmt.Sprintf("%s = $%d", keyWithChar, checkIndex))
+				checkValues = append(checkValues, value)
+				checkIndex++
+			}
+		}
+		whereClause := strings.Join(whereConditions, " AND ")
+
+		// Check if record exists
+		checkSQL := fmt.Sprintf("SELECT 1 FROM %s WHERE %s LIMIT 1", table, whereClause)
+		checkResult, checkErr := d.DoQuery(ctx, link, checkSQL, checkValues...)
+		if checkErr != nil {
+			return nil, checkErr
+		}
+
+		// If record exists, return result with 0 affected rows
+		if len(checkResult) > 0 {
+			batchResult.Result = &gdb.SqlResult{}
+			batchResult.Affected = 0
+			return batchResult, nil
+		}
+
+		// Record doesn't exist, proceed with insert
+		// For InsertIgnore, we just do a simple INSERT (no MERGE needed since we checked it doesn't exist)
+		var insertSQL strings.Builder
+		insertSQL.WriteString(fmt.Sprintf("INSERT INTO %s (", table))
+		insertSQL.WriteString(strings.Join(insertKeys, ","))
+		insertSQL.WriteString(") VALUES (")
+		for i := range insertKeys {
+			if i > 0 {
+				insertSQL.WriteString(",")
+			}
+			insertSQL.WriteString(fmt.Sprintf("$%d", i+1))
+		}
+		insertSQL.WriteString(")")
+
+		r, err := d.DoExec(ctx, link, insertSQL.String(), queryValues...)
+		if err != nil {
+			return r, err
+		}
+		if n, err := r.RowsAffected(); err != nil {
+			return r, err
+		} else {
+			batchResult.Result = r
+			batchResult.Affected = n
+		}
+		return batchResult, nil
+	}
+
+	// For Save/Replace (withUpdate=true), use MERGE
+	sqlStr = parseSqlForMerge(table, queryHolders, insertKeys, insertValues, updateValues, conflictKeys, charL, charR)
+	r, err := d.DoExec(ctx, link, sqlStr, queryValues...)
+	if err != nil {
+		return r, err
+	}
+	// GaussDB's MERGE statement may not return correct RowsAffected
+	// Workaround: If RowsAffected returns 0 despite a successful MERGE, we manually set it to 1.
+	if n, err := r.RowsAffected(); err != nil {
+		return r, err
+	} else {
+		batchResult.Result = r
+		// If RowsAffected returns 0, manually set to 1 for MERGE operations
+		if n == 0 {
+			batchResult.Affected = 1
+		} else {
+			batchResult.Affected += n
+		}
+	}
+	return batchResult, nil
+}
+
+// parseSqlForMerge generates MERGE statement for GaussDB.
+// When updateValues is empty, it only inserts (INSERT IGNORE behavior).
+// When updateValues is provided, it performs upsert (INSERT or UPDATE).
+// Examples:
+// - INSERT IGNORE: MERGE INTO table T1 USING (...) T2 ON (...) WHEN NOT MATCHED THEN INSERT(...) VALUES (...)
+// - UPSERT: MERGE INTO table T1 USING (...) T2 ON (...) WHEN NOT MATCHED THEN INSERT(...) VALUES (...) WHEN MATCHED THEN UPDATE SET ...
+func parseSqlForMerge(table string,
+	queryHolders, insertKeys, insertValues, updateValues, duplicateKey []string, charL, charR string,
+) (sqlStr string) {
+	var (
+		intoStr   = fmt.Sprintf("MERGE INTO %s AS T1", table)
+		usingStr  = fmt.Sprintf("USING (SELECT %s) AS T2", strings.Join(queryHolders, ","))
+		onStr     string
+		insertStr = fmt.Sprintf(
+			"WHEN NOT MATCHED THEN INSERT (%s) VALUES (%s)",
+			strings.Join(insertKeys, ","),
+			strings.Join(insertValues, ","),
+		)
+		updateStr string
+	)
+
+	// Build ON condition
+	var onConditions []string
+	for _, key := range duplicateKey {
+		keyWithChar := charL + key + charR
+		onConditions = append(onConditions, fmt.Sprintf("T1.%s = T2.%s", keyWithChar, keyWithChar))
+	}
+	onStr = "ON (" + strings.Join(onConditions, " AND ") + ")"
+
+	// Build UPDATE clause only when updateValues is provided
+	if len(updateValues) > 0 {
+		updateStr = fmt.Sprintf(" WHEN MATCHED THEN UPDATE SET %s", strings.Join(updateValues, ","))
+	}
+
+	sqlStr = fmt.Sprintf("%s %s %s %s%s", intoStr, usingStr, onStr, insertStr, updateStr)
+	return
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_open.go b/contrib/drivers/gaussdb/gaussdb_open.go
new file mode 100644
index 000000000..0ae6570c3
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_open.go
@@ -0,0 +1,69 @@
+// 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 gaussdb
+
+import (
+	"database/sql"
+	"fmt"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/text/gstr"
+)
+
+// Open creates and returns an underlying sql.DB object for GaussDB (openGauss).
+// https://gitee.com/opengauss/openGauss-connector-go-pq
+func (d *Driver) Open(config *gdb.ConfigNode) (db *sql.DB, err error) {
+	source, err := configNodeToSource(config)
+	if err != nil {
+		return nil, err
+	}
+	underlyingDriverName := "opengauss"
+	if db, err = sql.Open(underlyingDriverName, source); err != nil {
+		err = gerror.WrapCodef(
+			gcode.CodeDbOperationError, err,
+			`sql.Open failed for driver "%s" by source "%s"`, underlyingDriverName, source,
+		)
+		return nil, err
+	}
+	return
+}
+
+func configNodeToSource(config *gdb.ConfigNode) (string, error) {
+	var source string
+	source = fmt.Sprintf(
+		"user=%s password='%s' host=%s sslmode=disable",
+		config.User, config.Pass, config.Host,
+	)
+	if config.Port != "" {
+		source = fmt.Sprintf("%s port=%s", source, config.Port)
+	}
+	if config.Name != "" {
+		source = fmt.Sprintf("%s dbname=%s", source, config.Name)
+	}
+	if config.Namespace != "" {
+		source = fmt.Sprintf("%s search_path=%s", source, config.Namespace)
+	}
+	if config.Timezone != "" {
+		source = fmt.Sprintf("%s timezone=%s", source, config.Timezone)
+	}
+	if config.Extra != "" {
+		extraMap, err := gstr.Parse(config.Extra)
+		if err != nil {
+			return "", gerror.WrapCodef(
+				gcode.CodeInvalidParameter,
+				err,
+				`invalid extra configuration: %s`, config.Extra,
+			)
+		}
+		for k, v := range extraMap {
+			source += fmt.Sprintf(` %s=%s`, k, v)
+		}
+	}
+	return source, nil
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_order.go b/contrib/drivers/gaussdb/gaussdb_order.go
new file mode 100644
index 000000000..159089d18
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_order.go
@@ -0,0 +1,12 @@
+// 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 gaussdb
+
+// OrderRandomFunction returns the SQL function for random ordering.
+func (d *Driver) OrderRandomFunction() string {
+	return "RANDOM()"
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_result.go b/contrib/drivers/gaussdb/gaussdb_result.go
new file mode 100644
index 000000000..6488e5563
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_result.go
@@ -0,0 +1,24 @@
+// 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 gaussdb
+
+import "database/sql"
+
+type Result struct {
+	sql.Result
+	affected          int64
+	lastInsertId      int64
+	lastInsertIdError error
+}
+
+func (pgr Result) RowsAffected() (int64, error) {
+	return pgr.affected, nil
+}
+
+func (pgr Result) LastInsertId() (int64, error) {
+	return pgr.lastInsertId, pgr.lastInsertIdError
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_table_fields.go b/contrib/drivers/gaussdb/gaussdb_table_fields.go
new file mode 100644
index 000000000..863bdf736
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_table_fields.go
@@ -0,0 +1,108 @@
+// 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 gaussdb
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gogf/gf/v2/database/gdb"
+)
+
+var (
+	tableFieldsSqlTmp = `
+SELECT
+    a.attname                                                                            AS field,
+    t.typname                                                                            AS type,
+    a.attnotnull                                                                         AS null,
+    (CASE WHEN d.contype = 'p' THEN 'pri' WHEN d.contype = 'u' THEN 'uni' ELSE '' END)   AS key,
+    ic.column_default                                                                    AS default_value,
+    b.description                                                                        AS comment,
+    COALESCE(character_maximum_length, numeric_precision, -1)                            AS length,
+    numeric_scale                                                                        AS scale
+FROM pg_attribute a
+    LEFT JOIN pg_class c                 ON a.attrelid = c.oid
+    LEFT JOIN pg_constraint d            ON d.conrelid = c.oid AND a.attnum = d.conkey[1]
+    LEFT JOIN pg_description b           ON a.attrelid = b.objoid AND a.attnum = b.objsubid
+    LEFT JOIN pg_type t                  ON a.atttypid = t.oid
+    LEFT JOIN information_schema.columns ic ON ic.column_name = a.attname AND ic.table_name = c.relname
+WHERE c.oid = '%s'::regclass
+    AND a.attisdropped IS FALSE
+    AND a.attnum > 0
+ORDER BY a.attnum`
+)
+
+func init() {
+	var err error
+	tableFieldsSqlTmp, err = gdb.FormatMultiLineSqlToSingle(tableFieldsSqlTmp)
+	if err != nil {
+		panic(err)
+	}
+}
+
+// TableFields retrieves and returns the fields' information of specified table of current schema.
+func (d *Driver) TableFields(
+	ctx context.Context, table string, schema ...string,
+) (fields map[string]*gdb.TableField, err error) {
+	var (
+		result       gdb.Result
+		link         gdb.Link
+		structureSql = fmt.Sprintf(tableFieldsSqlTmp, table)
+	)
+	// Schema parameter is not used for SlaveLink as it would attempt to switch database
+	// In GaussDB/PostgreSQL, schema is handled via search_path or table qualification
+	if link, err = d.SlaveLink(); err != nil {
+		return nil, err
+	}
+	result, err = d.DoSelect(ctx, link, structureSql)
+	if err != nil {
+		return nil, err
+	}
+	fields = make(map[string]*gdb.TableField)
+	var (
+		index         = 0
+		name          string
+		ok            bool
+		existingField *gdb.TableField
+	)
+	for _, m := range result {
+		name = m["field"].String()
+		// Merge duplicated fields, especially for key constraints.
+		// Priority: pri > uni > others
+		if existingField, ok = fields[name]; ok {
+			currentKey := m["key"].String()
+			// Merge key information with priority: pri > uni
+			if currentKey == "pri" || (currentKey == "uni" && existingField.Key != "pri") {
+				existingField.Key = currentKey
+			}
+			continue
+		}
+
+		var (
+			fieldType  string
+			dataType   = m["type"].String()
+			dataLength = m["length"].Int()
+		)
+		if dataLength > 0 {
+			fieldType = fmt.Sprintf("%s(%d)", dataType, dataLength)
+		} else {
+			fieldType = dataType
+		}
+
+		fields[name] = &gdb.TableField{
+			Index:   index,
+			Name:    name,
+			Type:    fieldType,
+			Null:    !m["null"].Bool(),
+			Key:     m["key"].String(),
+			Default: m["default_value"].Val(),
+			Comment: m["comment"].String(),
+		}
+		index++
+	}
+	return fields, nil
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_tables.go b/contrib/drivers/gaussdb/gaussdb_tables.go
new file mode 100644
index 000000000..77600f647
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_tables.go
@@ -0,0 +1,103 @@
+// 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 gaussdb
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gutil"
+)
+
+var (
+	tablesSqlTmp = `
+SELECT
+	c.relname
+FROM
+	pg_class c
+INNER JOIN pg_namespace n ON
+	c.relnamespace = n.oid
+WHERE
+	n.nspname = '%s'
+	AND c.relkind IN ('r', 'p')
+	%s
+ORDER BY
+	c.relname
+`
+
+	versionRegex = regexp.MustCompile(`PostgreSQL (\d+\.\d+)`)
+)
+
+func init() {
+	var err error
+	tablesSqlTmp, err = gdb.FormatMultiLineSqlToSingle(tablesSqlTmp)
+	if err != nil {
+		panic(err)
+	}
+}
+
+// Tables retrieves and returns the tables of current schema.
+// It's mainly used in cli tool chain for automatically generating the models.
+func (d *Driver) Tables(ctx context.Context, schema ...string) (tables []string, err error) {
+	var (
+		result     gdb.Result
+		usedSchema = gutil.GetOrDefaultStr(d.GetConfig().Namespace, schema...)
+	)
+	if usedSchema == "" {
+		usedSchema = defaultSchema
+	}
+	// DO NOT use `usedSchema` as parameter for function `SlaveLink`.
+	// Schema is already handled in usedSchema variable above
+	link, err := d.SlaveLink()
+	if err != nil {
+		return nil, err
+	}
+
+	useRelpartbound := ""
+	if gstr.CompareVersion(d.version(ctx, link), "10") >= 0 {
+		useRelpartbound = "AND c.relpartbound IS NULL"
+	}
+
+	var query = fmt.Sprintf(
+		tablesSqlTmp,
+		usedSchema,
+		useRelpartbound,
+	)
+
+	query, _ = gregex.ReplaceString(`[\n\r\s]+`, " ", gstr.Trim(query))
+	result, err = d.DoSelect(ctx, link, query)
+	if err != nil {
+		return
+	}
+	for _, m := range result {
+		for _, v := range m {
+			tables = append(tables, v.String())
+		}
+	}
+	return
+}
+
+// version checks and returns the database version.
+func (d *Driver) version(ctx context.Context, link gdb.Link) string {
+	result, err := d.DoSelect(ctx, link, "SELECT version();")
+	if err != nil {
+		return ""
+	}
+	if len(result) > 0 {
+		if v, ok := result[0]["version"]; ok {
+			matches := versionRegex.FindStringSubmatch(v.String())
+			if len(matches) >= 2 {
+				return matches[1]
+			}
+		}
+	}
+	return ""
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_z_unit_db_test.go b/contrib/drivers/gaussdb/gaussdb_z_unit_db_test.go
new file mode 100644
index 000000000..3156627ac
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_z_unit_db_test.go
@@ -0,0 +1,601 @@
+// 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 gaussdb_test
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_DB_Query(t *testing.T) {
+	table := createTable("name")
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		_, err := db.Query(ctx, fmt.Sprintf("select * from %s ", table))
+		t.AssertNil(err)
+	})
+}
+
+func Test_DB_Exec(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		_, err := db.Exec(ctx, fmt.Sprintf("select * from %s ", table))
+		t.AssertNil(err)
+	})
+}
+
+func Test_DB_Insert(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		_, err := db.Insert(ctx, table, g.Map{
+			"id":          1,
+			"passport":    "t1",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "T1",
+			"create_time": gtime.Now().String(),
+		})
+		t.AssertNil(err)
+		answer, err := db.GetAll(ctx, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1)
+		t.AssertNil(err)
+		t.Assert(len(answer), 1)
+		t.Assert(answer[0]["passport"], "t1")
+		t.Assert(answer[0]["password"], "25d55ad283aa400af464c76d713c07ad")
+		t.Assert(answer[0]["nickname"], "T1")
+
+		// normal map
+		result, err := db.Insert(ctx, table, g.Map{
+			"id":          "2",
+			"passport":    "t2",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_2",
+			"create_time": gtime.Now().String(),
+		})
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+		answer, err = db.GetAll(ctx, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 2)
+		t.AssertNil(err)
+		t.Assert(len(answer), 1)
+		t.Assert(answer[0]["passport"], "t2")
+		t.Assert(answer[0]["password"], "25d55ad283aa400af464c76d713c07ad")
+		t.Assert(answer[0]["nickname"], "name_2")
+	})
+}
+
+func Test_DB_Save(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		createTable("t_user")
+		defer dropTable("t_user")
+
+		i := 10
+		data := g.Map{
+			"id":          i,
+			"passport":    fmt.Sprintf(`t%d`, i),
+			"password":    fmt.Sprintf(`p%d`, i),
+			"nickname":    fmt.Sprintf(`T%d`, i),
+			"create_time": gtime.Now().String(),
+		}
+		_, err := db.Save(ctx, "t_user", data, 10)
+		gtest.AssertNil(err)
+	})
+}
+
+func Test_DB_Replace(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		createTable("t_user")
+		defer dropTable("t_user")
+
+		// Insert initial record
+		i := 10
+		data := g.Map{
+			"id":          i,
+			"passport":    fmt.Sprintf(`t%d`, i),
+			"password":    fmt.Sprintf(`p%d`, i),
+			"nickname":    fmt.Sprintf(`T%d`, i),
+			"create_time": gtime.Now().String(),
+		}
+		_, err := db.Insert(ctx, "t_user", data)
+		gtest.AssertNil(err)
+
+		// Replace with new data
+		data2 := g.Map{
+			"id":          i,
+			"passport":    fmt.Sprintf(`t%d_new`, i),
+			"password":    fmt.Sprintf(`p%d_new`, i),
+			"nickname":    fmt.Sprintf(`T%d_new`, i),
+			"create_time": gtime.Now().String(),
+		}
+		_, err = db.Replace(ctx, "t_user", data2)
+		gtest.AssertNil(err)
+
+		// Verify the data was replaced
+		one, err := db.GetOne(ctx, fmt.Sprintf("SELECT * FROM t_user WHERE id=?"), i)
+		gtest.AssertNil(err)
+		gtest.Assert(one["passport"].String(), fmt.Sprintf(`t%d_new`, i))
+		gtest.Assert(one["password"].String(), fmt.Sprintf(`p%d_new`, i))
+		gtest.Assert(one["nickname"].String(), fmt.Sprintf(`T%d_new`, i))
+	})
+}
+
+func Test_DB_GetAll(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.GetAll(ctx, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1)
+		t.AssertNil(err)
+		t.Assert(len(result), 1)
+		t.Assert(result[0]["id"].Int(), 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.GetAll(ctx, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), g.Slice{1})
+		t.AssertNil(err)
+		t.Assert(len(result), 1)
+		t.Assert(result[0]["id"].Int(), 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.GetAll(ctx, fmt.Sprintf("SELECT * FROM %s WHERE id in(?)", table), g.Slice{1, 2, 3})
+		t.AssertNil(err)
+		t.Assert(len(result), 3)
+		t.Assert(result[0]["id"].Int(), 1)
+		t.Assert(result[1]["id"].Int(), 2)
+		t.Assert(result[2]["id"].Int(), 3)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.GetAll(ctx, fmt.Sprintf("SELECT * FROM %s WHERE id in(?,?,?)", table), g.Slice{1, 2, 3})
+		t.AssertNil(err)
+		t.Assert(len(result), 3)
+		t.Assert(result[0]["id"].Int(), 1)
+		t.Assert(result[1]["id"].Int(), 2)
+		t.Assert(result[2]["id"].Int(), 3)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.GetAll(ctx, fmt.Sprintf("SELECT * FROM %s WHERE id in(?,?,?)", table), g.Slice{1, 2, 3}...)
+		t.AssertNil(err)
+		t.Assert(len(result), 3)
+		t.Assert(result[0]["id"].Int(), 1)
+		t.Assert(result[1]["id"].Int(), 2)
+		t.Assert(result[2]["id"].Int(), 3)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.GetAll(ctx, fmt.Sprintf("SELECT * FROM %s WHERE id>=? AND id <=?", table), g.Slice{1, 3})
+		t.AssertNil(err)
+		t.Assert(len(result), 3)
+		t.Assert(result[0]["id"].Int(), 1)
+		t.Assert(result[1]["id"].Int(), 2)
+		t.Assert(result[2]["id"].Int(), 3)
+	})
+}
+
+func Test_DB_GetOne(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			Nickname   string
+			CreateTime string
+		}
+		data := User{
+			Id:         1,
+			Passport:   "user_1",
+			Password:   "pass_1",
+			Nickname:   "name_1",
+			CreateTime: "2020-10-10 12:00:01",
+		}
+		_, err := db.Insert(ctx, table, data)
+		t.AssertNil(err)
+
+		one, err := db.GetOne(ctx, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1)
+		t.AssertNil(err)
+		t.Assert(one["passport"], data.Passport)
+		t.Assert(one["create_time"], data.CreateTime)
+		t.Assert(one["nickname"], data.Nickname)
+	})
+}
+
+func Test_DB_GetValue(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		value, err := db.GetValue(ctx, fmt.Sprintf("SELECT id FROM %s WHERE passport=?", table), "user_3")
+		t.AssertNil(err)
+		t.Assert(value.Int(), 3)
+	})
+}
+
+func Test_DB_GetCount(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.GetCount(ctx, fmt.Sprintf("SELECT * FROM %s", table))
+		t.AssertNil(err)
+		t.Assert(count, TableSize)
+	})
+}
+
+func Test_DB_GetArray(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		array, err := db.GetArray(ctx, fmt.Sprintf("SELECT password FROM %s", table))
+		t.AssertNil(err)
+		arrays := make([]string, 0)
+		for i := 1; i <= TableSize; i++ {
+			arrays = append(arrays, fmt.Sprintf(`pass_%d`, i))
+		}
+		t.Assert(array, arrays)
+	})
+}
+
+func Test_DB_GetScan(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime gtime.Time
+		}
+		user := new(User)
+		err := db.GetScan(ctx, user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3)
+		t.AssertNil(err)
+		t.Assert(user.NickName, "name_3")
+	})
+}
+
+func Test_DB_Update(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Update(ctx, table, "password='987654321'", "id=3")
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+
+		one, err := db.Model(table).Where("id", 3).One()
+		t.AssertNil(err)
+		t.Assert(one["id"].Int(), 3)
+		t.Assert(one["passport"].String(), "user_3")
+		t.Assert(one["password"].String(), "987654321")
+		t.Assert(one["nickname"].String(), "name_3")
+	})
+}
+
+func Test_DB_Delete(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Delete(ctx, table, "id>3")
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 7)
+	})
+}
+
+func Test_DB_Tables(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		tables := []string{"t_user1", "pop", "haha"}
+		for _, v := range tables {
+			createTable(v)
+		}
+		result, err := db.Tables(ctx)
+		gtest.AssertNil(err)
+		for i := 0; i < len(tables); i++ {
+			find := false
+			for j := 0; j < len(result); j++ {
+				if tables[i] == result[j] {
+					find = true
+					break
+				}
+			}
+			gtest.AssertEQ(find, true)
+		}
+	})
+}
+
+func Test_DB_TableFields(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		table := createTable()
+		defer dropTable(table)
+
+		var expect = map[string][]any{
+			// []string: Index Type Null Key Default Comment
+			// id is bigserial so the default is a pgsql function
+			"id":          {0, "int8(64)", false, "pri", fmt.Sprintf("nextval('%s_id_seq'::regclass)", table), ""},
+			"passport":    {1, "varchar(45)", false, "", nil, ""},
+			"password":    {2, "varchar(32)", false, "", nil, ""},
+			"nickname":    {3, "varchar(45)", false, "", nil, ""},
+			"create_time": {4, "timestamp", false, "", nil, ""},
+		}
+
+		res, err := db.TableFields(ctx, table)
+		gtest.AssertNil(err)
+
+		for k, v := range expect {
+			_, ok := res[k]
+			gtest.AssertEQ(ok, true)
+
+			gtest.AssertEQ(res[k].Index, v[0])
+			gtest.AssertEQ(res[k].Name, k)
+			gtest.AssertEQ(res[k].Type, v[1])
+			gtest.AssertEQ(res[k].Null, v[2])
+			gtest.AssertEQ(res[k].Key, v[3])
+			gtest.AssertEQ(res[k].Default, v[4])
+			gtest.AssertEQ(res[k].Comment, v[5])
+		}
+	})
+}
+
+func Test_NoFields_Error(t *testing.T) {
+	createSql := `CREATE TABLE IF NOT EXISTS %s (
+id bigint PRIMARY KEY,
+int_col INT);`
+
+	type Data struct {
+		Id     int64
+		IntCol int64
+	}
+	// pgsql converts table names to lowercase
+	// mark: [c.oid = '%s'::regclass] is not case-sensitive
+	tableName := "Error_table"
+	_, err := db.Exec(ctx, fmt.Sprintf(createSql, tableName))
+	gtest.AssertNil(err)
+	defer dropTable(tableName)
+
+	gtest.C(t, func(t *gtest.T) {
+		var data = Data{
+			Id:     2,
+			IntCol: 2,
+		}
+		_, err = db.Model(tableName).Data(data).Insert()
+		t.AssertNE(err, nil)
+
+		// Insert a piece of test data using lowercase
+		_, err = db.Model(strings.ToLower(tableName)).Data(data).Insert()
+		t.AssertNil(err)
+
+		_, err = db.Model(tableName).Where("id", 1).Data(g.Map{
+			"int_col": 9999,
+		}).Update()
+		t.AssertNE(err, nil)
+
+	})
+	// The inserted field does not exist in the table
+	gtest.C(t, func(t *gtest.T) {
+		data := map[string]any{
+			"id1":        22,
+			"int_col_22": 11111,
+		}
+		_, err = db.Model(tableName).Data(data).Insert()
+		t.Assert(err, fmt.Errorf(`input data match no fields in table "%s"`, tableName))
+
+		lowerTableName := strings.ToLower(tableName)
+		_, err = db.Model(lowerTableName).Data(data).Insert()
+		t.Assert(err, fmt.Errorf(`input data match no fields in table "%s"`, lowerTableName))
+
+		_, err = db.Model(lowerTableName).Where("id", 1).Data(g.Map{
+			"int_col-2": 9999,
+		}).Update()
+		t.Assert(err, fmt.Errorf(`input data match no fields in table "%s"`, lowerTableName))
+	})
+
+}
+
+func Test_DB_TableFields_DuplicateConstraints(t *testing.T) {
+	// Test for the fix of duplicate field results with multiple constraints
+	// This test verifies that when a field has multiple constraints (e.g., both primary key and unique),
+	// the TableFields method correctly merges the results with proper priority (pri > uni > others)
+	gtest.C(t, func(t *gtest.T) {
+		tableName := "test_multi_constraint"
+		createSql := fmt.Sprintf(`
+			CREATE TABLE %s (
+				id bigserial NOT NULL PRIMARY KEY,
+				email varchar(100) NOT NULL UNIQUE,
+				username varchar(50) NOT NULL,
+				status int NOT NULL DEFAULT 1
+			)`, tableName)
+
+		_, err := db.Exec(ctx, createSql)
+		t.AssertNil(err)
+		defer dropTable(tableName)
+
+		// Get table fields
+		fields, err := db.TableFields(ctx, tableName)
+		t.AssertNil(err)
+
+		// Verify id field has primary key constraint
+		t.AssertNE(fields["id"], nil)
+		t.Assert(fields["id"].Key, "pri")
+		t.Assert(fields["id"].Name, "id")
+		t.Assert(fields["id"].Type, "int8(64)")
+
+		// Verify email field has unique constraint
+		t.AssertNE(fields["email"], nil)
+		t.Assert(fields["email"].Key, "uni")
+		t.Assert(fields["email"].Name, "email")
+		t.Assert(fields["email"].Type, "varchar(100)")
+
+		// Verify username field has no constraint
+		t.AssertNE(fields["username"], nil)
+		t.Assert(fields["username"].Key, "")
+		t.Assert(fields["username"].Name, "username")
+
+		// Verify status field has no constraint and has default value
+		t.AssertNE(fields["status"], nil)
+		t.Assert(fields["status"].Key, "")
+		t.Assert(fields["status"].Name, "status")
+		t.Assert(fields["status"].Default, 1)
+
+		// Verify field count is correct (no duplicates)
+		t.Assert(len(fields), 4)
+	})
+
+	// Test table with composite constraints
+	gtest.C(t, func(t *gtest.T) {
+		tableName := "test_composite_constraint"
+		createSql := fmt.Sprintf(`
+			CREATE TABLE %s (
+				user_id bigint NOT NULL,
+				project_id bigint NOT NULL,
+				role varchar(50) NOT NULL,
+				PRIMARY KEY (user_id, project_id)
+			)`, tableName)
+
+		_, err := db.Exec(ctx, createSql)
+		t.AssertNil(err)
+		defer dropTable(tableName)
+
+		// Get table fields
+		fields, err := db.TableFields(ctx, tableName)
+		t.AssertNil(err)
+
+		// In PostgreSQL, composite primary keys may appear in query results
+		// The first field in the composite key should be marked as 'pri'
+		t.AssertNE(fields["user_id"], nil)
+		t.Assert(fields["user_id"].Name, "user_id")
+
+		t.AssertNE(fields["project_id"], nil)
+		t.Assert(fields["project_id"].Name, "project_id")
+
+		t.AssertNE(fields["role"], nil)
+		t.Assert(fields["role"].Name, "role")
+		t.Assert(fields["role"].Key, "")
+
+		// Verify field count is correct (no duplicates)
+		t.Assert(len(fields), 3)
+	})
+}
+
+func Test_DB_InsertIgnore(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	// Insert test record
+	gtest.C(t, func(t *gtest.T) {
+		_, err := db.Insert(ctx, table, g.Map{
+			"id":          1,
+			"passport":    "t1",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "T1",
+			"create_time": gtime.Now().String(),
+		})
+		t.AssertNil(err)
+
+		answer, err := db.GetAll(ctx, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1)
+		t.AssertNil(err)
+		t.Assert(len(answer), 1)
+		t.Assert(answer[0]["passport"], "t1")
+		t.Assert(answer[0]["password"], "25d55ad283aa400af464c76d713c07ad")
+		t.Assert(answer[0]["nickname"], "T1")
+
+		// Ignore Duplicate record
+		result, err := db.InsertIgnore(ctx, table, g.Map{
+			"id":          1,
+			"passport":    "t1_duplicate",
+			"password":    "duplicate_password",
+			"nickname":    "Duplicate",
+			"create_time": gtime.Now().String(),
+		})
+		t.AssertNil(err)
+
+		n, _ := result.RowsAffected()
+		t.Assert(n, 0)
+
+		answer, err = db.GetAll(ctx, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1)
+		t.AssertNil(err)
+		t.Assert(len(answer), 1)
+		t.Assert(answer[0]["passport"], "t1")
+		t.Assert(answer[0]["password"], "25d55ad283aa400af464c76d713c07ad")
+		t.Assert(answer[0]["nickname"], "T1")
+
+		// Insert Correct Record
+		result, err = db.Insert(ctx, table, g.Map{
+			"id":          2,
+			"passport":    "t2",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_2",
+			"create_time": gtime.Now().String(),
+		})
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+
+		answer, err = db.GetAll(ctx, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 2)
+		t.AssertNil(err)
+		t.Assert(len(answer), 1)
+		t.Assert(answer[0]["passport"], "t2")
+		t.Assert(answer[0]["password"], "25d55ad283aa400af464c76d713c07ad")
+		t.Assert(answer[0]["nickname"], "name_2")
+
+		// Insert Multiple Records Using g.Map Array
+		data := g.List{
+			{
+				"id":          3,
+				"passport":    "t3",
+				"password":    "25d55ad283aa400af464c76d713c07ad",
+				"nickname":    "name_3",
+				"create_time": gtime.Now().String(),
+			},
+			{
+				"id":          4,
+				"passport":    "t4",
+				"password":    "25d55ad283aa400af464c76d713c07ad",
+				"nickname":    "name_4",
+				"create_time": gtime.Now().String(),
+			},
+			{
+				"id":          1,
+				"passport":    "t1_conflict",
+				"password":    "conflict_password",
+				"nickname":    "conflict_name",
+				"create_time": gtime.Now().String(),
+			},
+			{
+				"id":          2,
+				"passport":    "t2_conflict",
+				"password":    "conflict_password",
+				"nickname":    "conflict_name",
+				"create_time": gtime.Now().String(),
+			},
+		}
+
+		// Insert Multiple Records with Ignore
+		result, err = db.InsertIgnore(ctx, table, data)
+		t.AssertNil(err)
+
+		n, _ = result.RowsAffected()
+		t.Assert(n, 2)
+
+		answer, err = db.GetAll(ctx, fmt.Sprintf("SELECT * FROM %s", table))
+		t.AssertNil(err)
+		t.Assert(len(answer), 4)
+		// Should have four records in total (ID 1, 2, 3, 4)
+
+		t.Assert(answer[0]["passport"], "t1")
+		t.Assert(answer[1]["passport"], "t2")
+		t.Assert(answer[2]["passport"], "t3")
+		t.Assert(answer[3]["passport"], "t4")
+	})
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_z_unit_field_test.go b/contrib/drivers/gaussdb/gaussdb_z_unit_field_test.go
new file mode 100644
index 000000000..cf0452046
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_z_unit_field_test.go
@@ -0,0 +1,955 @@
+// 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 gaussdb_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/google/uuid"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+// Test_TableFields tests the TableFields method for retrieving table field information
+func Test_TableFields(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		fields, err := db.TableFields(ctx, table)
+		t.AssertNil(err)
+		t.Assert(len(fields) > 0, true)
+
+		// Test primary key field
+		t.Assert(fields["id"].Name, "id")
+		t.Assert(fields["id"].Key, "pri")
+
+		// Test integer types
+		t.Assert(fields["col_int2"].Name, "col_int2")
+		t.Assert(fields["col_int4"].Name, "col_int4")
+		t.Assert(fields["col_int8"].Name, "col_int8")
+
+		// Test float types
+		t.Assert(fields["col_float4"].Name, "col_float4")
+		t.Assert(fields["col_float8"].Name, "col_float8")
+		t.Assert(fields["col_numeric"].Name, "col_numeric")
+
+		// Test character types
+		t.Assert(fields["col_char"].Name, "col_char")
+		t.Assert(fields["col_varchar"].Name, "col_varchar")
+		t.Assert(fields["col_text"].Name, "col_text")
+
+		// Test boolean type
+		t.Assert(fields["col_bool"].Name, "col_bool")
+
+		// Test date/time types
+		t.Assert(fields["col_date"].Name, "col_date")
+		t.Assert(fields["col_timestamp"].Name, "col_timestamp")
+
+		// Test JSON types
+		t.Assert(fields["col_json"].Name, "col_json")
+		t.Assert(fields["col_jsonb"].Name, "col_jsonb")
+
+		// Test array types
+		t.Assert(fields["col_int2_arr"].Name, "col_int2_arr")
+		t.Assert(fields["col_int4_arr"].Name, "col_int4_arr")
+		t.Assert(fields["col_varchar_arr"].Name, "col_varchar_arr")
+	})
+}
+
+// Test_TableFields_Types tests field type information
+func Test_TableFields_Types(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		fields, err := db.TableFields(ctx, table)
+		t.AssertNil(err)
+
+		// Test integer type names
+		t.Assert(fields["col_int2"].Type, "int2(16)")
+		t.Assert(fields["col_int4"].Type, "int4(32)")
+		t.Assert(fields["col_int8"].Type, "int8(64)")
+
+		// Test float type names
+		t.Assert(fields["col_float4"].Type, "float4(24)")
+		t.Assert(fields["col_float8"].Type, "float8(53)")
+		t.Assert(fields["col_numeric"].Type, "numeric(10)")
+
+		// Test character type names
+		t.Assert(fields["col_char"].Type, "bpchar(10)")
+		t.Assert(fields["col_varchar"].Type, "varchar(100)")
+		t.Assert(fields["col_text"].Type, "text")
+
+		// Test boolean type name
+		t.Assert(fields["col_bool"].Type, "bool")
+
+		// Test date/time type names
+		// Note: GaussDB internally represents date as timestamp in pg_type
+		t.Assert(fields["col_date"].Type, "timestamp")
+		t.Assert(fields["col_timestamp"].Type, "timestamp")
+		t.Assert(fields["col_timestamptz"].Type, "timestamptz")
+
+		// Test JSON type names
+		t.Assert(fields["col_json"].Type, "json")
+		t.Assert(fields["col_jsonb"].Type, "jsonb")
+
+		// Test array type names (PostgreSQL uses _ prefix for array types)
+		t.Assert(fields["col_int2_arr"].Type, "_int2")
+		t.Assert(fields["col_int4_arr"].Type, "_int4")
+		t.Assert(fields["col_int8_arr"].Type, "_int8")
+		t.Assert(fields["col_float4_arr"].Type, "_float4")
+		t.Assert(fields["col_float8_arr"].Type, "_float8")
+		t.Assert(fields["col_numeric_arr"].Type, "_numeric")
+		t.Assert(fields["col_varchar_arr"].Type, "_varchar")
+		t.Assert(fields["col_text_arr"].Type, "_text")
+		t.Assert(fields["col_bool_arr"].Type, "_bool")
+	})
+}
+
+// Test_TableFields_Nullable tests field nullable information
+func Test_TableFields_Nullable(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		fields, err := db.TableFields(ctx, table)
+		t.AssertNil(err)
+
+		// NOT NULL fields should have Null = false
+		t.Assert(fields["col_int2"].Null, false)
+		t.Assert(fields["col_int4"].Null, false)
+		t.Assert(fields["col_numeric"].Null, false)
+		t.Assert(fields["col_varchar"].Null, false)
+		t.Assert(fields["col_bool"].Null, false)
+		t.Assert(fields["col_varchar_arr"].Null, false)
+
+		// Nullable fields should have Null = true
+		t.Assert(fields["col_int8"].Null, true)
+		t.Assert(fields["col_text"].Null, true)
+		t.Assert(fields["col_json"].Null, true)
+	})
+}
+
+// Test_TableFields_Comments tests field comment information
+func Test_TableFields_Comments(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		fields, err := db.TableFields(ctx, table)
+		t.AssertNil(err)
+
+		// Test fields with comments
+		t.Assert(fields["id"].Comment, "Primary key ID")
+		t.Assert(fields["col_int2"].Comment, "int2 type (smallint)")
+		t.Assert(fields["col_int4"].Comment, "int4 type (integer)")
+		t.Assert(fields["col_int8"].Comment, "int8 type (bigint)")
+		t.Assert(fields["col_numeric"].Comment, "numeric type with precision")
+		t.Assert(fields["col_varchar"].Comment, "varchar type")
+		t.Assert(fields["col_bool"].Comment, "boolean type")
+		t.Assert(fields["col_timestamp"].Comment, "timestamp type")
+		t.Assert(fields["col_json"].Comment, "json type")
+		t.Assert(fields["col_jsonb"].Comment, "jsonb type")
+
+		// Test array field comments
+		t.Assert(fields["col_int2_arr"].Comment, "int2 array type (_int2)")
+		t.Assert(fields["col_int4_arr"].Comment, "int4 array type (_int4)")
+		t.Assert(fields["col_int8_arr"].Comment, "int8 array type (_int8)")
+		t.Assert(fields["col_numeric_arr"].Comment, "numeric array type (_numeric)")
+		t.Assert(fields["col_varchar_arr"].Comment, "varchar array type (_varchar)")
+		t.Assert(fields["col_text_arr"].Comment, "text array type (_text)")
+	})
+}
+
+// Test_Field_Type_Conversion tests type conversion for various PostgreSQL types
+func Test_Field_Type_Conversion(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query a single record
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+
+		// Test integer type conversions
+		t.Assert(one["col_int2"].Int(), 1)
+		t.Assert(one["col_int4"].Int(), 10)
+		t.Assert(one["col_int8"].Int64(), int64(100))
+
+		// Test float type conversions
+		t.Assert(one["col_float4"].Float32() > 0, true)
+		t.Assert(one["col_float8"].Float64() > 0, true)
+
+		// Test string type conversions
+		t.AssertNE(one["col_varchar"].String(), "")
+		t.AssertNE(one["col_text"].String(), "")
+
+		// Test boolean type conversion
+		t.Assert(one["col_bool"].Bool(), false) // i=1, 1%2==0 is false
+	})
+}
+
+// Test_Field_Array_Type_Conversion tests array type conversion
+func Test_Field_Array_Type_Conversion(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query a single record
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+
+		// Test integer array type conversions
+		int2Arr := one["col_int2_arr"].Ints()
+		t.Assert(len(int2Arr), 3)
+		t.Assert(int2Arr[0], 1)
+		t.Assert(int2Arr[1], 2)
+		t.Assert(int2Arr[2], 1)
+
+		int4Arr := one["col_int4_arr"].Ints()
+		t.Assert(len(int4Arr), 3)
+		t.Assert(int4Arr[0], 10)
+		t.Assert(int4Arr[1], 20)
+		t.Assert(int4Arr[2], 1)
+
+		int8Arr := one["col_int8_arr"].Int64s()
+		t.Assert(len(int8Arr), 3)
+		t.Assert(int8Arr[0], int64(100))
+		t.Assert(int8Arr[1], int64(200))
+		t.Assert(int8Arr[2], int64(1))
+
+		// Test string array type conversions
+		varcharArr := one["col_varchar_arr"].Strings()
+		t.Assert(len(varcharArr), 3)
+		t.Assert(varcharArr[0], "a")
+		t.Assert(varcharArr[1], "b")
+		t.Assert(varcharArr[2], "c1")
+
+		textArr := one["col_text_arr"].Strings()
+		t.Assert(len(textArr), 3)
+		t.Assert(textArr[0], "x")
+		t.Assert(textArr[1], "y")
+		t.Assert(textArr[2], "z1")
+
+		// Test boolean array type conversions
+		// col_bool_arr is '{true, false, %t}' where %t = i%2==0, for i=1 it's false
+		boolArr := one["col_bool_arr"].Bools()
+		t.Assert(len(boolArr), 3)
+		t.Assert(boolArr[0], true)  // literal true
+		t.Assert(boolArr[1], false) // literal false
+		t.Assert(boolArr[2], false) // i=1, 1%2==0 is false
+	})
+}
+
+// Test_Field_Array_Insert tests inserting array data
+func Test_Field_Array_Insert(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with array values
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_int2_arr":    []int{1, 2, 3},
+			"col_int4_arr":    []int{10, 20, 30},
+			"col_varchar_arr": []string{"a", "b", "c"},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		t.Assert(one["col_int2"].Int(), 1)
+		t.Assert(one["col_varchar"].String(), "test")
+		t.Assert(one["col_bool"].Bool(), true)
+
+		int2Arr := one["col_int2_arr"].Ints()
+		t.Assert(len(int2Arr), 3)
+		t.Assert(int2Arr[0], 1)
+		t.Assert(int2Arr[1], 2)
+		t.Assert(int2Arr[2], 3)
+
+		varcharArr := one["col_varchar_arr"].Strings()
+		t.Assert(len(varcharArr), 3)
+		t.Assert(varcharArr[0], "a")
+		t.Assert(varcharArr[1], "b")
+		t.Assert(varcharArr[2], "c")
+	})
+}
+
+// Test_Field_Array_Update tests updating array data
+func Test_Field_Array_Update(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Update array values
+		_, err := db.Model(table).Where("id", 1).Data(g.Map{
+			"col_int2_arr":    []int{100, 200, 300},
+			"col_varchar_arr": []string{"x", "y", "z"},
+		}).Update()
+		t.AssertNil(err)
+
+		// Query and verify
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+
+		int2Arr := one["col_int2_arr"].Ints()
+		t.Assert(len(int2Arr), 3)
+		t.Assert(int2Arr[0], 100)
+		t.Assert(int2Arr[1], 200)
+		t.Assert(int2Arr[2], 300)
+
+		varcharArr := one["col_varchar_arr"].Strings()
+		t.Assert(len(varcharArr), 3)
+		t.Assert(varcharArr[0], "x")
+		t.Assert(varcharArr[1], "y")
+		t.Assert(varcharArr[2], "z")
+	})
+}
+
+// Test_Field_JSON_Type tests JSON/JSONB type handling
+func Test_Field_JSON_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with JSON values
+		testData := g.Map{
+			"name":  "test",
+			"value": 123,
+			"items": []string{"a", "b", "c"},
+		}
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":    1,
+			"col_int4":    10,
+			"col_numeric": 99.99,
+			"col_varchar": "test",
+			"col_bool":    true,
+			"col_json":    testData,
+			"col_jsonb":   testData,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Test JSON field
+		jsonMap := one["col_json"].Map()
+		t.Assert(jsonMap["name"], "test")
+		t.Assert(jsonMap["value"], 123)
+
+		// Test JSONB field
+		jsonbMap := one["col_jsonb"].Map()
+		t.Assert(jsonbMap["name"], "test")
+		t.Assert(jsonbMap["value"], 123)
+	})
+}
+
+// Test_Field_Scan_To_Struct tests scanning results to struct
+func Test_Field_Scan_To_Struct(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	type TestRecord struct {
+		Id         int64    `json:"id"`
+		ColInt2    int16    `json:"col_int2"`
+		ColInt4    int32    `json:"col_int4"`
+		ColInt8    int64    `json:"col_int8"`
+		ColVarchar string   `json:"col_varchar"`
+		ColBool    bool     `json:"col_bool"`
+		ColInt2Arr []int    `json:"col_int2_arr"`
+		ColInt4Arr []int    `json:"col_int4_arr"`
+		ColInt8Arr []int64  `json:"col_int8_arr"`
+		ColTextArr []string `json:"col_text_arr"`
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		var record TestRecord
+		err := db.Model(table).Where("id", 1).Scan(&record)
+		t.AssertNil(err)
+
+		t.Assert(record.Id, int64(1))
+		t.Assert(record.ColInt2, int16(1))
+		t.Assert(record.ColInt4, int32(10))
+		t.Assert(record.ColInt8, int64(100))
+		t.AssertNE(record.ColVarchar, "")
+		t.Assert(record.ColBool, false)
+
+		// Test array fields scanned to struct
+		t.Assert(len(record.ColInt2Arr), 3)
+		t.Assert(record.ColInt2Arr[0], 1)
+		t.Assert(record.ColInt2Arr[1], 2)
+		t.Assert(record.ColInt2Arr[2], 1)
+
+		t.Assert(len(record.ColTextArr), 3)
+		t.Assert(record.ColTextArr[0], "x")
+		t.Assert(record.ColTextArr[1], "y")
+		t.Assert(record.ColTextArr[2], "z1")
+	})
+}
+
+// Test_Field_Scan_To_Struct_Slice tests scanning multiple results to struct slice
+func Test_Field_Scan_To_Struct_Slice(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	type TestRecord struct {
+		Id         int64    `json:"id"`
+		ColInt2    int16    `json:"col_int2"`
+		ColVarchar string   `json:"col_varchar"`
+		ColInt2Arr []int    `json:"col_int2_arr"`
+		ColTextArr []string `json:"col_text_arr"`
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		var records []TestRecord
+		err := db.Model(table).OrderAsc("id").Limit(5).Scan(&records)
+		t.AssertNil(err)
+
+		t.Assert(len(records), 5)
+
+		// Verify first record
+		t.Assert(records[0].Id, int64(1))
+		t.Assert(records[0].ColInt2, int16(1))
+		t.Assert(len(records[0].ColInt2Arr), 3)
+
+		// Verify last record
+		t.Assert(records[4].Id, int64(5))
+		t.Assert(records[4].ColInt2, int16(5))
+	})
+}
+
+// Test_Field_Empty_Array tests handling empty arrays
+func Test_Field_Empty_Array(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with empty array values (using default)
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":    1,
+			"col_int4":    10,
+			"col_numeric": 99.99,
+			"col_varchar": "test",
+			"col_bool":    true,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify empty arrays
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Default empty arrays
+		int2Arr := one["col_int2_arr"].Ints()
+		t.Assert(len(int2Arr), 0)
+
+		varcharArr := one["col_varchar_arr"].Strings()
+		t.Assert(len(varcharArr), 0)
+	})
+}
+
+// Test_Field_Null_Values tests handling NULL values
+func Test_Field_Null_Values(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert minimal required fields, leaving nullable fields as NULL
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_varchar_arr": []string{},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify NULL handling
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Nullable fields should return appropriate zero values
+		t.Assert(one["col_text"].IsNil() || one["col_text"].IsEmpty(), true)
+		t.Assert(one["col_int8_arr"].IsNil() || one["col_int8_arr"].IsEmpty(), true)
+	})
+}
+
+// Test_Field_Float_Array_Type_Conversion tests float array type conversion (_float4, _float8)
+func Test_Field_Float_Array_Type_Conversion(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query a single record
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+
+		// Test float4 array type conversions
+		float4Arr := one["col_float4_arr"].Float32s()
+		t.Assert(len(float4Arr), 3)
+		t.Assert(float4Arr[0] > 0, true)
+		t.Assert(float4Arr[1] > 0, true)
+
+		// Test float8 array type conversions
+		float8Arr := one["col_float8_arr"].Float64s()
+		t.Assert(len(float8Arr), 3)
+		t.Assert(float8Arr[0] > 0, true)
+		t.Assert(float8Arr[1] > 0, true)
+	})
+}
+
+// Test_Field_Numeric_Array_Type_Conversion tests numeric/decimal array type conversion
+func Test_Field_Numeric_Array_Type_Conversion(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query a single record
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+
+		// Test numeric array type conversions
+		numericArr := one["col_numeric_arr"].Float64s()
+		t.Assert(len(numericArr), 3)
+		t.Assert(numericArr[0] > 0, true)
+		t.Assert(numericArr[1] > 0, true)
+
+		// Test decimal array type conversions
+		decimalArr := one["col_decimal_arr"].Float64s()
+		if !one["col_decimal_arr"].IsNil() {
+			t.Assert(len(decimalArr) > 0, true)
+		}
+	})
+}
+
+// Test_Field_Bool_Array_Type_Conversion tests bool array type conversion more thoroughly
+func Test_Field_Bool_Array_Type_Conversion(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with specific bool array values
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":     1,
+			"col_int4":     10,
+			"col_numeric":  99.99,
+			"col_varchar":  "test",
+			"col_bool":     true,
+			"col_bool_arr": []bool{true, false, true},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Test bool array
+		boolArr := one["col_bool_arr"].Bools()
+		t.Assert(len(boolArr), 3)
+		t.Assert(boolArr[0], true)
+		t.Assert(boolArr[1], false)
+		t.Assert(boolArr[2], true)
+	})
+}
+
+// Test_Field_Char_Array_Type tests char array type (_char)
+func Test_Field_Char_Array_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with char array values
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_char_arr":    []string{"a", "b", "c"},
+			"col_varchar_arr": []string{},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Test char array
+		charArr := one["col_char_arr"].Strings()
+		t.Assert(len(charArr), 3)
+	})
+}
+
+// Test_Field_Bytea_Type tests bytea (binary) type conversion
+func Test_Field_Bytea_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with binary data
+		binaryData := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f} // "Hello" in hex
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_bytea":       binaryData,
+			"col_varchar_arr": []string{},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Test bytea field
+		result := one["col_bytea"].Bytes()
+		t.Assert(len(result), 5)
+		t.Assert(result[0], 0x48) // 'H'
+	})
+}
+
+// Test_Field_Bytea_Array_Type tests bytea array type (_bytea)
+func Test_Field_Bytea_Array_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with bytea array values using raw SQL
+		// PostgreSQL bytea array literal format: ARRAY[E'\\x010203', E'\\x040506']::bytea[]
+		_, err := db.Exec(ctx, fmt.Sprintf(`
+			INSERT INTO %s (col_int2, col_int4, col_numeric, col_varchar, col_bool, col_varchar_arr, col_bytea_arr)
+			VALUES (1, 10, 99.99, 'test', true, '{}', ARRAY[E'\\x010203', E'\\x040506']::bytea[])
+		`, table))
+		t.AssertNil(err)
+
+		// Query and verify bytea array
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Test bytea array field - should be converted to [][]byte
+		byteaArrVal := one["col_bytea_arr"]
+		t.Assert(byteaArrVal.IsNil(), false)
+
+		// Verify the array contains the expected data
+		byteaArr := byteaArrVal.Interfaces()
+		t.Assert(len(byteaArr), 2)
+	})
+}
+
+// Test_Field_Date_Array_Type tests date array type (_date)
+func Test_Field_Date_Array_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Note: PostgreSQL _date array is not yet mapped in the driver
+		// This test documents the limitation but can be extended when support is added
+
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_varchar_arr": []string{},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify NULL date array is handled gracefully
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+		// date array should be nil or empty
+		t.Assert(one["col_date_arr"].IsNil() || one["col_date_arr"].IsEmpty(), true)
+	})
+}
+
+// Test_Field_Timestamp_Array_Type tests timestamp array type (_timestamp)
+func Test_Field_Timestamp_Array_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Note: PostgreSQL _timestamp array is not yet mapped in the driver
+		// This test documents the limitation but can be extended when support is added
+
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_varchar_arr": []string{},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify NULL timestamp array is handled gracefully
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+		// timestamp array should be nil or empty
+		t.Assert(one["col_timestamp_arr"].IsNil() || one["col_timestamp_arr"].IsEmpty(), true)
+	})
+}
+
+// Test_Field_JSONB_Array_Type tests JSONB array type (_jsonb)
+func Test_Field_JSONB_Array_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Note: PostgreSQL _jsonb array is not yet mapped in the driver
+		// This test documents the limitation but can be extended when support is added
+
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_varchar_arr": []string{},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify NULL jsonb array is handled gracefully
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+		// jsonb array should be nil or empty
+		t.Assert(one["col_jsonb_arr"].IsNil() || one["col_jsonb_arr"].IsEmpty(), true)
+	})
+}
+
+// Test_Field_UUID_Array_Type tests UUID array type (_uuid)
+func Test_Field_UUID_Array_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with UUID array values using raw SQL
+		// PostgreSQL uuid array literal format: ARRAY['uuid1', 'uuid2']::uuid[]
+		uuid1 := "550e8400-e29b-41d4-a716-446655440000"
+		uuid2 := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+		uuid3 := "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
+		_, err := db.Exec(ctx, fmt.Sprintf(`
+			INSERT INTO %s (col_int2, col_int4, col_numeric, col_varchar, col_bool, col_varchar_arr, col_uuid_arr)
+			VALUES (1, 10, 99.99, 'test', true, '{}', ARRAY['%s', '%s', '%s']::uuid[])
+		`, table, uuid1, uuid2, uuid3))
+		t.AssertNil(err)
+
+		// Query and verify UUID array
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Test UUID array field - should be converted to []uuid.UUID
+		uuidArrVal := one["col_uuid_arr"]
+		t.Assert(uuidArrVal.IsNil(), false)
+
+		// Verify the array contains the expected data as []uuid.UUID
+		uuidArr := uuidArrVal.Interfaces()
+		t.Assert(len(uuidArr), 3)
+
+		// Verify each element is uuid.UUID type
+		u1, ok := uuidArr[0].(uuid.UUID)
+		t.Assert(ok, true)
+		t.Assert(u1.String(), uuid1)
+
+		u2, ok := uuidArr[1].(uuid.UUID)
+		t.Assert(ok, true)
+		t.Assert(u2.String(), uuid2)
+
+		u3, ok := uuidArr[2].(uuid.UUID)
+		t.Assert(ok, true)
+		t.Assert(u3.String(), uuid3)
+	})
+}
+
+// Test_Field_UUID_Type tests UUID type
+func Test_Field_UUID_Type(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query and verify UUID field
+		one, err := db.Model(table).OrderAsc("id").One()
+		t.AssertNil(err)
+
+		// Test UUID field - should be converted to uuid.UUID
+		uuidVal := one["col_uuid"]
+		t.Assert(uuidVal.IsNil(), false)
+
+		// Verify the value is uuid.UUID type
+		uuidObj, ok := uuidVal.Val().(uuid.UUID)
+		t.Assert(ok, true)
+
+		// Verify the UUID format
+		uuidStr := uuidObj.String()
+		t.Assert(len(uuidStr) > 0, true)
+		// UUID should contain the pattern from insert: 550e8400-e29b-41d4-a716-44665544000X
+		t.Assert(uuidStr, "550e8400-e29b-41d4-a716-446655440001")
+
+		// Also verify we can still get string representation via .String()
+		t.Assert(uuidVal.String(), "550e8400-e29b-41d4-a716-446655440001")
+	})
+}
+
+// Test_Field_Bytea_Array_Type_Scan tests bytea array type and scanning
+func Test_Field_Bytea_Array_Type_Scan(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query and verify bytea array field
+		one, err := db.Model(table).OrderAsc("id").One()
+		t.AssertNil(err)
+
+		// Test bytea array field
+		byteaArrVal := one["col_bytea_arr"]
+		// bytea array should not be nil since we inserted data
+		t.Assert(byteaArrVal.IsNil(), false)
+	})
+}
+
+// Test_Field_Date_Array_Type_Scan tests date array type and scanning
+func Test_Field_Date_Array_Type_Scan(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query and verify date array field
+		one, err := db.Model(table).OrderAsc("id").One()
+		t.AssertNil(err)
+
+		// Test date array field
+		dateArrVal := one["col_date_arr"]
+		t.Assert(dateArrVal.IsNil(), false)
+
+		// Verify the array contains the expected data
+		dateArr := dateArrVal.Strings()
+		t.Assert(len(dateArr) > 0, true)
+	})
+}
+
+// Test_Field_Timestamp_Array_Type_Scan tests timestamp array type and scanning
+func Test_Field_Timestamp_Array_Type_Scan(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query and verify timestamp array field
+		one, err := db.Model(table).OrderAsc("id").One()
+		t.AssertNil(err)
+
+		// Test timestamp array field
+		timestampArrVal := one["col_timestamp_arr"]
+		t.Assert(timestampArrVal.IsNil(), false)
+
+		// Verify the array contains the expected data
+		timestampArr := timestampArrVal.Strings()
+		t.Assert(len(timestampArr) > 0, true)
+	})
+}
+
+// Test_Field_JSONB_Array_Type_Scan tests JSONB array type and scanning
+func Test_Field_JSONB_Array_Type_Scan(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query and verify JSONB array field
+		one, err := db.Model(table).OrderAsc("id").One()
+		t.AssertNil(err)
+
+		// Test JSONB array field
+		jsonbArrVal := one["col_jsonb_arr"]
+		t.Assert(jsonbArrVal.IsNil(), false)
+	})
+}
+
+// Test_Field_UUID_Query tests querying by UUID field
+func Test_Field_UUID_Query(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test 1: Query by UUID string
+		uuidStr := "550e8400-e29b-41d4-a716-446655440001"
+		one, err := db.Model(table).Where("col_uuid", uuidStr).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+		t.Assert(one["id"].Int(), 1)
+
+		// Verify the returned UUID is correct
+		uuidObj, ok := one["col_uuid"].Val().(uuid.UUID)
+		t.Assert(ok, true)
+		t.Assert(uuidObj.String(), uuidStr)
+
+		// Test 2: Query by uuid.UUID type directly
+		uuidVal, err := uuid.Parse("550e8400-e29b-41d4-a716-446655440002")
+		t.AssertNil(err)
+		one, err = db.Model(table).Where("col_uuid", uuidVal).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+		t.Assert(one["id"].Int(), 2)
+
+		// Test 3: Query by UUID string using g.Map
+		one, err = db.Model(table).Where(g.Map{
+			"col_uuid": "550e8400-e29b-41d4-a716-446655440003",
+		}).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+		t.Assert(one["id"].Int(), 3)
+
+		// Test 4: Query by uuid.UUID type using g.Map
+		uuidVal, err = uuid.Parse("550e8400-e29b-41d4-a716-446655440004")
+		t.AssertNil(err)
+		one, err = db.Model(table).Where(g.Map{
+			"col_uuid": uuidVal,
+		}).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+		t.Assert(one["id"].Int(), 4)
+
+		// Test 5: Query non-existent UUID
+		one, err = db.Model(table).Where("col_uuid", "00000000-0000-0000-0000-000000000000").One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), true)
+
+		// Test 6: Query multiple records by UUID IN clause with strings
+		all, err := db.Model(table).WhereIn("col_uuid", g.Slice{
+			"550e8400-e29b-41d4-a716-446655440001",
+			"550e8400-e29b-41d4-a716-446655440002",
+		}).OrderAsc("id").All()
+		t.AssertNil(err)
+		t.Assert(len(all), 2)
+		t.Assert(all[0]["id"].Int(), 1)
+		t.Assert(all[1]["id"].Int(), 2)
+
+		// Test 7: Query multiple records by UUID IN clause with uuid.UUID types
+		uuid1, _ := uuid.Parse("550e8400-e29b-41d4-a716-446655440003")
+		uuid2, _ := uuid.Parse("550e8400-e29b-41d4-a716-446655440004")
+		all, err = db.Model(table).WhereIn("col_uuid", g.Slice{uuid1, uuid2}).OrderAsc("id").All()
+		t.AssertNil(err)
+		t.Assert(len(all), 2)
+		t.Assert(all[0]["id"].Int(), 3)
+		t.Assert(all[1]["id"].Int(), 4)
+	})
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_z_unit_filter_test.go b/contrib/drivers/gaussdb/gaussdb_z_unit_filter_test.go
new file mode 100644
index 000000000..0264c2388
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_z_unit_filter_test.go
@@ -0,0 +1,277 @@
+// 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 gaussdb_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/gogf/gf/v2/test/gtest"
+
+	"github.com/gogf/gf/contrib/drivers/gaussdb/v2"
+)
+
+// Test_DoFilter_LimitOffset tests LIMIT OFFSET conversion
+func Test_DoFilter_LimitOffset(t *testing.T) {
+	var (
+		ctx    = gctx.New()
+		driver = gaussdb.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test MySQL style LIMIT x,y to PostgreSQL style LIMIT y OFFSET x
+		sql := "SELECT * FROM users LIMIT 10, 20"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users LIMIT 20 OFFSET 10")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test with different numbers
+		sql := "SELECT * FROM users LIMIT 0, 100"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users LIMIT 100 OFFSET 0")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test no conversion needed
+		sql := "SELECT * FROM users LIMIT 50"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users LIMIT 50")
+	})
+}
+
+// Test_DoFilter_InsertIgnore tests INSERT IGNORE conversion
+func Test_DoFilter_InsertIgnore(t *testing.T) {
+	var (
+		ctx    = gctx.New()
+		driver = gaussdb.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test INSERT IGNORE conversion
+		// Note: GaussDB (PostgreSQL 9.2) does not support ON CONFLICT syntax (added in PG 9.5)
+		// GaussDB handles InsertIgnore at DoInsert level using MERGE statement
+		sql := "INSERT IGNORE INTO users (name) VALUES ($1)"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		// GaussDB removes IGNORE keyword but doesn't add ON CONFLICT (not supported)
+		t.Assert(newSql, "INSERT INTO users (name) VALUES ($1)")
+	})
+}
+
+// Test_DoFilter_PlaceholderConversion tests placeholder conversion
+func Test_DoFilter_PlaceholderConversion(t *testing.T) {
+	var (
+		ctx    = gctx.New()
+		driver = gaussdb.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test ? placeholder conversion to $n
+		sql := "SELECT * FROM users WHERE id = ? AND name = ?"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users WHERE id = $1 AND name = $2")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test multiple placeholders
+		sql := "INSERT INTO users (a, b, c, d, e) VALUES (?, ?, ?, ?, ?)"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "INSERT INTO users (a, b, c, d, e) VALUES ($1, $2, $3, $4, $5)")
+	})
+}
+
+// Test_DoFilter_JsonbOperator tests JSONB operator handling
+func Test_DoFilter_JsonbOperator(t *testing.T) {
+	var (
+		ctx    = gctx.New()
+		driver = gaussdb.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test jsonb ?| operator
+		// The jsonb ? is first converted to $1, then restored to ?
+		// So the next placeholder becomes $2
+		sql := "SELECT * FROM users WHERE (data)::jsonb ?| ?"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		// After placeholder conversion, the ? in jsonb should be preserved
+		t.Assert(newSql, "SELECT * FROM users WHERE (data)::jsonb ?| $2")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test jsonb ?& operator
+		sql := "SELECT * FROM users WHERE (data)::jsonb &? ?"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users WHERE (data)::jsonb &? $2")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test jsonb ? operator
+		sql := "SELECT * FROM users WHERE (data)::jsonb ? ?"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users WHERE (data)::jsonb ? $2")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test combination of jsonb and regular placeholders
+		sql := "SELECT * FROM users WHERE id = ? AND (data)::jsonb ?| ?"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users WHERE id = $1 AND (data)::jsonb ?| $3")
+	})
+}
+
+// Test_DoFilter_ComplexQuery tests complex queries with multiple features
+func Test_DoFilter_ComplexQuery(t *testing.T) {
+	var (
+		ctx    = gctx.New()
+		driver = gaussdb.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test complex query with LIMIT and placeholders
+		sql := "SELECT * FROM users WHERE status = ? AND age > ? LIMIT 5, 10"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users WHERE status = $1 AND age > $2 LIMIT 10 OFFSET 5")
+	})
+}
+
+// Test_Tables tests the Tables method
+func Test_Tables_Method(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		tables, err := db.Tables(ctx)
+		t.AssertNil(err)
+		t.Assert(len(tables) >= 0, true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test with specific schema - use the test schema
+		tables, err := db.Tables(ctx, "test")
+		t.AssertNil(err)
+		t.Assert(len(tables) >= 0, true)
+	})
+}
+
+// Test_OrderRandomFunction tests the OrderRandomFunction method
+func Test_OrderRandomFunction(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test ORDER BY RANDOM()
+		all, err := db.Model(table).OrderRandom().All()
+		t.AssertNil(err)
+		t.Assert(len(all), TableSize)
+	})
+}
+
+// Test_GetChars tests the GetChars method
+func Test_GetChars(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := gaussdb.Driver{}
+		left, right := driver.GetChars()
+		t.Assert(left, `"`)
+		t.Assert(right, `"`)
+	})
+}
+
+// Test_New tests the New method
+func Test_New(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := gaussdb.New()
+		t.AssertNE(driver, nil)
+	})
+}
+
+// Test_DoExec_NonIntPrimaryKey tests DoExec with non-integer primary key
+func Test_DoExec_NonIntPrimaryKey(t *testing.T) {
+	// Create a table with UUID primary key
+	tableName := "t_uuid_pk_test"
+	_, err := db.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS `+tableName+` (
+			id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+			name varchar(100)
+		)
+	`)
+	if err != nil {
+		// If gen_random_uuid is not available, skip this test
+		t.Log("Skipping UUID test:", err)
+		return
+	}
+	defer db.Exec(ctx, "DROP TABLE IF EXISTS "+tableName)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with UUID primary key
+		result, err := db.Model(tableName).Data(g.Map{
+			"name": "test_user",
+		}).Insert()
+		t.AssertNil(err)
+
+		// LastInsertId should return error for non-integer primary key
+		_, err = result.LastInsertId()
+		// For UUID, LastInsertId is not supported
+		t.AssertNE(err, nil)
+
+		// RowsAffected should still work
+		affected, err := result.RowsAffected()
+		t.AssertNil(err)
+		t.Assert(affected, int64(1))
+	})
+}
+
+// Test_TableFields_WithSchema tests TableFields with specific schema
+func Test_TableFields_WithSchema(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test with schema parameter
+		fields, err := db.TableFields(ctx, table, "test")
+		t.AssertNil(err)
+		t.Assert(len(fields) > 0, true)
+	})
+}
+
+// Test_TableFields_UniqueKey tests TableFields with unique key constraint
+func Test_TableFields_UniqueKey(t *testing.T) {
+	tableName := "t_unique_test"
+
+	// Create table with unique constraint
+	_, err := db.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS `+tableName+` (
+			id bigserial PRIMARY KEY,
+			email varchar(100) UNIQUE NOT NULL,
+			name varchar(100)
+		)
+	`)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer db.Exec(ctx, "DROP TABLE IF EXISTS "+tableName)
+
+	gtest.C(t, func(t *gtest.T) {
+		fields, err := db.TableFields(ctx, tableName)
+		t.AssertNil(err)
+
+		// Check primary key
+		t.Assert(fields["id"].Key, "pri")
+
+		// Check unique key
+		t.Assert(fields["email"].Key, "uni")
+	})
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_z_unit_init_test.go b/contrib/drivers/gaussdb/gaussdb_z_unit_init_test.go
new file mode 100644
index 000000000..abe8a74b4
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_z_unit_init_test.go
@@ -0,0 +1,339 @@
+// 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 gaussdb_test
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	_ "github.com/gogf/gf/contrib/drivers/gaussdb/v2"
+
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+const (
+	TableSize   = 10
+	TablePrefix = "t_"
+	SchemaName  = "test"
+	CreateTime  = "2018-10-24 10:00:00"
+)
+
+var (
+	db         gdb.DB
+	configNode gdb.ConfigNode
+	ctx        = context.TODO()
+)
+
+func init() {
+	configNode = gdb.ConfigNode{
+		Link:      `gaussdb:gaussdb:UTpass@1234@tcp(127.0.0.1:9950)/postgres`,
+		Namespace: SchemaName, // Set the schema namespace
+	}
+
+	// gaussdb only permit to connect to the designation database.
+	// so you need to create the gaussdb database before you use orm
+	gdb.AddConfigNode(gdb.DefaultGroupName, configNode)
+	if r, err := gdb.New(configNode); err != nil {
+		gtest.Fatal(err)
+	} else {
+		db = r
+	}
+
+	// Create schema if not exists
+	schemaTemplate := "CREATE SCHEMA IF NOT EXISTS %s"
+	if _, err := db.Exec(ctx, fmt.Sprintf(schemaTemplate, SchemaName)); err != nil {
+		gtest.Error(err)
+	}
+}
+
+func createTable(table ...string) string {
+	return createTableWithDb(db, table...)
+}
+
+func createInitTable(table ...string) string {
+	return createInitTableWithDb(db, table...)
+}
+
+func createTableWithDb(db gdb.DB, table ...string) (name string) {
+	if len(table) > 0 {
+		name = table[0]
+	} else {
+		name = fmt.Sprintf(`%s_%d`, TablePrefix+"test", gtime.TimestampNano())
+	}
+
+	dropTableWithDb(db, name)
+
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+		CREATE TABLE %s (
+		   	id bigserial  NOT NULL,
+		   	passport varchar(45) NOT NULL,
+		   	password varchar(32) NOT NULL,
+		   	nickname varchar(45) NOT NULL,
+		   	create_time timestamp NOT NULL,
+		    favorite_movie varchar[],
+		    favorite_music text[],
+			numeric_values numeric[],
+			decimal_values decimal[],
+		   	PRIMARY KEY (id)
+		) ;`, name,
+	)); err != nil {
+		gtest.Fatal(err)
+	}
+	return
+}
+
+func dropTable(table string) {
+	dropTableWithDb(db, table)
+}
+
+func createInitTableWithDb(db gdb.DB, table ...string) (name string) {
+	name = createTableWithDb(db, table...)
+	array := garray.New(true)
+	for i := 1; i <= TableSize; i++ {
+		array.Append(g.Map{
+			"id":          i,
+			"passport":    fmt.Sprintf(`user_%d`, i),
+			"password":    fmt.Sprintf(`pass_%d`, i),
+			"nickname":    fmt.Sprintf(`name_%d`, i),
+			"create_time": gtime.NewFromStr(CreateTime).String(),
+		})
+	}
+
+	result, err := db.Insert(ctx, name, array.Slice())
+	gtest.AssertNil(err)
+
+	n, e := result.RowsAffected()
+	gtest.Assert(e, nil)
+	gtest.Assert(n, TableSize)
+	return
+}
+
+func dropTableWithDb(db gdb.DB, table string) {
+	if _, err := db.Exec(ctx, fmt.Sprintf("DROP TABLE IF EXISTS %s", table)); err != nil {
+		gtest.Error(err)
+	}
+}
+
+// createAllTypesTable creates a table with all common PostgreSQL types for testing
+func createAllTypesTable(table ...string) string {
+	return createAllTypesTableWithDb(db, table...)
+}
+
+func createAllTypesTableWithDb(db gdb.DB, table ...string) (name string) {
+	if len(table) > 0 {
+		name = table[0]
+	} else {
+		name = fmt.Sprintf(`%s_%d`, TablePrefix+"all_types", gtime.TimestampNano())
+	}
+
+	dropTableWithDb(db, name)
+
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+		CREATE TABLE %s (
+			-- Basic integer types
+			id bigserial PRIMARY KEY,
+			col_int2 int2 NOT NULL DEFAULT 0,
+			col_int4 int4 NOT NULL DEFAULT 0,
+			col_int8 int8 DEFAULT 0,
+			col_smallint smallint,
+			col_integer integer,
+			col_bigint bigint,
+
+			-- Float types
+			col_float4 float4 DEFAULT 0.0,
+			col_float8 float8 DEFAULT 0.0,
+			col_real real,
+			col_double double precision,
+			col_numeric numeric(10,2) NOT NULL DEFAULT 0.00,
+			col_decimal decimal(10,2),
+
+			-- Character types
+			col_char char(10) DEFAULT '',
+			col_varchar varchar(100) NOT NULL DEFAULT '',
+			col_text text,
+
+			-- Boolean type
+			col_bool boolean NOT NULL DEFAULT false,
+
+			-- Date/Time types
+			col_date date DEFAULT CURRENT_DATE,
+			col_time time,
+			col_timetz timetz,
+			col_timestamp timestamp DEFAULT CURRENT_TIMESTAMP,
+			col_timestamptz timestamptz,
+			col_interval interval,
+
+			-- Binary type
+			col_bytea bytea,
+
+			-- JSON types
+			col_json json DEFAULT '{}',
+			col_jsonb jsonb DEFAULT '{}',
+
+			-- UUID type
+			col_uuid uuid,
+
+			-- Network types
+			col_inet inet,
+			col_cidr cidr,
+			col_macaddr macaddr,
+
+			-- Array types - integers
+			col_int2_arr int2[] DEFAULT '{}',
+			col_int4_arr int4[] DEFAULT '{}',
+			col_int8_arr int8[],
+
+			-- Array types - floats
+			col_float4_arr float4[],
+			col_float8_arr float8[],
+			col_numeric_arr numeric[] DEFAULT '{}',
+			col_decimal_arr decimal[],
+
+			-- Array types - characters
+			col_varchar_arr varchar[] NOT NULL DEFAULT '{}',
+			col_text_arr text[],
+			col_char_arr char(10)[],
+
+			-- Array types - boolean
+			col_bool_arr boolean[],
+
+			-- Array types - bytea
+			col_bytea_arr bytea[],
+
+			-- Array types - date/time
+			col_date_arr date[],
+			col_timestamp_arr timestamp[],
+
+			-- Array types - JSON
+			col_jsonb_arr jsonb[],
+
+			-- Array types - UUID
+			col_uuid_arr uuid[]
+		);
+
+		-- Add comments for columns
+		COMMENT ON TABLE %s IS 'Test table with all PostgreSQL types';
+		COMMENT ON COLUMN %s.id IS 'Primary key ID';
+		COMMENT ON COLUMN %s.col_int2 IS 'int2 type (smallint)';
+		COMMENT ON COLUMN %s.col_int4 IS 'int4 type (integer)';
+		COMMENT ON COLUMN %s.col_int8 IS 'int8 type (bigint)';
+		COMMENT ON COLUMN %s.col_numeric IS 'numeric type with precision';
+		COMMENT ON COLUMN %s.col_varchar IS 'varchar type';
+		COMMENT ON COLUMN %s.col_bool IS 'boolean type';
+		COMMENT ON COLUMN %s.col_timestamp IS 'timestamp type';
+		COMMENT ON COLUMN %s.col_json IS 'json type';
+		COMMENT ON COLUMN %s.col_jsonb IS 'jsonb type';
+		COMMENT ON COLUMN %s.col_int2_arr IS 'int2 array type (_int2)';
+		COMMENT ON COLUMN %s.col_int4_arr IS 'int4 array type (_int4)';
+		COMMENT ON COLUMN %s.col_int8_arr IS 'int8 array type (_int8)';
+		COMMENT ON COLUMN %s.col_numeric_arr IS 'numeric array type (_numeric)';
+		COMMENT ON COLUMN %s.col_varchar_arr IS 'varchar array type (_varchar)';
+		COMMENT ON COLUMN %s.col_text_arr IS 'text array type (_text)';
+		`, name,
+		name, name, name, name, name, name, name, name, name, name, name, name, name, name, name, name, name)); err != nil {
+		gtest.Fatal(err)
+	}
+	return
+}
+
+// createInitAllTypesTable creates and initializes a table with all common PostgreSQL types
+func createInitAllTypesTable(table ...string) string {
+	return createInitAllTypesTableWithDb(db, table...)
+}
+
+func createInitAllTypesTableWithDb(db gdb.DB, table ...string) (name string) {
+	name = createAllTypesTableWithDb(db, table...)
+
+	// Insert test data
+	for i := 1; i <= TableSize; i++ {
+		var sql strings.Builder
+
+		// Write INSERT statement header
+		sql.WriteString(fmt.Sprintf(`INSERT INTO %s (
+			col_int2, col_int4, col_int8, col_smallint, col_integer, col_bigint,
+			col_float4, col_float8, col_real, col_double, col_numeric, col_decimal,
+			col_char, col_varchar, col_text, col_bool,
+			col_date, col_time, col_timestamp,
+			col_json, col_jsonb,
+			col_bytea,
+			col_uuid,
+			col_int2_arr, col_int4_arr, col_int8_arr,
+			col_float4_arr, col_float8_arr, col_numeric_arr, col_decimal_arr,
+			col_varchar_arr, col_text_arr, col_bool_arr, col_bytea_arr, col_date_arr, col_timestamp_arr, col_jsonb_arr, col_uuid_arr
+		) VALUES (`, name))
+
+		// Integer types: col_int2, col_int4, col_int8, col_smallint, col_integer, col_bigint
+		sql.WriteString(fmt.Sprintf("%d, %d, %d, %d, %d, %d, ",
+			i, i*10, i*100, i, i*10, i*100))
+
+		// Float types: col_float4, col_float8, col_real, col_double, col_numeric, col_decimal
+		sql.WriteString(fmt.Sprintf("%d.5, %d.5, %d.5, %d.5, %d.99, %d.99, ",
+			i, i, i, i, i, i))
+
+		// Character types: col_char, col_varchar, col_text, col_bool
+		sql.WriteString(fmt.Sprintf("'char_%d', 'varchar_%d', 'text_%d', %t, ",
+			i, i, i, i%2 == 0))
+
+		// Date/Time types: col_date, col_time, col_timestamp
+		// Calculate day as integer in range 1-28; 28 is used because it is the maximum day value safe for all months to avoid date validity issues.
+		// %02d in fmt.Sprintf ensures two-digit zero-padded format
+		dayOfMonth := (i-1)%28 + 1
+		sql.WriteString(fmt.Sprintf("'2024-01-%02d', '10:00:%02d', '2024-01-%02d 10:00:00', ",
+			dayOfMonth, (i-1)%60, dayOfMonth))
+
+		// JSON types: col_json, col_jsonb
+		sql.WriteString(fmt.Sprintf(`'{"key": "value%d"}', '{"key": "value%d"}', `, i, i))
+
+		// Bytea type: col_bytea
+		sql.WriteString(`E'\\xDEADBEEF', `)
+
+		// UUID type: col_uuid (use %x for hex representation, padded to ensure valid UUID)
+		sql.WriteString(fmt.Sprintf("'550e8400-e29b-41d4-a716-4466554400%02x', ", i))
+
+		// Integer array types: col_int2_arr, col_int4_arr, col_int8_arr
+		sql.WriteString(fmt.Sprintf("'{1, 2, %d}', '{10, 20, %d}', '{100, 200, %d}', ",
+			i, i, i))
+
+		// Float array types: col_float4_arr, col_float8_arr, col_numeric_arr, col_decimal_arr
+		sql.WriteString(fmt.Sprintf("'{1.1, 2.2, %d.3}', '{1.1, 2.2, %d.3}', '{1.11, 2.22, %d.33}', '{1.11, 2.22, %d.33}', ",
+			i, i, i, i))
+
+		// Character array types: col_varchar_arr, col_text_arr
+		sql.WriteString(fmt.Sprintf(`'{"a", "b", "c%d"}', '{"x", "y", "z%d"}', `, i, i))
+
+		// Boolean array type: col_bool_arr
+		sql.WriteString(fmt.Sprintf("'{true, false, %t}', ", i%2 == 0))
+
+		// Bytea array type: col_bytea_arr (use ARRAY syntax for bytea)
+		sql.WriteString(`ARRAY[E'\\xDEADBEEF', E'\\xCAFEBABE']::bytea[], `)
+
+		// Date array type: col_date_arr
+		sql.WriteString(fmt.Sprintf(`'{"2024-01-%02d", "2024-01-%02d"}', `, dayOfMonth, (dayOfMonth%28)+1))
+
+		// Timestamp array type: col_timestamp_arr
+		sql.WriteString(fmt.Sprintf(`'{"2024-01-%02d 10:00:00", "2024-01-%02d 11:00:00"}', `, dayOfMonth, dayOfMonth))
+
+		// JSONB array type: col_jsonb_arr (store as text array first, then cast to jsonb array)
+		sql.WriteString(`ARRAY['{"key": "value1"}', '{"key": "value2"}']::jsonb[], `)
+
+		// UUID array type: col_uuid_arr
+		sql.WriteString(fmt.Sprintf("ARRAY['550e8400-e29b-41d4-a716-4466554400%02x'::uuid, '6ba7b810-9dad-11d1-80b4-00c04fd430c8'::uuid]", i))
+
+		// Close VALUES
+		sql.WriteString(")")
+
+		if _, err := db.Exec(ctx, sql.String()); err != nil {
+			gtest.Fatal(err)
+		}
+	}
+	return
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_z_unit_model_test.go b/contrib/drivers/gaussdb/gaussdb_z_unit_model_test.go
new file mode 100644
index 000000000..62b2b8ee6
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_z_unit_model_test.go
@@ -0,0 +1,864 @@
+// 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 gaussdb_test
+
+import (
+	"database/sql"
+	"fmt"
+	"testing"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_Model_Insert(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		user := db.Model(table)
+		result, err := user.Data(g.Map{
+			"id":          1,
+			"uid":         1,
+			"passport":    "t1",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_1",
+			"create_time": gtime.Now().String(),
+		}).Insert()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+
+		result, err = db.Model(table).Data(g.Map{
+			"id":          "2",
+			"uid":         "2",
+			"passport":    "t2",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_2",
+			"create_time": gtime.Now().String(),
+		}).Insert()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+
+		type User struct {
+			Id         int         `gconv:"id"`
+			Uid        int         `gconv:"uid"`
+			Passport   string      `json:"passport"`
+			Password   string      `gconv:"password"`
+			Nickname   string      `gconv:"nickname"`
+			CreateTime *gtime.Time `json:"create_time"`
+		}
+		// Model inserting.
+		result, err = db.Model(table).Data(User{
+			Id:         3,
+			Uid:        3,
+			Passport:   "t3",
+			Password:   "25d55ad283aa400af464c76d713c07ad",
+			Nickname:   "name_3",
+			CreateTime: gtime.Now(),
+		}).Insert()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+		value, err := db.Model(table).Fields("passport").Where("id=3").Value() // model value
+		t.AssertNil(err)
+		t.Assert(value.String(), "t3")
+
+		result, err = db.Model(table).Data(&User{
+			Id:         4,
+			Uid:        4,
+			Passport:   "t4",
+			Password:   "25d55ad283aa400af464c76d713c07ad",
+			Nickname:   "T4",
+			CreateTime: gtime.Now(),
+		}).Insert()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+		value, err = db.Model(table).Fields("passport").Where("id=4").Value()
+		t.AssertNil(err)
+		t.Assert(value.String(), "t4")
+
+		result, err = db.Model(table).Where("id>?", 1).Delete() // model delete
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 3)
+	})
+}
+
+func Test_Model_One(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			Nickname   string
+			CreateTime string
+		}
+		data := User{
+			Id:         1,
+			Passport:   "user_1",
+			Password:   "pass_1",
+			Nickname:   "name_1",
+			CreateTime: "2020-10-10 12:00:01",
+		}
+		_, err := db.Model(table).Data(data).Insert()
+		t.AssertNil(err)
+
+		one, err := db.Model(table).WherePri(1).One() // model one
+		t.AssertNil(err)
+		t.Assert(one["passport"], data.Passport)
+		t.Assert(one["create_time"], data.CreateTime)
+		t.Assert(one["nickname"], data.Nickname)
+	})
+}
+
+func Test_Model_All(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).All()
+		t.AssertNil(err)
+		t.Assert(len(result), TableSize)
+	})
+}
+
+func Test_Model_Delete(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Where("id", "2").Delete()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+}
+
+func Test_Model_Update(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	// Update + Data(string)
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Data("passport='user_33'").Where("passport='user_3'").Update()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+
+	// Update + Fields(string)
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Fields("passport").Data(g.Map{
+			"passport": "user_44",
+			"none":     "none",
+		}).Where("passport='user_4'").Update()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+}
+
+func Test_Model_Array(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model(table).Where("id", g.Slice{1, 2, 3}).All()
+		t.AssertNil(err)
+		t.Assert(all.Array("id"), g.Slice{1, 2, 3})
+		t.Assert(all.Array("nickname"), g.Slice{"name_1", "name_2", "name_3"})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array, err := db.Model(table).Fields("nickname").Where("id", g.Slice{1, 2, 3}).Array()
+		t.AssertNil(err)
+		t.Assert(array, g.Slice{"name_1", "name_2", "name_3"})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array, err := db.Model(table).Array("nickname", "id", g.Slice{1, 2, 3})
+		t.AssertNil(err)
+		t.Assert(array, g.Slice{"name_1", "name_2", "name_3"})
+	})
+}
+
+func Test_Model_Scan(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	type User struct {
+		Id         int
+		Passport   string
+		Password   string
+		NickName   string
+		CreateTime gtime.Time
+	}
+	gtest.C(t, func(t *gtest.T) {
+		var users []User
+		err := db.Model(table).Scan(&users)
+		t.AssertNil(err)
+		t.Assert(len(users), TableSize)
+	})
+}
+
+func Test_Model_Count(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(TableSize))
+	})
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.Model(table).FieldsEx("id").Where("id>8").Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(2))
+	})
+}
+
+func Test_Model_Exist(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		exist, err := db.Model(table).Exist()
+		t.AssertNil(err)
+		t.Assert(exist, TableSize > 0)
+		exist, err = db.Model(table).Where("id", -1).Exist()
+		t.AssertNil(err)
+		t.Assert(exist, false)
+	})
+}
+
+func Test_Model_Where(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	// map + slice parameter
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Where(g.Map{
+			"id":       g.Slice{1, 2, 3},
+			"passport": g.Slice{"user_2", "user_3"},
+		}).Where("id=? and nickname=?", g.Slice{3, "name_3"}).One()
+		t.AssertNil(err)
+		t.AssertGT(len(result), 0)
+		t.Assert(result["id"].Int(), 3)
+	})
+
+	// struct, automatic mapping and filtering.
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id       int
+			Nickname string
+		}
+		result, err := db.Model(table).Where(User{3, "name_3"}).One()
+		t.AssertNil(err)
+		t.Assert(result["id"].Int(), 3)
+
+		result, err = db.Model(table).Where(&User{3, "name_3"}).One()
+		t.AssertNil(err)
+		t.Assert(result["id"].Int(), 3)
+	})
+}
+
+func Test_Model_Save(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime *gtime.Time
+		}
+		var (
+			user   User
+			count  int
+			result sql.Result
+			err    error
+		)
+
+		result, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "p1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": CreateTime,
+		}).OnConflict("id").Save()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+
+		err = db.Model(table).Scan(&user)
+		t.AssertNil(err)
+		t.Assert(user.Id, 1)
+		t.Assert(user.Passport, "p1")
+		t.Assert(user.Password, "pw1")
+		t.Assert(user.NickName, "n1")
+		t.Assert(user.CreateTime.String(), CreateTime)
+
+		_, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "p1",
+			"password":    "pw2",
+			"nickname":    "n2",
+			"create_time": CreateTime,
+		}).OnConflict("id").Save()
+		t.AssertNil(err)
+
+		err = db.Model(table).Scan(&user)
+		t.AssertNil(err)
+		t.Assert(user.Passport, "p1")
+		t.Assert(user.Password, "pw2")
+		t.Assert(user.NickName, "n2")
+		t.Assert(user.CreateTime.String(), CreateTime)
+
+		count, err = db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, 1)
+	})
+}
+
+func Test_Model_Replace(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial record
+		result, err := db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "t1",
+			"password":    "pass1",
+			"nickname":    "T1",
+			"create_time": "2018-10-24 10:00:00",
+		}).Insert()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+
+		// Replace with new data
+		result, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "t11",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "T11",
+			"create_time": "2018-10-24 10:00:00",
+		}).Replace()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+
+		// Verify the data was replaced
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"].String(), "t11")
+		t.Assert(one["password"].String(), "25d55ad283aa400af464c76d713c07ad")
+		t.Assert(one["nickname"].String(), "T11")
+
+		// Replace with new ID (insert new record)
+		result, err = db.Model(table).Data(g.Map{
+			"id":          2,
+			"passport":    "t22",
+			"password":    "pass22",
+			"nickname":    "T22",
+			"create_time": "2018-10-24 11:00:00",
+		}).Replace()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+
+		// Verify new record was inserted
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, 2)
+	})
+}
+
+func Test_Model_OnConflict(t *testing.T) {
+	var (
+		table      = fmt.Sprintf(`%s_%d`, TablePrefix+"test", gtime.TimestampNano())
+		uniqueName = fmt.Sprintf(`%s_%d`, TablePrefix+"test_unique", gtime.TimestampNano())
+	)
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+		CREATE TABLE %s (
+		   	id bigserial  NOT NULL,
+		   	passport varchar(45) NOT NULL,
+		   	password varchar(32) NOT NULL,
+		   	nickname varchar(45) NOT NULL,
+		   	create_time timestamp NOT NULL,
+		   	PRIMARY KEY (id),
+			CONSTRAINT %s UNIQUE ("passport", "password")
+		) ;`, table, uniqueName,
+	)); err != nil {
+		gtest.Fatal(err)
+	}
+	defer dropTable(table)
+
+	// string type 1.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict("passport,password").Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["password"], data["password"])
+		t.Assert(one["nickname"], "n1")
+	})
+
+	// string type 2.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict("passport", "password").Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["password"], data["password"])
+		t.Assert(one["nickname"], "n1")
+	})
+
+	// slice.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict(g.Slice{"passport", "password"}).Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["password"], data["password"])
+		t.Assert(one["nickname"], "n1")
+	})
+}
+
+func Test_Model_OnDuplicate(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	// string type 1.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict("id").OnDuplicate("passport,password").Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["password"], data["password"])
+		t.Assert(one["nickname"], "name_1")
+	})
+
+	// string type 2.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict("id").OnDuplicate("passport", "password").Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["password"], data["password"])
+		t.Assert(one["nickname"], "name_1")
+	})
+
+	// slice.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict("id").OnDuplicate(g.Slice{"passport", "password"}).Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["password"], data["password"])
+		t.Assert(one["nickname"], "name_1")
+	})
+
+	// map.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict("id").OnDuplicate(g.Map{
+			"passport": "nickname",
+			"password": "nickname",
+		}).Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"], data["nickname"])
+		t.Assert(one["password"], data["nickname"])
+		t.Assert(one["nickname"], "name_1")
+	})
+
+	// map+raw.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.MapStrStr{
+			"id":          "1",
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict("id").OnDuplicate(g.Map{
+			"passport": gdb.Raw("CONCAT(EXCLUDED.passport, '1')"),
+			"password": gdb.Raw("CONCAT(EXCLUDED.password, '2')"),
+		}).Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"], data["passport"]+"1")
+		t.Assert(one["password"], data["password"]+"2")
+		t.Assert(one["nickname"], "name_1")
+	})
+}
+
+func Test_Model_OnDuplicateWithCounter(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict("id").OnDuplicate(g.Map{
+			"id": gdb.Counter{Field: "id", Value: 999999},
+		}).Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.AssertNil(one)
+	})
+}
+
+func Test_Model_OnDuplicateEx(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	// string type 1.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict("id").OnDuplicateEx("nickname,create_time").Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["password"], data["password"])
+		t.Assert(one["nickname"], "name_1")
+	})
+
+	// string type 2.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict("id").OnDuplicateEx("nickname", "create_time").Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["password"], data["password"])
+		t.Assert(one["nickname"], "name_1")
+	})
+
+	// slice.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict("id").OnDuplicateEx(g.Slice{"nickname", "create_time"}).Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["password"], data["password"])
+		t.Assert(one["nickname"], "name_1")
+	})
+
+	// map.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    "pp1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": "2016-06-06",
+		}
+		_, err := db.Model(table).OnConflict("id").OnDuplicateEx(g.Map{
+			"nickname":    "nickname",
+			"create_time": "nickname",
+		}).Data(data).Save()
+		t.AssertNil(err)
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"], data["passport"])
+		t.Assert(one["password"], data["password"])
+		t.Assert(one["nickname"], "name_1")
+	})
+}
+
+func Test_OrderRandom(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).OrderRandom().All()
+		t.AssertNil(err)
+		t.Assert(len(result), TableSize)
+	})
+}
+
+func Test_ConvertSliceString(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id            int
+			Passport      string
+			Password      string
+			NickName      string
+			CreateTime    *gtime.Time
+			FavoriteMovie []string
+			FavoriteMusic []string
+		}
+
+		var (
+			user  User
+			user2 User
+			err   error
+		)
+
+		// slice string not null
+		_, err = db.Model(table).Data(g.Map{
+			"id":             1,
+			"passport":       "p1",
+			"password":       "pw1",
+			"nickname":       "n1",
+			"create_time":    CreateTime,
+			"favorite_movie": g.Slice{"Iron-Man", "Spider-Man"},
+			"favorite_music": g.Slice{"Hey jude", "Let it be"},
+		}).Insert()
+		t.AssertNil(err)
+
+		err = db.Model(table).Where("id", 1).Scan(&user)
+		t.AssertNil(err)
+		t.Assert(len(user.FavoriteMusic), 2)
+		t.Assert(user.FavoriteMusic[0], "Hey jude")
+		t.Assert(user.FavoriteMusic[1], "Let it be")
+		t.Assert(len(user.FavoriteMovie), 2)
+		t.Assert(user.FavoriteMovie[0], "Iron-Man")
+		t.Assert(user.FavoriteMovie[1], "Spider-Man")
+
+		// slice string null
+		_, err = db.Model(table).Data(g.Map{
+			"id":          2,
+			"passport":    "p1",
+			"password":    "pw1",
+			"nickname":    "n1",
+			"create_time": CreateTime,
+		}).Insert()
+		t.AssertNil(err)
+
+		err = db.Model(table).Where("id", 2).Scan(&user2)
+		t.AssertNil(err)
+		t.Assert(user2.FavoriteMusic, nil)
+		t.Assert(len(user2.FavoriteMovie), 0)
+	})
+}
+
+func Test_ConvertSliceFloat64(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	type Args struct {
+		NumericValues []float64 `orm:"numeric_values"`
+		DecimalValues []float64 `orm:"decimal_values"`
+	}
+	type User struct {
+		Id         int         `orm:"id"`
+		Passport   string      `orm:"passport"`
+		Password   string      `json:"password"`
+		NickName   string      `json:"nickname"`
+		CreateTime *gtime.Time `json:"create_time"`
+		Args
+	}
+
+	tests := []struct {
+		name string
+		args Args
+	}{
+		{
+			name: "nil",
+			args: Args{
+				NumericValues: nil,
+				DecimalValues: nil,
+			},
+		},
+		{
+			name: "not nil",
+			args: Args{
+				NumericValues: []float64{1.1, 2.2, 3.3},
+				DecimalValues: []float64{1.1, 2.2, 3.3},
+			},
+		},
+		{
+			name: "not empty",
+			args: Args{
+				NumericValues: []float64{},
+				DecimalValues: []float64{},
+			},
+		},
+	}
+	now := gtime.New(CreateTime)
+	for i, tt := range tests {
+		gtest.C(t, func(t *gtest.T) {
+			user := User{
+				Id:         i + 1,
+				Passport:   fmt.Sprintf("test_%d", i+1),
+				Password:   fmt.Sprintf("pass_%d", i+1),
+				NickName:   fmt.Sprintf("name_%d", i+1),
+				CreateTime: now,
+				Args:       tt.args,
+			}
+
+			_, err := db.Model(table).OmitNilData().Insert(user)
+			t.AssertNil(err)
+			var got Args
+			err = db.Model(table).Where("id", user.Id).Limit(1).Scan(&got)
+			t.AssertNil(err)
+			t.AssertEQ(tt.args, got)
+		})
+	}
+}
+
+func Test_Model_InsertIgnore(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		user := db.Model(table)
+		result, err := user.Data(g.Map{
+			"id":          1,
+			"uid":         1,
+			"passport":    "t1",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_1",
+			"create_time": gtime.Now().String(),
+		}).Insert()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+
+		result, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"uid":         1,
+			"passport":    "t1",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_1",
+			"create_time": gtime.Now().String(),
+		}).Insert()
+		t.AssertNE(err, nil)
+
+		result, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"uid":         1,
+			"passport":    "t2",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_2",
+			"create_time": gtime.Now().String(),
+		}).InsertIgnore()
+		t.AssertNil(err)
+
+		n, _ = result.RowsAffected()
+		t.Assert(n, 0)
+
+		value, err := db.Model(table).Fields("passport").WherePri(1).Value()
+		t.AssertNil(err)
+		t.Assert(value.String(), "t1")
+
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, 1)
+
+		// pgsql support ignore without primary key
+		result, err = db.Model(table).Data(g.Map{
+			// "id":          1,
+			"uid":         1,
+			"passport":    "t2",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_2",
+			"create_time": gtime.Now().String(),
+		}).InsertIgnore()
+		t.AssertNil(err)
+
+		count, err = db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, 1)
+	})
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_z_unit_open_test.go b/contrib/drivers/gaussdb/gaussdb_z_unit_open_test.go
new file mode 100644
index 000000000..dfbff24a8
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_z_unit_open_test.go
@@ -0,0 +1,179 @@
+// 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 gaussdb_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/test/gtest"
+
+	"github.com/gogf/gf/contrib/drivers/gaussdb/v2"
+)
+
+// Test_Open tests the Open method with various configurations
+func Test_Open_WithNamespace(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := gaussdb.Driver{}
+		config := &gdb.ConfigNode{
+			User:      "postgres",
+			Pass:      "12345678",
+			Host:      "127.0.0.1",
+			Port:      "5432",
+			Name:      "test",
+			Namespace: "public",
+		}
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		t.AssertNE(db, nil)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
+
+// Test_Open_WithTimezone tests Open with timezone configuration
+func Test_Open_WithTimezone(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := gaussdb.Driver{}
+		config := &gdb.ConfigNode{
+			User:     "postgres",
+			Pass:     "12345678",
+			Host:     "127.0.0.1",
+			Port:     "5432",
+			Name:     "test",
+			Timezone: "Asia/Shanghai",
+		}
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		t.AssertNE(db, nil)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
+
+// Test_Open_WithExtra tests Open with extra configuration
+func Test_Open_WithExtra(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := gaussdb.Driver{}
+		config := &gdb.ConfigNode{
+			User:  "postgres",
+			Pass:  "12345678",
+			Host:  "127.0.0.1",
+			Port:  "5432",
+			Name:  "test",
+			Extra: "connect_timeout=10",
+		}
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		t.AssertNE(db, nil)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
+
+// Test_Open_WithInvalidExtra tests Open with invalid extra configuration
+func Test_Open_WithInvalidExtra(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := gaussdb.Driver{}
+		config := &gdb.ConfigNode{
+			User: "postgres",
+			Pass: "12345678",
+			Host: "127.0.0.1",
+			Port: "5432",
+			Name: "test",
+			// Invalid extra format with invalid URL encoding that will cause parse error
+			Extra: "%Q=%Q&b",
+		}
+		_, err := driver.Open(config)
+		t.AssertNE(err, nil)
+	})
+}
+
+// Test_Open_WithFullConfig tests Open with all configuration options
+func Test_Open_WithFullConfig(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := gaussdb.Driver{}
+		config := &gdb.ConfigNode{
+			User:      "postgres",
+			Pass:      "12345678",
+			Host:      "127.0.0.1",
+			Port:      "5432",
+			Name:      "test",
+			Namespace: "public",
+			Timezone:  "UTC",
+			Extra:     "connect_timeout=10",
+		}
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		t.AssertNE(db, nil)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
+
+// Test_Open_WithoutPort tests Open without port
+func Test_Open_WithoutPort(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := gaussdb.Driver{}
+		config := &gdb.ConfigNode{
+			User: "postgres",
+			Pass: "12345678",
+			Host: "127.0.0.1",
+			Name: "test",
+		}
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		t.AssertNE(db, nil)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
+
+// Test_Open_WithoutName tests Open without database name
+func Test_Open_WithoutName(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := gaussdb.Driver{}
+		config := &gdb.ConfigNode{
+			User: "postgres",
+			Pass: "12345678",
+			Host: "127.0.0.1",
+			Port: "5432",
+		}
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		t.AssertNE(db, nil)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
+
+// Test_Open_InvalidHost tests Open with invalid host
+func Test_Open_InvalidHost(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := gaussdb.Driver{}
+		config := &gdb.ConfigNode{
+			User: "postgres",
+			Pass: "12345678",
+			Host: "invalid_host_that_does_not_exist",
+			Port: "5432",
+			Name: "test",
+		}
+		// Note: sql.Open doesn't actually connect, so no error here
+		// The error would occur when actually using the connection
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_z_unit_raw_test.go b/contrib/drivers/gaussdb/gaussdb_z_unit_raw_test.go
new file mode 100644
index 000000000..4d9c2dcba
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_z_unit_raw_test.go
@@ -0,0 +1,99 @@
+// 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 gaussdb_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_Raw_Insert(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		user := db.Model(table)
+		result, err := user.Data(g.Map{
+			"passport":    "port_1",
+			"password":    "pass_1",
+			"nickname":    "name_1",
+			"create_time": gdb.Raw("now()"),
+		}).Insert()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+}
+
+func Test_Raw_BatchInsert(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		user := db.Model(table)
+		result, err := user.Data(
+			g.List{
+				g.Map{
+					"passport":    "port_2",
+					"password":    "pass_2",
+					"nickname":    "name_2",
+					"create_time": gdb.Raw("now()"),
+				},
+				g.Map{
+					"passport":    "port_4",
+					"password":    "pass_4",
+					"nickname":    "name_4",
+					"create_time": gdb.Raw("now()"),
+				},
+			},
+		).Insert()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 2)
+	})
+}
+
+func Test_Raw_Delete(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		user := db.Model(table)
+		result, err := user.Data(g.Map{
+			"id": gdb.Raw("id"),
+		}).Where("id", 1).Delete()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+}
+
+func Test_Raw_Update(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		user := db.Model(table)
+		result, err := user.Data(g.Map{
+			"id":          gdb.Raw("id+100"),
+			"create_time": gdb.Raw("now()"),
+		}).Where("id", 1).Update()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		user := db.Model(table)
+		n, err := user.Where("id", 101).Count()
+		t.AssertNil(err)
+		t.Assert(n, int64(1))
+	})
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_z_unit_test.go b/contrib/drivers/gaussdb/gaussdb_z_unit_test.go
new file mode 100644
index 000000000..3846d9313
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_z_unit_test.go
@@ -0,0 +1,106 @@
+// 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 gaussdb_test
+
+import (
+	"context"
+	"testing"
+
+	"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/test/gtest"
+
+	"github.com/gogf/gf/contrib/drivers/gaussdb/v2"
+)
+
+func Test_LastInsertId(t *testing.T) {
+	// err not nil
+	gtest.C(t, func(t *gtest.T) {
+		_, err := db.Model("notexist").Insert(g.List{
+			{"name": "user1"},
+			{"name": "user2"},
+			{"name": "user3"},
+		})
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		tableName := createTable()
+		defer dropTable(tableName)
+		res, err := db.Model(tableName).Insert(g.List{
+			{"passport": "user1", "password": "pwd", "nickname": "nickname", "create_time": CreateTime},
+			{"passport": "user2", "password": "pwd", "nickname": "nickname", "create_time": CreateTime},
+			{"passport": "user3", "password": "pwd", "nickname": "nickname", "create_time": CreateTime},
+		})
+		t.AssertNil(err)
+		lastInsertId, err := res.LastInsertId()
+		t.AssertNil(err)
+		t.Assert(lastInsertId, int64(3))
+		rowsAffected, err := res.RowsAffected()
+		t.AssertNil(err)
+		t.Assert(rowsAffected, int64(3))
+	})
+}
+
+func Test_TxLastInsertId(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		tableName := createTable()
+		defer dropTable(tableName)
+		err := db.Transaction(context.TODO(), func(ctx context.Context, tx gdb.TX) error {
+			// user
+			res, err := tx.Model(tableName).Insert(g.List{
+				{"passport": "user1", "password": "pwd", "nickname": "nickname", "create_time": CreateTime},
+				{"passport": "user2", "password": "pwd", "nickname": "nickname", "create_time": CreateTime},
+				{"passport": "user3", "password": "pwd", "nickname": "nickname", "create_time": CreateTime},
+			})
+			t.AssertNil(err)
+			lastInsertId, err := res.LastInsertId()
+			t.AssertNil(err)
+			t.AssertEQ(lastInsertId, int64(3))
+			rowsAffected, err := res.RowsAffected()
+			t.AssertNil(err)
+			t.AssertEQ(rowsAffected, int64(3))
+
+			res1, err := tx.Model(tableName).Insert(g.List{
+				{"passport": "user4", "password": "pwd", "nickname": "nickname", "create_time": CreateTime},
+				{"passport": "user5", "password": "pwd", "nickname": "nickname", "create_time": CreateTime},
+			})
+			t.AssertNil(err)
+			lastInsertId1, err := res1.LastInsertId()
+			t.AssertNil(err)
+			t.AssertEQ(lastInsertId1, int64(5))
+			rowsAffected1, err := res1.RowsAffected()
+			t.AssertNil(err)
+			t.AssertEQ(rowsAffected1, int64(2))
+			return nil
+
+		})
+		t.AssertNil(err)
+	})
+}
+
+func Test_Driver_DoFilter(t *testing.T) {
+	var (
+		ctx    = gctx.New()
+		driver = gaussdb.Driver{}
+	)
+	gtest.C(t, func(t *gtest.T) {
+		var data = g.Map{
+			`select * from user where (role)::jsonb ?| 'admin'`: `select * from user where (role)::jsonb ?| 'admin'`,
+			`select * from user where (role)::jsonb ?| '?'`:     `select * from user where (role)::jsonb ?| '$2'`,
+			`select * from user where (role)::jsonb &? '?'`:     `select * from user where (role)::jsonb &? '$2'`,
+			`select * from user where (role)::jsonb ? '?'`:      `select * from user where (role)::jsonb ? '$2'`,
+			`select * from user where '?'`:                      `select * from user where '$1'`,
+		}
+		for k, v := range data {
+			newSql, _, err := driver.DoFilter(ctx, nil, k, nil)
+			t.AssertNil(err)
+			t.Assert(newSql, v)
+		}
+	})
+}
diff --git a/contrib/drivers/gaussdb/gaussdb_z_unit_upsert_test.go b/contrib/drivers/gaussdb/gaussdb_z_unit_upsert_test.go
new file mode 100644
index 000000000..06e091a1a
--- /dev/null
+++ b/contrib/drivers/gaussdb/gaussdb_z_unit_upsert_test.go
@@ -0,0 +1,267 @@
+// 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 gaussdb_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+// Test_FormatUpsert_WithOnDuplicateStr tests FormatUpsert with OnDuplicateStr
+func Test_FormatUpsert_WithOnDuplicateStr(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial data
+		_, err := db.Model(table).Data(g.Map{
+			"passport":    "user1",
+			"password":    "pwd",
+			"nickname":    "nick1",
+			"create_time": CreateTime,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Test Save with OnConflict (upsert)
+		_, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "user1",
+			"password":    "newpwd",
+			"nickname":    "newnick",
+			"create_time": CreateTime,
+		}).OnConflict("id").Save()
+		t.AssertNil(err)
+
+		// Verify the update
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one["password"].String(), "newpwd")
+		t.Assert(one["nickname"].String(), "newnick")
+	})
+}
+
+// Test_FormatUpsert_WithOnDuplicateMap tests FormatUpsert with OnDuplicateMap
+func Test_FormatUpsert_WithOnDuplicateMap(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial data
+		_, err := db.Model(table).Data(g.Map{
+			"passport":    "user2",
+			"password":    "pwd",
+			"nickname":    "nick2",
+			"create_time": CreateTime,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Test OnDuplicate with map - values should be column names to use EXCLUDED.column
+		_, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "user2",
+			"password":    "newpwd2",
+			"nickname":    "newnick2",
+			"create_time": CreateTime,
+		}).OnConflict("id").OnDuplicate(g.Map{
+			"password": "password",
+			"nickname": "nickname",
+		}).Save()
+		t.AssertNil(err)
+
+		// Verify - values should be from the inserted data
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one["password"].String(), "newpwd2")
+		t.Assert(one["nickname"].String(), "newnick2")
+	})
+}
+
+// Test_FormatUpsert_WithCounter tests FormatUpsert with Counter type on numeric column.
+// Note: In PostgreSQL, Counter uses EXCLUDED.column which references the NEW value being inserted,
+// not the current table value. This differs from MySQL's ON DUPLICATE KEY UPDATE behavior.
+func Test_FormatUpsert_WithCounter(t *testing.T) {
+	// Create a special table with numeric id for counter test
+	tableName := "t_counter_test"
+	dropTable(tableName)
+	_, err := db.Exec(ctx, `
+		CREATE TABLE `+tableName+` (
+			id bigserial PRIMARY KEY,
+			counter_value int NOT NULL DEFAULT 0,
+			name varchar(45)
+		)
+	`)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer dropTable(tableName)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial data
+		_, err := db.Model(tableName).Data(g.Map{
+			"counter_value": 10,
+			"name":          "counter_test",
+		}).Insert()
+		t.AssertNil(err)
+
+		// Get initial ID
+		one, err := db.Model(tableName).Where("name", "counter_test").One()
+		t.AssertNil(err)
+		initialId := one["id"].Int64()
+
+		// Test OnDuplicate with Counter
+		// In PostgreSQL: counter_value = EXCLUDED.counter_value + 5
+		// EXCLUDED.counter_value is the value we're trying to insert (20)
+		// So result = 20 + 5 = 25
+		_, err = db.Model(tableName).Data(g.Map{
+			"id":            initialId,
+			"counter_value": 20, // This is the EXCLUDED value
+			"name":          "counter_test",
+		}).OnConflict("id").OnDuplicate(g.Map{
+			"counter_value": &gdb.Counter{
+				Field: "counter_value",
+				Value: 5,
+			},
+		}).Save()
+		t.AssertNil(err)
+
+		// Verify: EXCLUDED.counter_value(20) + 5 = 25
+		one, err = db.Model(tableName).Where("id", initialId).One()
+		t.AssertNil(err)
+		t.Assert(one["counter_value"].Int(), 25)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test Counter with negative value (decrement)
+		one, err := db.Model(tableName).Where("name", "counter_test").One()
+		t.AssertNil(err)
+		initialId := one["id"].Int64()
+
+		// In PostgreSQL: counter_value = EXCLUDED.counter_value - 3
+		// EXCLUDED.counter_value is 100, so result = 100 - 3 = 97
+		_, err = db.Model(tableName).Data(g.Map{
+			"id":            initialId,
+			"counter_value": 100, // This is the EXCLUDED value
+			"name":          "counter_test",
+		}).OnConflict("id").OnDuplicate(g.Map{
+			"counter_value": &gdb.Counter{
+				Field: "counter_value",
+				Value: -3,
+			},
+		}).Save()
+		t.AssertNil(err)
+
+		// Verify: EXCLUDED.counter_value(100) - 3 = 97
+		one, err = db.Model(tableName).Where("id", initialId).One()
+		t.AssertNil(err)
+		t.Assert(one["counter_value"].Int(), 97)
+	})
+}
+
+// Test_FormatUpsert_WithRaw tests FormatUpsert with Raw type
+func Test_FormatUpsert_WithRaw(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial data
+		_, err := db.Model(table).Data(g.Map{
+			"passport":    "raw_user",
+			"password":    "pwd",
+			"nickname":    "nick",
+			"create_time": CreateTime,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Get initial ID
+		one, err := db.Model(table).Where("passport", "raw_user").One()
+		t.AssertNil(err)
+		initialId := one["id"].Int64()
+
+		// Test OnDuplicate with Raw SQL
+		_, err = db.Model(table).Data(g.Map{
+			"id":          initialId,
+			"passport":    "raw_user",
+			"password":    "pwd",
+			"nickname":    "nick",
+			"create_time": CreateTime,
+		}).OnConflict("id").OnDuplicate(g.Map{
+			"password": gdb.Raw("'raw_password'"),
+		}).Save()
+		t.AssertNil(err)
+
+		// Verify
+		one, err = db.Model(table).Where("id", initialId).One()
+		t.AssertNil(err)
+		t.Assert(one["password"].String(), "raw_password")
+	})
+}
+
+// Test_FormatUpsert_NoOnConflict tests FormatUpsert without OnConflict (should fail)
+func Test_FormatUpsert_NoOnConflict(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial data
+		_, err := db.Model(table).Data(g.Map{
+			"passport":    "no_conflict_user",
+			"password":    "pwd",
+			"nickname":    "nick",
+			"create_time": CreateTime,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Try Save without OnConflict and without primary key in data - should fail
+		// because driver cannot auto-detect conflict columns when primary key is missing
+		_, err = db.Model(table).Data(g.Map{
+			// "id":          1,
+			"passport":    "no_conflict_user",
+			"password":    "newpwd",
+			"nickname":    "newnick",
+			"create_time": CreateTime,
+		}).Save()
+		t.AssertNE(err, nil)
+	})
+}
+
+// Test_FormatUpsert_MultipleConflictKeys tests FormatUpsert with multiple conflict keys
+func Test_FormatUpsert_MultipleConflictKeys(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial data
+		_, err := db.Model(table).Data(g.Map{
+			"passport":    "multi_key_user",
+			"password":    "pwd",
+			"nickname":    "nick",
+			"create_time": CreateTime,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Test with multiple conflict keys using only "id" which has a unique constraint
+		// Note: Using multiple keys requires a composite unique constraint to exist
+		_, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "multi_key_user",
+			"password":    "newpwd",
+			"nickname":    "newnick",
+			"create_time": CreateTime,
+		}).OnConflict("id").Save()
+		t.AssertNil(err)
+
+		// Verify the update
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one["password"].String(), "newpwd")
+		t.Assert(one["nickname"].String(), "newnick")
+	})
+}
diff --git a/contrib/drivers/gaussdb/go.mod b/contrib/drivers/gaussdb/go.mod
new file mode 100644
index 000000000..2a6f906ea
--- /dev/null
+++ b/contrib/drivers/gaussdb/go.mod
@@ -0,0 +1,46 @@
+module github.com/gogf/gf/contrib/drivers/gaussdb/v2
+
+go 1.23.0
+
+require (
+	gitee.com/opengauss/openGauss-connector-go-pq v1.0.7
+	github.com/gogf/gf/v2 v2.9.8
+	github.com/google/uuid v1.6.0
+)
+
+require (
+	github.com/BurntSushi/toml v1.5.0 // indirect
+	github.com/clbanning/mxj/v2 v2.7.0 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
+	github.com/fatih/color v1.18.0 // indirect
+	github.com/fsnotify/fsnotify v1.9.0 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/gorilla/websocket v1.5.3 // indirect
+	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
+	github.com/magiconair/properties v1.8.10 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/olekukonko/errors v1.1.0 // indirect
+	github.com/olekukonko/ll v0.0.9 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
+	github.com/tjfoc/gmsm v1.4.1 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/crypto v0.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/sys v0.35.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
+
+replace (
+	github.com/gogf/gf/contrib/drivers/mysql/v2 => ../mysql
+	github.com/gogf/gf/v2 => ../../../
+)
diff --git a/contrib/drivers/gaussdb/go.sum b/contrib/drivers/gaussdb/go.sum
new file mode 100644
index 000000000..d3266deaa
--- /dev/null
+++ b/contrib/drivers/gaussdb/go.sum
@@ -0,0 +1,169 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+gitee.com/opengauss/openGauss-connector-go-pq v1.0.7 h1:plLidoldV5RfMU6i/I+tvRKtP3sfDyUzQ//HGXLLsZo=
+gitee.com/opengauss/openGauss-connector-go-pq v1.0.7/go.mod h1:2UEp+ug6ls6C0pLfZgBn7VBzBntFUzxJuy+6FlQ7qyI=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
+github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyME=
+github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
+github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtgzltlQbOBae4=
+github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
+github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
+github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
+github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
+github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+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/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/tjfoc/gmsm v1.4.1 h1:aMe1GlZb+0bLjn+cKTPEvvn9oUEBlJitaZiiBwsbgho=
+github.com/tjfoc/gmsm v1.4.1/go.mod h1:j4INPkHWMrhJb38G+J6W4Tw0AbuN8Thu3PbdVYhVcTE=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20201012173705-84dcc777aaee/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20201010224723-4f7140c49acb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+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.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
diff --git a/contrib/drivers/mariadb/go.mod b/contrib/drivers/mariadb/go.mod
new file mode 100644
index 000000000..2dc871cab
--- /dev/null
+++ b/contrib/drivers/mariadb/go.mod
@@ -0,0 +1,44 @@
+module github.com/gogf/gf/contrib/drivers/mariadb/v2
+
+go 1.23.0
+
+require (
+	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.8
+	github.com/gogf/gf/v2 v2.9.8
+)
+
+require (
+	github.com/BurntSushi/toml v1.5.0 // indirect
+	github.com/clbanning/mxj/v2 v2.7.0 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
+	github.com/fatih/color v1.18.0 // indirect
+	github.com/fsnotify/fsnotify v1.9.0 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-sql-driver/mysql v1.7.1 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/gorilla/websocket v1.5.3 // indirect
+	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
+	github.com/magiconair/properties v1.8.10 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/olekukonko/errors v1.1.0 // indirect
+	github.com/olekukonko/ll v0.0.9 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/sys v0.35.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
+
+replace (
+	github.com/gogf/gf/contrib/drivers/mysql/v2 => ../mysql
+	github.com/gogf/gf/v2 => ../../../
+)
diff --git a/contrib/drivers/mariadb/go.sum b/contrib/drivers/mariadb/go.sum
new file mode 100644
index 000000000..f96db96f2
--- /dev/null
+++ b/contrib/drivers/mariadb/go.sum
@@ -0,0 +1,81 @@
+github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
+github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
+github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyME=
+github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
+github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
+github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
+github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtgzltlQbOBae4=
+github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
+github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
+github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
+github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
+github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/contrib/drivers/mariadb/mariadb.go b/contrib/drivers/mariadb/mariadb.go
new file mode 100644
index 000000000..02137db6c
--- /dev/null
+++ b/contrib/drivers/mariadb/mariadb.go
@@ -0,0 +1,61 @@
+// 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 mariadb implements gdb.Driver, which supports operations for database MariaDB.
+package mariadb
+
+import (
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+
+	"github.com/gogf/gf/contrib/drivers/mysql/v2"
+)
+
+// Driver is the driver for MariaDB database.
+//
+// MariaDB is a community-developed, commercially supported fork of the MySQL relational database.
+// This driver uses the MySQL protocol to communicate with MariaDB database, as MariaDB maintains
+// high compatibility with MySQL protocol.
+//
+// Although MariaDB is compatible with MySQL protocol, it is packaged as a separate driver component
+// rather than reusing the mysql adapter directly. This design allows for future extensibility,
+// such as implementing MariaDB-specific features or optimizations.
+type Driver struct {
+	*mysql.Driver
+}
+
+func init() {
+	var (
+		err         error
+		driverObj   = New()
+		driverNames = g.SliceStr{"mariadb"}
+	)
+	for _, driverName := range driverNames {
+		if err = gdb.Register(driverName, driverObj); err != nil {
+			panic(err)
+		}
+	}
+}
+
+// New creates and returns a driver that implements gdb.Driver, which supports operations for MariaDB.
+func New() gdb.Driver {
+	mysqlDriver := mysql.New().(*mysql.Driver)
+	return &Driver{
+		Driver: mysqlDriver,
+	}
+}
+
+// New creates and returns a database object for MariaDB.
+// It implements the interface of gdb.Driver for extra database driver installation.
+func (d *Driver) New(core *gdb.Core, node *gdb.ConfigNode) (gdb.DB, error) {
+	mysqlDB, err := d.Driver.New(core, node)
+	if err != nil {
+		return nil, err
+	}
+	return &Driver{
+		Driver: mysqlDB.(*mysql.Driver),
+	}, nil
+}
diff --git a/contrib/drivers/mariadb/mariadb_table_fields.go b/contrib/drivers/mariadb/mariadb_table_fields.go
new file mode 100644
index 000000000..492bb4bff
--- /dev/null
+++ b/contrib/drivers/mariadb/mariadb_table_fields.go
@@ -0,0 +1,83 @@
+// 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 mariadb
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/util/gutil"
+)
+
+var (
+	tableFieldsSqlByMariadb = `
+SELECT
+	c.COLUMN_NAME AS 'Field',
+	( CASE WHEN ch.CHECK_CLAUSE LIKE 'json_valid%%' THEN 'json' ELSE c.COLUMN_TYPE END ) AS 'Type',
+	c.COLLATION_NAME AS 'Collation',
+	c.IS_NULLABLE AS 'Null',
+	c.COLUMN_KEY AS 'Key',
+	( CASE WHEN c.COLUMN_DEFAULT = 'NULL' OR c.COLUMN_DEFAULT IS NULL THEN NULL ELSE c.COLUMN_DEFAULT END) AS 'Default',
+	c.EXTRA AS 'Extra',
+	c.PRIVILEGES AS 'Privileges',
+	c.COLUMN_COMMENT AS 'Comment' 
+FROM
+	information_schema.COLUMNS AS c
+	LEFT JOIN information_schema.CHECK_CONSTRAINTS AS ch ON c.TABLE_NAME = ch.TABLE_NAME 
+	AND c.TABLE_SCHEMA = ch.CONSTRAINT_SCHEMA
+	AND c.COLUMN_NAME = ch.CONSTRAINT_NAME 
+WHERE
+	c.TABLE_SCHEMA = '%s' 
+	AND c.TABLE_NAME = '%s'
+	ORDER BY c.ORDINAL_POSITION`
+)
+
+func init() {
+	var err error
+	tableFieldsSqlByMariadb, err = gdb.FormatMultiLineSqlToSingle(tableFieldsSqlByMariadb)
+	if err != nil {
+		panic(err)
+	}
+}
+
+// TableFields retrieves and returns the fields' information of specified table of current
+// schema.
+func (d *Driver) TableFields(
+	ctx context.Context, table string, schema ...string,
+) (fields map[string]*gdb.TableField, err error) {
+	var (
+		result     gdb.Result
+		link       gdb.Link
+		usedSchema = gutil.GetOrDefaultStr(d.GetSchema(), schema...)
+	)
+	if link, err = d.SlaveLink(usedSchema); err != nil {
+		return nil, err
+	}
+
+	result, err = d.DoSelect(
+		ctx, link,
+		fmt.Sprintf(tableFieldsSqlByMariadb, usedSchema, table),
+	)
+	if err != nil {
+		return nil, err
+	}
+	fields = make(map[string]*gdb.TableField)
+	for i, m := range result {
+		fields[m["Field"].String()] = &gdb.TableField{
+			Index:   i,
+			Name:    m["Field"].String(),
+			Type:    m["Type"].String(),
+			Null:    m["Null"].Bool(),
+			Key:     m["Key"].String(),
+			Default: m["Default"].Val(),
+			Extra:   m["Extra"].String(),
+			Comment: m["Comment"].String(),
+		}
+	}
+	return fields, nil
+}
diff --git a/contrib/drivers/mariadb/mariadb_unit_init_test.go b/contrib/drivers/mariadb/mariadb_unit_init_test.go
new file mode 100644
index 000000000..4d4e978a0
--- /dev/null
+++ b/contrib/drivers/mariadb/mariadb_unit_init_test.go
@@ -0,0 +1,128 @@
+// 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 mariadb_test
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	_ "github.com/gogf/gf/contrib/drivers/mariadb/v2"
+
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+const (
+	TableSize   = 10
+	TableName   = "user"
+	TestSchema1 = "test1"
+	TestSchema2 = "test2"
+	TestDbPass  = "12345678"
+	CreateTime  = "2018-10-24 10:00:00"
+)
+
+var (
+	db  gdb.DB
+	db2 gdb.DB
+	ctx = context.TODO()
+)
+
+func init() {
+	nodeDefault := gdb.ConfigNode{
+		ExecTimeout: time.Second * 2,
+		Link:        fmt.Sprintf("mariadb:root:%s@tcp(127.0.0.1:3307)/?loc=Local&parseTime=true", TestDbPass),
+		TranTimeout: time.Second * 3,
+	}
+	err := gdb.AddConfigNode(gdb.DefaultGroupName, nodeDefault)
+	if err != nil {
+		panic(err)
+	}
+
+	// Default db.
+	if r, err := gdb.NewByGroup(); err != nil {
+		gtest.Error(err)
+	} else {
+		db = r
+	}
+	schemaTemplate := "CREATE DATABASE IF NOT EXISTS `%s` CHARACTER SET UTF8"
+	if _, err := db.Exec(ctx, fmt.Sprintf(schemaTemplate, TestSchema1)); err != nil {
+		gtest.Error(err)
+	}
+	if _, err := db.Exec(ctx, fmt.Sprintf(schemaTemplate, TestSchema2)); err != nil {
+		gtest.Error(err)
+	}
+	db = db.Schema(TestSchema1)
+	db2 = db.Schema(TestSchema2)
+}
+
+func createTable(table ...string) string {
+	return createTableWithDb(db, table...)
+}
+
+func createInitTable(table ...string) string {
+	return createInitTableWithDb(db, table...)
+}
+
+func dropTable(table string) {
+	dropTableWithDb(db, table)
+}
+
+func createTableWithDb(db gdb.DB, table ...string) (name string) {
+	if len(table) > 0 {
+		name = table[0]
+	} else {
+		name = fmt.Sprintf(`%s_%d`, TableName, gtime.TimestampNano())
+	}
+	dropTableWithDb(db, name)
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+	    CREATE TABLE %s (
+	        id          int(10) unsigned NOT NULL AUTO_INCREMENT,
+	        passport    varchar(45) NULL,
+	        password    char(32) NULL,
+	        nickname    varchar(45) NULL,
+	        create_time timestamp(6) NULL,
+	        create_date       date NULL,
+	        PRIMARY KEY (id)
+	    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+	    `, name,
+	)); err != nil {
+		gtest.Fatal(err)
+	}
+	return name
+}
+
+func createInitTableWithDb(db gdb.DB, table ...string) (name string) {
+	name = createTableWithDb(db, table...)
+	array := garray.New(true)
+	for i := 1; i <= TableSize; i++ {
+		array.Append(g.Map{
+			"id":          i,
+			"passport":    fmt.Sprintf(`user_%d`, i),
+			"password":    fmt.Sprintf(`pass_%d`, i),
+			"nickname":    fmt.Sprintf(`name_%d`, i),
+			"create_time": gtime.NewFromStr(CreateTime).String(),
+		})
+	}
+
+	result, err := db.Insert(ctx, name, array.Slice())
+	gtest.AssertNil(err)
+
+	n, e := result.RowsAffected()
+	gtest.Assert(e, nil)
+	gtest.Assert(n, TableSize)
+	return
+}
+
+func dropTableWithDb(db gdb.DB, table string) {
+	if _, err := db.Exec(ctx, fmt.Sprintf("DROP TABLE IF EXISTS `%s`", table)); err != nil {
+		gtest.Error(err)
+	}
+}
diff --git a/contrib/drivers/mariadb/mariadb_unit_model_test.go b/contrib/drivers/mariadb/mariadb_unit_model_test.go
new file mode 100644
index 000000000..5b505b720
--- /dev/null
+++ b/contrib/drivers/mariadb/mariadb_unit_model_test.go
@@ -0,0 +1,1498 @@
+// 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 mariadb_test
+
+import (
+	"database/sql"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/guid"
+)
+
+func Test_Model_Insert(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		user := db.Model(table)
+		result, err := user.Data(g.Map{
+			"id":          1,
+			"uid":         1,
+			"passport":    "t1",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_1",
+			"create_time": gtime.Now().String(),
+		}).Insert()
+		t.AssertNil(err)
+		n, _ := result.LastInsertId()
+		t.Assert(n, 1)
+
+		result, err = db.Model(table).Data(g.Map{
+			"id":          "2",
+			"uid":         "2",
+			"passport":    "t2",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_2",
+			"create_time": gtime.Now().String(),
+		}).Insert()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+
+		type User struct {
+			Id         int         `gconv:"id"`
+			Uid        int         `gconv:"uid"`
+			Passport   string      `json:"passport"`
+			Password   string      `gconv:"password"`
+			Nickname   string      `gconv:"nickname"`
+			CreateTime *gtime.Time `json:"create_time"`
+		}
+		// Model inserting.
+		result, err = db.Model(table).Data(User{
+			Id:       3,
+			Uid:      3,
+			Passport: "t3",
+			Password: "25d55ad283aa400af464c76d713c07ad",
+			Nickname: "name_3",
+		}).Insert()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+		value, err := db.Model(table).Fields("passport").Where("id=3").Value()
+		t.AssertNil(err)
+		t.Assert(value.String(), "t3")
+
+		result, err = db.Model(table).Data(&User{
+			Id:         4,
+			Uid:        4,
+			Passport:   "t4",
+			Password:   "25d55ad283aa400af464c76d713c07ad",
+			Nickname:   "T4",
+			CreateTime: gtime.Now(),
+		}).Insert()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+		value, err = db.Model(table).Fields("passport").Where("id=4").Value()
+		t.AssertNil(err)
+		t.Assert(value.String(), "t4")
+
+		result, err = db.Model(table).Where("id>?", 1).Delete()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 3)
+	})
+}
+
+func Test_Model_InsertIgnore(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		_, err := db.Model(table).Data(g.Map{
+			"id":          1,
+			"uid":         1,
+			"passport":    "t1",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_1",
+			"create_time": gtime.Now().String(),
+		}).Insert()
+		t.AssertNE(err, nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		_, err := db.Model(table).Data(g.Map{
+			"id":          1,
+			"uid":         1,
+			"passport":    "t1",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_1",
+			"create_time": gtime.Now().String(),
+		}).InsertIgnore()
+		t.AssertNil(err)
+	})
+}
+
+func Test_Model_Batch(t *testing.T) {
+	// batch insert
+	gtest.C(t, func(t *gtest.T) {
+		table := createTable()
+		defer dropTable(table)
+		result, err := db.Model(table).Data(g.List{
+			{
+				"id":          2,
+				"uid":         2,
+				"passport":    "t2",
+				"password":    "25d55ad283aa400af464c76d713c07ad",
+				"nickname":    "name_2",
+				"create_time": gtime.Now().String(),
+			},
+			{
+				"id":          3,
+				"uid":         3,
+				"passport":    "t3",
+				"password":    "25d55ad283aa400af464c76d713c07ad",
+				"nickname":    "name_3",
+				"create_time": gtime.Now().String(),
+			},
+		}).Batch(1).Insert()
+		if err != nil {
+			gtest.Error(err)
+		}
+		n, _ := result.RowsAffected()
+		t.Assert(n, 2)
+	})
+
+	// batch insert, retrieving last insert auto-increment id.
+	gtest.C(t, func(t *gtest.T) {
+		table := createTable()
+		defer dropTable(table)
+		result, err := db.Model(table).Data(g.List{
+			{"passport": "t1"},
+			{"passport": "t2"},
+			{"passport": "t3"},
+			{"passport": "t4"},
+			{"passport": "t5"},
+		}).Batch(2).Insert()
+		if err != nil {
+			gtest.Error(err)
+		}
+		n, _ := result.RowsAffected()
+		t.Assert(n, 5)
+	})
+
+	// batch save
+	gtest.C(t, func(t *gtest.T) {
+		table := createInitTable()
+		defer dropTable(table)
+		result, err := db.Model(table).All()
+		t.AssertNil(err)
+		t.Assert(len(result), TableSize)
+		for _, v := range result {
+			v["nickname"].Set(v["nickname"].String() + v["id"].String())
+		}
+		r, e := db.Model(table).Data(result).Save()
+		t.Assert(e, nil)
+		n, e := r.RowsAffected()
+		t.Assert(e, nil)
+		t.Assert(n, TableSize*2)
+	})
+
+	// batch replace
+	gtest.C(t, func(t *gtest.T) {
+		table := createInitTable()
+		defer dropTable(table)
+		result, err := db.Model(table).All()
+		t.AssertNil(err)
+		t.Assert(len(result), TableSize)
+		for _, v := range result {
+			v["nickname"].Set(v["nickname"].String() + v["id"].String())
+		}
+		r, e := db.Model(table).Data(result).Replace()
+		t.Assert(e, nil)
+		n, e := r.RowsAffected()
+		t.Assert(e, nil)
+		t.Assert(n, TableSize*2)
+	})
+}
+
+func Test_Model_Replace(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "t11",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "T11",
+			"create_time": "2018-10-24 10:00:00",
+		}).Replace()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+}
+
+func Test_Model_Save(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "t111",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "T111",
+			"create_time": "2018-10-24 10:00:00",
+		}).Save()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+}
+
+func Test_Model_Update(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	// UPDATE...LIMIT
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Data("nickname", "T100").Where(1).Order("id desc").Limit(2).Update()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 2)
+
+		v1, err := db.Model(table).Fields("nickname").Where("id", 10).Value()
+		t.AssertNil(err)
+		t.Assert(v1.String(), "T100")
+
+		v2, err := db.Model(table).Fields("nickname").Where("id", 8).Value()
+		t.AssertNil(err)
+		t.Assert(v2.String(), "name_8")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Data("passport", "user_22").Where("passport=?", "user_2").Update()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Data("passport", "user_2").Where("passport='user_22'").Update()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+
+	// Update + Data(string)
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Data("passport='user_33'").Where("passport='user_3'").Update()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+	// Update + Fields(string)
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Fields("passport").Data(g.Map{
+			"passport": "user_44",
+			"none":     "none",
+		}).Where("passport='user_4'").Update()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+}
+
+func Test_Model_Clone(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		md := db.Model(table).Safe(true).Where("id IN(?)", g.Slice{1, 3})
+		count, err := md.Count()
+		t.AssertNil(err)
+
+		record, err := md.Safe(true).Order("id DESC").One()
+		t.AssertNil(err)
+
+		result, err := md.Safe(true).Order("id ASC").All()
+		t.AssertNil(err)
+
+		t.Assert(count, int64(2))
+		t.Assert(record["id"].Int(), 3)
+		t.Assert(len(result), 2)
+		t.Assert(result[0]["id"].Int(), 1)
+		t.Assert(result[1]["id"].Int(), 3)
+	})
+}
+
+func Test_Model_Safe(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		md := db.Model(table).Safe(false).Where("id IN(?)", g.Slice{1, 3})
+		count, err := md.Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(2))
+
+		md.Where("id = ?", 1)
+		count, err = md.Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(1))
+	})
+	gtest.C(t, func(t *gtest.T) {
+		md := db.Model(table).Safe(true).Where("id IN(?)", g.Slice{1, 3})
+		count, err := md.Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(2))
+
+		md.Where("id = ?", 1)
+		count, err = md.Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(2))
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		md := db.Model(table).Safe().Where("id IN(?)", g.Slice{1, 3})
+		count, err := md.Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(2))
+
+		md.Where("id = ?", 1)
+		count, err = md.Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(2))
+	})
+	gtest.C(t, func(t *gtest.T) {
+		md1 := db.Model(table).Safe()
+		md2 := md1.Where("id in (?)", g.Slice{1, 3})
+		count, err := md2.Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(2))
+
+		all, err := md2.All()
+		t.AssertNil(err)
+		t.Assert(len(all), 2)
+
+		all, err = md2.Page(1, 10).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		table := createInitTable()
+		defer dropTable(table)
+
+		md1 := db.Model(table).Where("id>", 0).Safe()
+		md2 := md1.Where("id in (?)", g.Slice{1, 3})
+		md3 := md1.Where("id in (?)", g.Slice{4, 5, 6})
+
+		// 1,3
+		count, err := md2.Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(2))
+
+		all, err := md2.Order("id asc").All()
+		t.AssertNil(err)
+		t.Assert(len(all), 2)
+		t.Assert(all[0]["id"].Int(), 1)
+		t.Assert(all[1]["id"].Int(), 3)
+
+		all, err = md2.Page(1, 10).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 2)
+
+		// 4,5,6
+		count, err = md3.Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(3))
+
+		all, err = md3.Order("id asc").All()
+		t.AssertNil(err)
+		t.Assert(len(all), 3)
+		t.Assert(all[0]["id"].Int(), 4)
+		t.Assert(all[1]["id"].Int(), 5)
+		t.Assert(all[2]["id"].Int(), 6)
+
+		all, err = md3.Page(1, 10).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 3)
+	})
+}
+
+func Test_Model_All(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).All()
+		t.AssertNil(err)
+		t.Assert(len(result), TableSize)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Where("id<0").All()
+		t.Assert(result, nil)
+		t.AssertNil(err)
+	})
+}
+
+func Test_Model_Fields(t *testing.T) {
+	tableName1 := createInitTable()
+	defer dropTable(tableName1)
+
+	tableName2 := "user_" + gtime.Now().TimestampNanoStr()
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+	    CREATE TABLE %s (
+	        id         int(10) unsigned NOT NULL AUTO_INCREMENT,
+	        name       varchar(45) NULL,
+			age        int(10) unsigned,
+	        PRIMARY KEY (id)
+	    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+	    `, tableName2,
+	)); err != nil {
+		gtest.AssertNil(err)
+	}
+	defer dropTable(tableName2)
+
+	r, err := db.Insert(ctx, tableName2, g.Map{
+		"id":   1,
+		"name": "table2_1",
+		"age":  18,
+	})
+	gtest.AssertNil(err)
+	n, _ := r.RowsAffected()
+	gtest.Assert(n, 1)
+
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model(tableName1).As("u").Fields("u.passport,u.id").Where("u.id<2").All()
+		t.AssertNil(err)
+		t.Assert(len(all), 1)
+		t.Assert(len(all[0]), 2)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model(tableName1).As("u1").
+			LeftJoin(tableName1, "u2", "u2.id=u1.id").
+			Fields("u1.passport,u1.id,u2.id AS u2id").
+			Where("u1.id<2").
+			All()
+		t.AssertNil(err)
+		t.Assert(len(all), 1)
+		t.Assert(len(all[0]), 3)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model(tableName1).As("u1").
+			LeftJoin(tableName2, "u2", "u2.id=u1.id").
+			Fields("u1.passport,u1.id,u2.name,u2.age").
+			Where("u1.id<2").
+			All()
+		t.AssertNil(err)
+		t.Assert(len(all), 1)
+		t.Assert(len(all[0]), 4)
+		t.Assert(all[0]["id"], 1)
+		t.Assert(all[0]["age"], 18)
+		t.Assert(all[0]["name"], "table2_1")
+		t.Assert(all[0]["passport"], "user_1")
+	})
+}
+
+func Test_Model_One(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		record, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(record["nickname"].String(), "name_1")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		record, err := db.Model(table).Where("id", 0).One()
+		t.AssertNil(err)
+		t.Assert(record, nil)
+	})
+}
+
+func Test_Model_Value(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		value, err := db.Model(table).Fields("nickname").Where("id", 1).Value()
+		t.AssertNil(err)
+		t.Assert(value.String(), "name_1")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		value, err := db.Model(table).Fields("nickname").Where("id", 0).Value()
+		t.AssertNil(err)
+		t.Assert(value, nil)
+	})
+}
+
+func Test_Model_Array(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model(table).Where("id", g.Slice{1, 2, 3}).All()
+		t.AssertNil(err)
+		t.Assert(all.Array("id"), g.Slice{1, 2, 3})
+		t.Assert(all.Array("nickname"), g.Slice{"name_1", "name_2", "name_3"})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		array, err := db.Model(table).Fields("nickname").Where("id", g.Slice{1, 2, 3}).Array()
+		t.AssertNil(err)
+		t.Assert(array, g.Slice{"name_1", "name_2", "name_3"})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array, err := db.Model(table).Array("nickname", "id", g.Slice{1, 2, 3})
+		t.AssertNil(err)
+		t.Assert(array, g.Slice{"name_1", "name_2", "name_3"})
+	})
+}
+
+func Test_Model_Count(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(TableSize))
+	})
+	// Count with cache, check internal ctx data feature.
+	gtest.C(t, func(t *gtest.T) {
+		for i := 0; i < 10; i++ {
+			count, err := db.Model(table).Cache(gdb.CacheOption{
+				Duration: time.Second * 10,
+				Name:     guid.S(),
+				Force:    false,
+			}).Count()
+			t.AssertNil(err)
+			t.Assert(count, int64(TableSize))
+		}
+	})
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.Model(table).FieldsEx("id").Where("id>8").Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(2))
+	})
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.Model(table).Fields("distinct id,nickname").Where("id>8").Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(2))
+	})
+	// COUNT...LIMIT...
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.Model(table).Page(1, 2).Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(TableSize))
+	})
+}
+
+func Test_Model_Exist(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		exist, err := db.Model(table).Exist()
+		t.AssertNil(err)
+		t.Assert(exist, TableSize > 0)
+		exist, err = db.Model(table).Where("id", -1).Exist()
+		t.AssertNil(err)
+		t.Assert(exist, false)
+	})
+}
+
+func Test_Model_Select(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	type User struct {
+		Id         int
+		Passport   string
+		Password   string
+		NickName   string
+		CreateTime gtime.Time
+	}
+	gtest.C(t, func(t *gtest.T) {
+		var users []User
+		err := db.Model(table).Scan(&users)
+		t.AssertNil(err)
+		t.Assert(len(users), TableSize)
+	})
+}
+
+func Test_Model_Struct(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime gtime.Time
+		}
+		user := new(User)
+		err := db.Model(table).Where("id=1").Scan(user)
+		t.AssertNil(err)
+		t.Assert(user.NickName, "name_1")
+		t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime *gtime.Time
+		}
+		user := new(User)
+		err := db.Model(table).Where("id=1").Scan(user)
+		t.AssertNil(err)
+		t.Assert(user.NickName, "name_1")
+		t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00")
+	})
+	// Auto creating struct object.
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime *gtime.Time
+		}
+		user := (*User)(nil)
+		err := db.Model(table).Where("id=1").Scan(&user)
+		t.AssertNil(err)
+		t.Assert(user.NickName, "name_1")
+		t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00")
+	})
+	// Just using Scan.
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime *gtime.Time
+		}
+		user := (*User)(nil)
+		err := db.Model(table).Where("id=1").Scan(&user)
+		if err != nil {
+			gtest.Error(err)
+		}
+		t.Assert(user.NickName, "name_1")
+		t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00")
+	})
+	// sql.ErrNoRows
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime *gtime.Time
+		}
+		user := new(User)
+		err := db.Model(table).Where("id=-1").Scan(user)
+		t.Assert(err, sql.ErrNoRows)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime *gtime.Time
+		}
+		var user *User
+		err := db.Model(table).Where("id=-1").Scan(&user)
+		t.AssertNil(err)
+	})
+}
+
+func Test_Model_Structs(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime gtime.Time
+		}
+		var users []User
+		err := db.Model(table).Order("id asc").Scan(&users)
+		if err != nil {
+			gtest.Error(err)
+		}
+		t.Assert(len(users), TableSize)
+		t.Assert(users[0].Id, 1)
+		t.Assert(users[1].Id, 2)
+		t.Assert(users[2].Id, 3)
+		t.Assert(users[0].NickName, "name_1")
+		t.Assert(users[1].NickName, "name_2")
+		t.Assert(users[2].NickName, "name_3")
+		t.Assert(users[0].CreateTime.String(), "2018-10-24 10:00:00")
+	})
+	// Auto create struct slice.
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime *gtime.Time
+		}
+		var users []*User
+		err := db.Model(table).Order("id asc").Scan(&users)
+		if err != nil {
+			gtest.Error(err)
+		}
+		t.Assert(len(users), TableSize)
+		t.Assert(users[0].Id, 1)
+		t.Assert(users[1].Id, 2)
+		t.Assert(users[2].Id, 3)
+		t.Assert(users[0].NickName, "name_1")
+		t.Assert(users[1].NickName, "name_2")
+		t.Assert(users[2].NickName, "name_3")
+		t.Assert(users[0].CreateTime.String(), "2018-10-24 10:00:00")
+	})
+	// Just using Scan.
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime *gtime.Time
+		}
+		var users []*User
+		err := db.Model(table).Order("id asc").Scan(&users)
+		if err != nil {
+			gtest.Error(err)
+		}
+		t.Assert(len(users), TableSize)
+		t.Assert(users[0].Id, 1)
+		t.Assert(users[1].Id, 2)
+		t.Assert(users[2].Id, 3)
+		t.Assert(users[0].NickName, "name_1")
+		t.Assert(users[1].NickName, "name_2")
+		t.Assert(users[2].NickName, "name_3")
+		t.Assert(users[0].CreateTime.String(), "2018-10-24 10:00:00")
+	})
+	// sql.ErrNoRows
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime *gtime.Time
+		}
+		var users []*User
+		err := db.Model(table).Where("id<0").Scan(&users)
+		t.AssertNil(err)
+	})
+}
+
+func Test_Model_Scan(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime gtime.Time
+		}
+		user := new(User)
+		err := db.Model(table).Where("id=1").Scan(user)
+		t.AssertNil(err)
+		t.Assert(user.NickName, "name_1")
+		t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime *gtime.Time
+		}
+		user := new(User)
+		err := db.Model(table).Where("id=1").Scan(user)
+		t.AssertNil(err)
+		t.Assert(user.NickName, "name_1")
+		t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime gtime.Time
+		}
+		var users []User
+		err := db.Model(table).Order("id asc").Scan(&users)
+		t.AssertNil(err)
+		t.Assert(len(users), TableSize)
+		t.Assert(users[0].Id, 1)
+		t.Assert(users[1].Id, 2)
+		t.Assert(users[2].Id, 3)
+		t.Assert(users[0].NickName, "name_1")
+		t.Assert(users[1].NickName, "name_2")
+		t.Assert(users[2].NickName, "name_3")
+		t.Assert(users[0].CreateTime.String(), "2018-10-24 10:00:00")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime *gtime.Time
+		}
+		var users []*User
+		err := db.Model(table).Order("id asc").Scan(&users)
+		t.AssertNil(err)
+		t.Assert(len(users), TableSize)
+		t.Assert(users[0].Id, 1)
+		t.Assert(users[1].Id, 2)
+		t.Assert(users[2].Id, 3)
+		t.Assert(users[0].NickName, "name_1")
+		t.Assert(users[1].NickName, "name_2")
+		t.Assert(users[2].NickName, "name_3")
+		t.Assert(users[0].CreateTime.String(), "2018-10-24 10:00:00")
+	})
+	// sql.ErrNoRows
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id         int
+			Passport   string
+			Password   string
+			NickName   string
+			CreateTime *gtime.Time
+		}
+		var (
+			user  = new(User)
+			users = new([]*User)
+		)
+		err1 := db.Model(table).Where("id < 0").Scan(user)
+		err2 := db.Model(table).Where("id < 0").Scan(users)
+		t.Assert(err1, sql.ErrNoRows)
+		t.Assert(err2, nil)
+	})
+}
+
+func Test_Model_OrderBy(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Order("id DESC").All()
+		t.AssertNil(err)
+		t.Assert(len(result), TableSize)
+		t.Assert(result[0]["nickname"].String(), fmt.Sprintf("name_%d", TableSize))
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Order(gdb.Raw("NULL")).All()
+		t.AssertNil(err)
+		t.Assert(len(result), TableSize)
+		t.Assert(result[0]["nickname"].String(), "name_1")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Order(gdb.Raw("field(id, 10,1,2,3,4,5,6,7,8,9)")).All()
+		t.AssertNil(err)
+		t.Assert(len(result), TableSize)
+		t.Assert(result[0]["nickname"].String(), "name_10")
+		t.Assert(result[1]["nickname"].String(), "name_1")
+		t.Assert(result[2]["nickname"].String(), "name_2")
+	})
+}
+
+func Test_Model_GroupBy(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Group("id").All()
+		t.AssertNil(err)
+		t.Assert(len(result), TableSize)
+		t.Assert(result[0]["nickname"].String(), "name_1")
+	})
+}
+
+func Test_Model_Data(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		table := createInitTable()
+		defer dropTable(table)
+		result, err := db.Model(table).Data("nickname=?", "test").Where("id=?", 3).Update()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		table := createTable()
+		defer dropTable(table)
+		users := make([]g.MapStrAny, 0)
+		for i := 1; i <= 10; i++ {
+			users = append(users, g.MapStrAny{
+				"id":       i,
+				"passport": fmt.Sprintf(`passport_%d`, i),
+				"password": fmt.Sprintf(`password_%d`, i),
+				"nickname": fmt.Sprintf(`nickname_%d`, i),
+			})
+		}
+		result, err := db.Model(table).Data(users).Batch(2).Insert()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 10)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		table := createTable()
+		defer dropTable(table)
+		users := garray.New()
+		for i := 1; i <= 10; i++ {
+			users.Append(g.MapStrAny{
+				"id":       i,
+				"passport": fmt.Sprintf(`passport_%d`, i),
+				"password": fmt.Sprintf(`password_%d`, i),
+				"nickname": fmt.Sprintf(`nickname_%d`, i),
+			})
+		}
+		result, err := db.Model(table).Data(users).Batch(2).Insert()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 10)
+	})
+}
+
+func Test_Model_Delete(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	// DELETE...LIMIT
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Where(1).Limit(2).Delete()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Where(1).Delete()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, TableSize-2)
+	})
+}
+
+func Test_Model_Offset(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Limit(2).Offset(5).Order("id").All()
+		t.AssertNil(err)
+		t.Assert(len(result), 2)
+		t.Assert(result[0]["id"], 6)
+		t.Assert(result[1]["id"], 7)
+	})
+}
+
+func Test_Model_Page(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Page(3, 3).Order("id").All()
+		t.AssertNil(err)
+		t.Assert(len(result), 3)
+		t.Assert(result[0]["id"], 7)
+		t.Assert(result[1]["id"], 8)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		model := db.Model(table).Safe().Order("id")
+		all, err := model.Page(3, 3).All()
+		count, err := model.Count()
+		t.AssertNil(err)
+		t.Assert(len(all), 3)
+		t.Assert(all[0]["id"], "7")
+		t.Assert(count, int64(TableSize))
+	})
+}
+
+func Test_Model_OmitEmpty(t *testing.T) {
+	table := fmt.Sprintf(`table_%s`, gtime.TimestampNanoStr())
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+    CREATE TABLE IF NOT EXISTS %s (
+        id int(10) unsigned NOT NULL AUTO_INCREMENT,
+        name varchar(45) NOT 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) {
+		_, err := db.Model(table).OmitEmpty().Data(g.Map{
+			"id":   1,
+			"name": "",
+		}).Save()
+		t.AssertNE(err, nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		_, err := db.Model(table).OmitEmptyData().Data(g.Map{
+			"id":   1,
+			"name": "",
+		}).Save()
+		t.AssertNE(err, nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		_, err := db.Model(table).OmitEmptyWhere().Data(g.Map{
+			"id":   1,
+			"name": "",
+		}).Save()
+		t.AssertNil(err)
+	})
+}
+
+func Test_Model_OmitNil(t *testing.T) {
+	table := fmt.Sprintf(`table_%s`, gtime.TimestampNanoStr())
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+    CREATE TABLE IF NOT EXISTS %s (
+        id int(10) unsigned NOT NULL AUTO_INCREMENT,
+        name varchar(45) NOT 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) {
+		_, err := db.Model(table).OmitNil().Data(g.Map{
+			"id":   1,
+			"name": nil,
+		}).Save()
+		t.AssertNE(err, nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		_, err := db.Model(table).OmitNil().Data(g.Map{
+			"id":   1,
+			"name": "",
+		}).Save()
+		t.AssertNil(err)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		_, err := db.Model(table).OmitNilWhere().Data(g.Map{
+			"id":   1,
+			"name": "",
+		}).Save()
+		t.AssertNil(err)
+	})
+}
+
+func Test_Model_FieldsEx(t *testing.T) {
+	table := createInitTable()
+	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()
+		t.AssertNil(err)
+		t.Assert(len(r), 2)
+		t.Assert(len(r[0]), 4)
+		t.Assert(r[0]["id"], "")
+		t.Assert(r[0]["passport"], "user_1")
+		t.Assert(r[0]["password"], "pass_1")
+		t.Assert(r[0]["nickname"], "name_1")
+		t.Assert(r[0]["create_time"], "")
+		t.Assert(r[1]["id"], "")
+		t.Assert(r[1]["passport"], "user_2")
+		t.Assert(r[1]["password"], "pass_2")
+		t.Assert(r[1]["nickname"], "name_2")
+		t.Assert(r[1]["create_time"], "")
+	})
+	// Update.
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.Model(table).FieldsEx("password").Data(g.Map{"nickname": "123", "password": "456"}).Where("id", 3).Update()
+		t.AssertNil(err)
+		n, _ := r.RowsAffected()
+		t.Assert(n, 1)
+
+		one, err := db.Model(table).Where("id", 3).One()
+		t.AssertNil(err)
+		t.Assert(one["nickname"], "123")
+		t.AssertNE(one["password"], "456")
+	})
+}
+
+func Test_Model_FieldsExStruct(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id       int    `orm:"id"       json:"id"`
+			Passport string `orm:"password" json:"pass_port"`
+			Password string `orm:"password" json:"password"`
+			NickName string `orm:"nickname" json:"nick__name"`
+		}
+		user := &User{
+			Id:       1,
+			Passport: "111",
+			Password: "222",
+			NickName: "333",
+		}
+		r, err := db.Model(table).FieldsEx("create_time, password").OmitEmpty().Data(user).Insert()
+		t.AssertNil(err)
+		n, err := r.RowsAffected()
+		t.AssertNil(err)
+		t.Assert(n, 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id       int    `orm:"id"       json:"id"`
+			Passport string `orm:"password" json:"pass_port"`
+			Password string `orm:"password" json:"password"`
+			NickName string `orm:"nickname" json:"nick__name"`
+		}
+		users := make([]*User, 0)
+		for i := 100; i < 110; i++ {
+			users = append(users, &User{
+				Id:       i,
+				Passport: fmt.Sprintf(`passport_%d`, i),
+				Password: fmt.Sprintf(`password_%d`, i),
+				NickName: fmt.Sprintf(`nickname_%d`, i),
+			})
+		}
+		r, err := db.Model(table).FieldsEx("create_time, password").
+			OmitEmpty().
+			Batch(2).
+			Data(users).
+			Insert()
+		t.AssertNil(err)
+		n, err := r.RowsAffected()
+		t.AssertNil(err)
+		t.Assert(n, 10)
+	})
+}
+
+func Test_Model_Join_SubQuery(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	gtest.C(t, func(t *gtest.T) {
+		subQuery := fmt.Sprintf("select * from `%s`", table)
+		r, err := db.Model(table, "t1").Fields("t2.id").LeftJoin(subQuery, "t2", "t2.id=t1.id").Array()
+		t.AssertNil(err)
+		t.Assert(len(r), TableSize)
+		t.Assert(r[0], "1")
+		t.Assert(r[TableSize-1], TableSize)
+	})
+}
+
+func Test_Model_Having(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model(table).Where("id > 1").Having("id > 8").All()
+		t.AssertNil(err)
+		t.Assert(len(all), 2)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model(table).Where("id > 1").Having("id > ?", 8).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 2)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model(table).Where("id > ?", 1).Having("id > ?", 8).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 2)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model(table).Where("id > ?", 1).Having("id", 8).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 1)
+	})
+}
+
+func Test_Model_Distinct(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.Model(table, "t").Fields("distinct t.id").Where("id > 1").Having("id > 8").All()
+		t.AssertNil(err)
+		t.Assert(len(all), 2)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.Model(table).Where("id > 1").Distinct().Count()
+		t.AssertNil(err)
+		t.Assert(count, int64(9))
+	})
+}
+
+func Test_Model_Min_Max(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		value, err := db.Model(table, "t").Fields("min(t.id)").Where("id > 1").Value()
+		t.AssertNil(err)
+		t.Assert(value.Int(), 2)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		value, err := db.Model(table, "t").Fields("max(t.id)").Where("id > 1").Value()
+		t.AssertNil(err)
+		t.Assert(value.Int(), 10)
+	})
+}
+
+func Test_Model_Fields_AutoMapping(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		value, err := db.Model(table).Fields("ID").Where("id", 2).Value()
+		t.AssertNil(err)
+		t.Assert(value.Int(), 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		value, err := db.Model(table).Fields("NICK_NAME").Where("id", 2).Value()
+		t.AssertNil(err)
+		t.Assert(value.String(), "name_2")
+	})
+	// Map
+	gtest.C(t, func(t *gtest.T) {
+		one, err := db.Model(table).Fields(g.Map{
+			"ID":        1,
+			"NICK_NAME": 1,
+		}).Where("id", 2).One()
+		t.AssertNil(err)
+		t.Assert(len(one), 2)
+		t.Assert(one["id"], 2)
+		t.Assert(one["nickname"], "name_2")
+	})
+	// Struct
+	gtest.C(t, func(t *gtest.T) {
+		type T struct {
+			ID       int
+			NICKNAME int
+		}
+		one, err := db.Model(table).Fields(&T{
+			ID:       0,
+			NICKNAME: 0,
+		}).Where("id", 2).One()
+		t.AssertNil(err)
+		t.Assert(len(one), 2)
+		t.Assert(one["id"], 2)
+		t.Assert(one["nickname"], "name_2")
+	})
+}
+
+func Test_Model_FieldsEx_AutoMapping(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	// "id":          i,
+	// "passport":    fmt.Sprintf(`user_%d`, i),
+	// "password":    fmt.Sprintf(`pass_%d`, i),
+	// "nickname":    fmt.Sprintf(`name_%d`, i),
+	// "create_time": gtime.NewFromStr("2018-10-24 10:00:00").String(),
+
+	gtest.C(t, func(t *gtest.T) {
+		value, err := db.Model(table).FieldsEx("create_date, Passport, Password, NickName, CreateTime").Where("id", 2).Value()
+		t.AssertNil(err)
+		t.Assert(value.Int(), 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		value, err := db.Model(table).FieldsEx("create_date, ID, Passport, Password, CreateTime").Where("id", 2).Value()
+		t.AssertNil(err)
+		t.Assert(value.String(), "name_2")
+	})
+	// Map
+	gtest.C(t, func(t *gtest.T) {
+		one, err := db.Model(table).FieldsEx(g.Map{
+			"Passport":   1,
+			"Password":   1,
+			"CreateTime": 1,
+		}).Where("id", 2).One()
+		t.AssertNil(err)
+		t.Assert(len(one), 3)
+		t.Assert(one["id"], 2)
+		t.Assert(one["nickname"], "name_2")
+	})
+	// Struct
+	gtest.C(t, func(t *gtest.T) {
+		type T struct {
+			Passport   int
+			Password   int
+			CreateTime int
+		}
+		one, err := db.Model(table).FieldsEx(&T{
+			Passport:   0,
+			Password:   0,
+			CreateTime: 0,
+		}).Where("id", 2).One()
+		t.AssertNil(err)
+		t.Assert(len(one), 3)
+		t.Assert(one["id"], 2)
+		t.Assert(one["nickname"], "name_2")
+	})
+}
+
+func Test_Model_Fields_Struct(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	type A struct {
+		Passport string
+		Password string
+	}
+	type B struct {
+		A
+		NickName string
+	}
+	gtest.C(t, func(t *gtest.T) {
+		one, err := db.Model(table).Fields(A{}).Where("id", 2).One()
+		t.AssertNil(err)
+		t.Assert(len(one), 2)
+		t.Assert(one["passport"], "user_2")
+		t.Assert(one["password"], "pass_2")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		one, err := db.Model(table).Fields(&A{}).Where("id", 2).One()
+		t.AssertNil(err)
+		t.Assert(len(one), 2)
+		t.Assert(one["passport"], "user_2")
+		t.Assert(one["password"], "pass_2")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		one, err := db.Model(table).Fields(B{}).Where("id", 2).One()
+		t.AssertNil(err)
+		t.Assert(len(one), 3)
+		t.Assert(one["passport"], "user_2")
+		t.Assert(one["password"], "pass_2")
+		t.Assert(one["nickname"], "name_2")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		one, err := db.Model(table).Fields(&B{}).Where("id", 2).One()
+		t.AssertNil(err)
+		t.Assert(len(one), 3)
+		t.Assert(one["passport"], "user_2")
+		t.Assert(one["password"], "pass_2")
+		t.Assert(one["nickname"], "name_2")
+	})
+}
+
+func Test_Model_HasTable(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		t.AssertNil(db.GetCore().ClearCacheAll(ctx))
+		result, err := db.GetCore().HasTable(table)
+		t.Assert(result, true)
+		t.AssertNil(err)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		t.AssertNil(db.GetCore().ClearCacheAll(ctx))
+		result, err := db.GetCore().HasTable("table12321")
+		t.Assert(result, false)
+		t.AssertNil(err)
+	})
+}
+
+func Test_Model_HasField(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).HasField("id")
+		t.Assert(result, true)
+		t.AssertNil(err)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).HasField("id123")
+		t.Assert(result, false)
+		t.AssertNil(err)
+	})
+}
+
+// https://github.com/gogf/gf/issues/4577
+// Test TableFields with multiple schemas having same table name with JSON field.
+// The bug: when JOIN information_schema.CHECK_CONSTRAINTS without schema filter,
+// MariaDB creates CHECK constraints for JSON fields (json_valid), causing duplicate rows
+// when multiple schemas have tables with same name and same JSON field name.
+// This leads to wrong field Index values.
+func Test_Issue4577_TableFields_MultipleSchema(t *testing.T) {
+	tableName := fmt.Sprintf("test_json_fields_%d", gtime.TimestampNano())
+
+	// Create table with JSON field in schema1 (3 columns)
+	createSQL1 := fmt.Sprintf(`
+		CREATE TABLE %s (
+			id          int(10) unsigned NOT NULL AUTO_INCREMENT,
+			name        varchar(45) NULL,
+			data        JSON NULL,
+			PRIMARY KEY (id)
+		) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+	`, tableName)
+
+	// Create table with JSON field in schema2 (5 columns - different structure)
+	// This is critical: different column count will cause Index overflow
+	createSQL2 := fmt.Sprintf(`
+		CREATE TABLE %s (
+			id          int(10) unsigned NOT NULL AUTO_INCREMENT,
+			name        varchar(45) NULL,
+			extra1      varchar(45) NULL,
+			extra2      varchar(45) NULL,
+			data        JSON NULL,
+			PRIMARY KEY (id)
+		) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+	`, tableName)
+
+	// Create table in schema test1 (db) - 3 columns
+	if _, err := db.Exec(ctx, createSQL1); err != nil {
+		gtest.Fatal(err)
+	}
+	defer func() {
+		db.Exec(ctx, fmt.Sprintf("DROP TABLE IF EXISTS %s", tableName))
+	}()
+
+	// Create table in schema test2 (db2) - 5 columns
+	if _, err := db2.Exec(ctx, createSQL2); err != nil {
+		gtest.Fatal(err)
+	}
+	defer func() {
+		db2.Exec(ctx, fmt.Sprintf("DROP TABLE IF EXISTS %s", tableName))
+	}()
+
+	gtest.C(t, func(t *gtest.T) {
+		// Clear any cached table fields to ensure fresh query
+		db.GetCore().ClearTableFieldsAll(ctx)
+		db2.GetCore().ClearTableFieldsAll(ctx)
+
+		// Get fields from test1 schema (should have 3 columns)
+		fields1, err := db.TableFields(ctx, tableName)
+		t.AssertNil(err)
+		t.Assert(len(fields1), 3)
+
+		// Check the 'data' field's Index - this is the critical check
+		// Without the fix (missing c.TABLE_SCHEMA = ch.CONSTRAINT_SCHEMA),
+		// the 'data' field's Index would be 3 (due to duplicate row from schema2's CHECK constraint)
+		// which is >= 3 and would cause array out of bounds during Scan
+		dataField := fields1["data"]
+		t.Assert(dataField.Index, 2)
+
+		// Verify JSON field type is correctly detected as 'json'
+		t.Assert(fields1["data"].Type, "json")
+
+		// Get fields from test2 schema (should have 5 columns)
+		fields2, err := db2.TableFields(ctx, tableName)
+		t.AssertNil(err)
+		t.Assert(len(fields2), 5)
+		t.Assert(fields2["data"].Index, 4)
+		t.Assert(fields2["data"].Type, "json")
+	})
+}
diff --git a/contrib/drivers/mssql/go.mod b/contrib/drivers/mssql/go.mod
index 1702839d8..e6f9c58f8 100644
--- a/contrib/drivers/mssql/go.mod
+++ b/contrib/drivers/mssql/go.mod
@@ -3,14 +3,14 @@ module github.com/gogf/gf/contrib/drivers/mssql/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 	github.com/microsoft/go-mssqldb v1.7.1
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -21,22 +21,22 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/crypto v0.41.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/crypto v0.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/drivers/mssql/go.sum b/contrib/drivers/mssql/go.sum
index a96040345..ad3f20bef 100644
--- a/contrib/drivers/mssql/go.sum
+++ b/contrib/drivers/mssql/go.sum
@@ -16,8 +16,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -49,8 +49,9 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -61,40 +62,42 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
-golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/contrib/drivers/mssql/mssql.go b/contrib/drivers/mssql/mssql.go
index 5be217ce0..a8f443e7d 100644
--- a/contrib/drivers/mssql/mssql.go
+++ b/contrib/drivers/mssql/mssql.go
@@ -4,11 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-// Package mssql implements gdb.Driver, which supports operations for database MSSql.
-//
-// Note:
-// 1. It does not support Replace features.
-// 2. It does not support LastInsertId.
+// Package mssql implements gdb.Driver, which supports operations for MSSQL.
 package mssql
 
 import (
diff --git a/contrib/drivers/mssql/mssql_do_exec.go b/contrib/drivers/mssql/mssql_do_exec.go
new file mode 100644
index 000000000..8cf90c484
--- /dev/null
+++ b/contrib/drivers/mssql/mssql_do_exec.go
@@ -0,0 +1,192 @@
+// 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 mssql
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+)
+
+const (
+	// INSERT statement prefixes
+	insertPrefixDefault = "INSERT INTO"
+	insertPrefixIgnore  = "INSERT IGNORE INTO"
+
+	// Database field attributes
+	fieldExtraIdentity = "IDENTITY"
+	fieldKeyPrimary    = "PRI"
+
+	// SQL keywords and syntax markers
+	outputKeyword      = "OUTPUT"
+	insertValuesMarker = ") VALUES" // find the position of the string "VALUES" in the INSERT SQL statement to embed output code for retrieving the last inserted ID
+
+	// Object and field references
+	insertedObjectName = "INSERTED"
+
+	// Result field names and aliases
+	affectCountExpression  = " 1 as AffectCount"
+	lastInsertIdFieldAlias = "ID"
+)
+
+// DoExec commits the sql string and its arguments to underlying driver
+// through given link object and returns the execution result.
+func (d *Driver) DoExec(ctx context.Context, link gdb.Link, sqlStr string, args ...interface{}) (result sql.Result, err error) {
+	// Transaction checks.
+	if link == nil {
+		if tx := gdb.TXFromCtx(ctx, d.GetGroup()); tx != nil {
+			// Firstly, check and retrieve transaction link from context.
+			link = &txLinkMssql{tx.GetSqlTX()}
+		} else if link, err = d.MasterLink(); err != nil {
+			// Or else it creates one from master node.
+			return nil, err
+		}
+	} else if !link.IsTransaction() {
+		// If current link is not transaction link, it checks and retrieves transaction from context.
+		if tx := gdb.TXFromCtx(ctx, d.GetGroup()); tx != nil {
+			link = &txLinkMssql{tx.GetSqlTX()}
+		}
+	}
+
+	// SQL filtering.
+	sqlStr, args = d.FormatSqlBeforeExecuting(sqlStr, args)
+	sqlStr, args, err = d.DoFilter(ctx, link, sqlStr, args)
+	if err != nil {
+		return nil, err
+	}
+
+	if !strings.HasPrefix(sqlStr, insertPrefixDefault) && !strings.HasPrefix(sqlStr, insertPrefixIgnore) {
+		return d.Core.DoExec(ctx, link, sqlStr, args)
+	}
+	// Find the first position of VALUES marker in the INSERT statement.
+	pos := strings.Index(sqlStr, insertValuesMarker)
+
+	table := d.GetTableNameFromSql(sqlStr)
+	outPutSql := d.GetInsertOutputSql(ctx, table)
+	// rebuild sql add output
+	var (
+		sqlValueBefore = sqlStr[:pos+1]
+		sqlValueAfter  = sqlStr[pos+1:]
+	)
+
+	sqlStr = fmt.Sprintf("%s%s%s", sqlValueBefore, outPutSql, sqlValueAfter)
+
+	// fmt.Println("sql str:", sqlStr)
+	// Link execution.
+	var out gdb.DoCommitOutput
+	out, err = d.DoCommit(ctx, gdb.DoCommitInput{
+		Link:          link,
+		Sql:           sqlStr,
+		Args:          args,
+		Stmt:          nil,
+		Type:          gdb.SqlTypeQueryContext,
+		IsTransaction: link.IsTransaction(),
+	})
+	if err != nil {
+		return &Result{lastInsertId: 0, rowsAffected: 0, err: err}, err
+	}
+	stdSqlResult := out.Records
+	if len(stdSqlResult) == 0 {
+		err = gerror.WrapCode(
+			gcode.CodeDbOperationError,
+			gerror.New("affected count is zero"),
+			`sql.Result.RowsAffected failed`,
+		)
+		return &Result{lastInsertId: 0, rowsAffected: 0, err: err}, err
+	}
+	// For batch insert, OUTPUT clause returns one row per inserted row.
+	// So the rowsAffected should be the count of returned records.
+	rowsAffected := int64(len(stdSqlResult))
+	// get last_insert_id from the first returned row
+	lastInsertId := stdSqlResult[0].GMap().GetVar(lastInsertIdFieldAlias).Int64()
+
+	return &Result{lastInsertId: lastInsertId, rowsAffected: rowsAffected}, err
+}
+
+// GetTableNameFromSql get table name from sql statement
+// It handles table string like:
+// "user"
+// "user u"
+// "DbLog.dbo.user",
+// "user as u".
+func (d *Driver) GetTableNameFromSql(sqlStr string) (table string) {
+	// INSERT INTO "ip_to_id"("ip") OUTPUT  1 as AffectCount,INSERTED.id as ID VALUES(?)
+	var (
+		leftChars, rightChars = d.GetChars()
+		trimStr               = leftChars + rightChars + "[] "
+		pattern               = "INTO(.+?)\\("
+		regCompile            = regexp.MustCompile(pattern)
+		tableInfo             = regCompile.FindStringSubmatch(sqlStr)
+	)
+	// get the first one. after the first it may be content of the value, it's not table name.
+	table = tableInfo[1]
+	table = strings.Trim(table, " ")
+	if strings.Contains(table, ".") {
+		tmpAry := strings.Split(table, ".")
+		// the last one is table name
+		table = tmpAry[len(tmpAry)-1]
+	} else if strings.Contains(table, "as") || strings.Contains(table, " ") {
+		tmpAry := strings.Split(table, "as")
+		if len(tmpAry) < 2 {
+			tmpAry = strings.Split(table, " ")
+		}
+		// get the first one
+		table = tmpAry[0]
+	}
+	table = strings.Trim(table, trimStr)
+	return table
+}
+
+// txLink is used to implement interface Link for TX.
+type txLinkMssql struct {
+	*sql.Tx
+}
+
+// IsTransaction returns if current Link is a transaction.
+func (l *txLinkMssql) IsTransaction() bool {
+	return true
+}
+
+// IsOnMaster checks and returns whether current link is operated on master node.
+// Note that, transaction operation is always operated on master node.
+func (l *txLinkMssql) IsOnMaster() bool {
+	return true
+}
+
+// GetInsertOutputSql  gen get last_insert_id code
+func (d *Driver) GetInsertOutputSql(ctx context.Context, table string) string {
+	fds, errFd := d.GetDB().TableFields(ctx, table)
+	if errFd != nil {
+		return ""
+	}
+	extraSqlAry := make([]string, 0)
+	extraSqlAry = append(extraSqlAry, fmt.Sprintf(" %s %s", outputKeyword, affectCountExpression))
+	incrNo := 0
+	if len(fds) > 0 {
+		for _, fd := range fds {
+			// has primary key and is auto-increment
+			if fd.Extra == fieldExtraIdentity && fd.Key == fieldKeyPrimary && !fd.Null {
+				incrNoStr := ""
+				if incrNo == 0 { // fixed first field named id, convenient to get
+					incrNoStr = fmt.Sprintf(" as %s", lastInsertIdFieldAlias)
+				}
+
+				extraSqlAry = append(extraSqlAry, fmt.Sprintf("%s.%s%s", insertedObjectName, fd.Name, incrNoStr))
+				incrNo++
+			}
+			// fmt.Printf("null:%t name:%s key:%s k:%s \n", fd.Null, fd.Name, fd.Key, k)
+		}
+	}
+	return strings.Join(extraSqlAry, ",")
+	// sql example:INSERT INTO "ip_to_id"("ip") OUTPUT  1 as AffectCount,INSERTED.id as ID VALUES(?)
+}
diff --git a/contrib/drivers/mssql/mssql_do_filter_test.go b/contrib/drivers/mssql/mssql_do_filter_test.go
index 89c76edcf..2f8a17a13 100644
--- a/contrib/drivers/mssql/mssql_do_filter_test.go
+++ b/contrib/drivers/mssql/mssql_do_filter_test.go
@@ -8,49 +8,48 @@ package mssql
 
 import (
 	"context"
-	"reflect"
 	"testing"
 
-	"github.com/gogf/gf/v2/database/gdb"
 	"github.com/gogf/gf/v2/test/gtest"
 )
 
 func TestDriver_DoFilter(t *testing.T) {
-	type fields struct {
-		Core *gdb.Core
-	}
-	type args struct {
-		ctx  context.Context
-		link gdb.Link
-		sql  string
-		args []any
-	}
-	var tests []struct {
-		name        string
-		fields      fields
-		args        args
-		wantNewSql  string
-		wantNewArgs []any
-		wantErr     bool
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			d := &Driver{
-				Core: tt.fields.Core,
-			}
-			gotNewSql, gotNewArgs, err := d.DoFilter(tt.args.ctx, tt.args.link, tt.args.sql, tt.args.args)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("DoFilter() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if gotNewSql != tt.wantNewSql {
-				t.Errorf("DoFilter() gotNewSql = %v, want %v", gotNewSql, tt.wantNewSql)
-			}
-			if !reflect.DeepEqual(gotNewArgs, tt.wantNewArgs) {
-				t.Errorf("DoFilter() gotNewArgs = %v, want %v", gotNewArgs, tt.wantNewArgs)
-			}
-		})
-	}
+	gtest.C(t, func(t *gtest.T) {
+		d := &Driver{}
+
+		// Test SELECT with LIMIT
+		sql := "SELECT * FROM users WHERE id = ? LIMIT 10"
+		args := []any{1}
+		newSql, newArgs, err := d.DoFilter(context.Background(), nil, sql, args)
+		t.AssertNil(err)
+		t.Assert(newArgs, args)
+		// DoFilter should transform the SQL for MSSQL compatibility
+		t.AssertNE(newSql, "")
+
+		// Test INSERT statement (should remain unchanged except for placeholder)
+		sql = "INSERT INTO users (name) VALUES (?)"
+		args = []any{"test"}
+		newSql, newArgs, err = d.DoFilter(context.Background(), nil, sql, args)
+		t.AssertNil(err)
+		t.Assert(newArgs, args)
+		t.AssertNE(newSql, "")
+
+		// Test UPDATE statement
+		sql = "UPDATE users SET name = ? WHERE id = ?"
+		args = []any{"test", 1}
+		newSql, newArgs, err = d.DoFilter(context.Background(), nil, sql, args)
+		t.AssertNil(err)
+		t.Assert(newArgs, args)
+		t.AssertNE(newSql, "")
+
+		// Test DELETE statement
+		sql = "DELETE FROM users WHERE id = ?"
+		args = []any{1}
+		newSql, newArgs, err = d.DoFilter(context.Background(), nil, sql, args)
+		t.AssertNil(err)
+		t.Assert(newArgs, args)
+		t.AssertNE(newSql, "")
+	})
 }
 
 func TestDriver_handleSelectSqlReplacement(t *testing.T) {
diff --git a/contrib/drivers/mssql/mssql_do_insert.go b/contrib/drivers/mssql/mssql_do_insert.go
index 5e467d730..fbdcba5d3 100644
--- a/contrib/drivers/mssql/mssql_do_insert.go
+++ b/contrib/drivers/mssql/mssql_do_insert.go
@@ -20,51 +20,95 @@ import (
 )
 
 // DoInsert inserts or updates data for given table.
-func (d *Driver) DoInsert(ctx context.Context, link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption) (result sql.Result, err error) {
+// The list parameter must contain at least one record, which was previously validated.
+func (d *Driver) DoInsert(
+	ctx context.Context, link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
+) (result sql.Result, err error) {
 	switch option.InsertOption {
 	case gdb.InsertOptionSave:
 		return d.doSave(ctx, link, table, list, option)
 
 	case gdb.InsertOptionReplace:
-		return nil, gerror.NewCode(
-			gcode.CodeNotSupported,
-			`Replace operation is not supported by mssql driver`,
-		)
+		// MSSQL does not support REPLACE INTO syntax, use SAVE instead.
+		return d.doSave(ctx, link, table, list, option)
+
+	case gdb.InsertOptionIgnore:
+		// MSSQL does not support INSERT IGNORE syntax, use MERGE instead.
+		return d.doInsertIgnore(ctx, link, table, list, option)
 
 	default:
 		return d.Core.DoInsert(ctx, link, table, list, option)
 	}
 }
 
-// doSave support upsert for SQL server
+// doSave support upsert for MSSQL
 func (d *Driver) doSave(ctx context.Context,
 	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
 ) (result sql.Result, err error) {
-	if len(option.OnConflict) == 0 {
-		return nil, gerror.NewCode(
-			gcode.CodeMissingParameter, `Please specify conflict columns`,
-		)
-	}
+	return d.doMergeInsert(ctx, link, table, list, option, true)
+}
 
-	if len(list) == 0 {
-		return nil, gerror.NewCode(
-			gcode.CodeInvalidRequest, `Save operation list is empty by mssql driver`,
-		)
+// doInsertIgnore implements INSERT IGNORE operation using MERGE statement for MSSQL database.
+// It only inserts records when there's no conflict on primary/unique keys.
+func (d *Driver) doInsertIgnore(ctx context.Context,
+	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
+) (result sql.Result, err error) {
+	return d.doMergeInsert(ctx, link, table, list, option, false)
+}
+
+// doMergeInsert implements MERGE-based insert operations for MSSQL database.
+// When withUpdate is true, it performs upsert (insert or update).
+// When withUpdate is false, it performs insert ignore (insert only when no conflict).
+func (d *Driver) doMergeInsert(
+	ctx context.Context,
+	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption, withUpdate bool,
+) (result sql.Result, err error) {
+	// If OnConflict is not specified, automatically get the primary key of the table
+	conflictKeys := option.OnConflict
+	if len(conflictKeys) == 0 {
+		primaryKeys, err := d.Core.GetPrimaryKeys(ctx, table)
+		if err != nil {
+			return nil, gerror.WrapCode(
+				gcode.CodeInternalError,
+				err,
+				`failed to get primary keys for table`,
+			)
+		}
+		foundPrimaryKey := false
+		for _, primaryKey := range primaryKeys {
+			for dataKey := range list[0] {
+				if strings.EqualFold(dataKey, primaryKey) {
+					foundPrimaryKey = true
+					break
+				}
+			}
+			if foundPrimaryKey {
+				break
+			}
+		}
+		if !foundPrimaryKey {
+			return nil, gerror.NewCodef(
+				gcode.CodeMissingParameter,
+				`Replace/Save/InsertIgnore operation requires conflict detection: `+
+					`either specify OnConflict() columns or ensure table '%s' has a primary key in the data`,
+				table,
+			)
+		}
+		// TODO consider composite primary keys.
+		conflictKeys = primaryKeys
 	}
 
 	var (
-		one          = list[0]
-		oneLen       = len(one)
-		charL, charR = d.GetChars()
+		one            = list[0]
+		oneLen         = len(one)
+		charL, charR   = d.GetChars()
+		conflictKeySet = gset.NewStrSet(false)
 
-		conflictKeys   = option.OnConflict
-		conflictKeySet = gset.New(false)
-
-		// queryHolders:	Handle data with Holder that need to be upsert
-		// queryValues:		Handle data that need to be upsert
+		// queryHolders:	Handle data with Holder that need to be merged
+		// queryValues:		Handle data that need to be merged
 		// insertKeys:		Handle valid keys that need to be inserted
 		// insertValues:	Handle values that need to be inserted
-		// updateValues:	Handle values that need to be updated
+		// updateValues:	Handle values that need to be updated (only when withUpdate=true)
 		queryHolders = make([]string, oneLen)
 		queryValues  = make([]any, oneLen)
 		insertKeys   = make([]string, oneLen)
@@ -84,9 +128,9 @@ func (d *Driver) doSave(ctx context.Context,
 		insertKeys[index] = charL + key + charR
 		insertValues[index] = "T2." + charL + key + charR
 
-		// filter conflict keys in updateValues.
-		// And the key is not a soft created field.
-		if !(conflictKeySet.Contains(key) || d.Core.IsSoftCreatedFieldName(key)) {
+		// Build updateValues only when withUpdate is true
+		// Filter conflict keys and soft created fields from updateValues
+		if withUpdate && !(conflictKeySet.Contains(key) || d.Core.IsSoftCreatedFieldName(key)) {
 			updateValues = append(
 				updateValues,
 				fmt.Sprintf(`T1.%s = T2.%s`, charL+key+charR, charL+key+charR),
@@ -95,8 +139,10 @@ func (d *Driver) doSave(ctx context.Context,
 		index++
 	}
 
-	batchResult := new(gdb.SqlResult)
-	sqlStr := parseSqlForUpsert(table, queryHolders, insertKeys, insertValues, updateValues, conflictKeys)
+	var (
+		batchResult = new(gdb.SqlResult)
+		sqlStr      = parseSqlForMerge(table, queryHolders, insertKeys, insertValues, updateValues, conflictKeys)
+	)
 	r, err := d.DoExec(ctx, link, sqlStr, queryValues...)
 	if err != nil {
 		return r, err
@@ -110,41 +156,48 @@ func (d *Driver) doSave(ctx context.Context,
 	return batchResult, nil
 }
 
-// parseSqlForUpsert
-// MERGE INTO {{table}} T1
-// USING ( VALUES( {{queryHolders}}) T2 ({{insertKeyStr}})
-// ON (T1.{{duplicateKey}} = T2.{{duplicateKey}} AND ...)
-// WHEN NOT MATCHED THEN
-// INSERT {{insertKeys}} VALUES {{insertValues}}
-// WHEN MATCHED THEN
-// UPDATE SET {{updateValues}}
-func parseSqlForUpsert(table string,
+// parseSqlForMerge generates MERGE statement for MSSQL database.
+// When updateValues is empty, it only inserts (INSERT IGNORE behavior).
+// When updateValues is provided, it performs upsert (INSERT or UPDATE).
+// Examples:
+// - INSERT IGNORE: MERGE INTO table T1 USING (...) T2 ON (...) WHEN NOT MATCHED THEN INSERT(...) VALUES (...)
+// - UPSERT: MERGE INTO table T1 USING (...) T2 ON (...) WHEN NOT MATCHED THEN INSERT(...) VALUES (...) WHEN MATCHED THEN UPDATE SET ...
+func parseSqlForMerge(table string,
 	queryHolders, insertKeys, insertValues, updateValues, duplicateKey []string,
 ) (sqlStr string) {
 	var (
 		queryHolderStr  = strings.Join(queryHolders, ",")
 		insertKeyStr    = strings.Join(insertKeys, ",")
 		insertValueStr  = strings.Join(insertValues, ",")
-		updateValueStr  = strings.Join(updateValues, ",")
 		duplicateKeyStr string
-		pattern         = gstr.Trim(`MERGE INTO %s T1 USING (VALUES(%s)) T2 (%s) ON (%s) WHEN NOT MATCHED THEN INSERT(%s) VALUES (%s) WHEN MATCHED THEN UPDATE SET %s;`)
 	)
 
+	// Build ON condition
 	for index, keys := range duplicateKey {
 		if index != 0 {
 			duplicateKeyStr += " AND "
 		}
-		duplicateTmp := fmt.Sprintf("T1.%s = T2.%s", keys, keys)
-		duplicateKeyStr += duplicateTmp
+		duplicateKeyStr += fmt.Sprintf("T1.%s = T2.%s", keys, keys)
 	}
 
-	return fmt.Sprintf(pattern,
-		table,
-		queryHolderStr,
-		insertKeyStr,
-		duplicateKeyStr,
-		insertKeyStr,
-		insertValueStr,
-		updateValueStr,
+	// Build SQL based on whether UPDATE is needed
+	pattern := gstr.Trim(
+		`MERGE INTO %s T1 USING (VALUES(%s)) T2 (%s) ON (%s) WHEN NOT MATCHED THEN INSERT(%s) VALUES (%s)`,
 	)
+	if len(updateValues) > 0 {
+		// Upsert: INSERT or UPDATE
+		pattern += gstr.Trim(` WHEN MATCHED THEN UPDATE SET %s`)
+		return fmt.Sprintf(
+			pattern+";",
+			table,
+			queryHolderStr,
+			insertKeyStr,
+			duplicateKeyStr,
+			insertKeyStr,
+			insertValueStr,
+			strings.Join(updateValues, ","),
+		)
+	}
+	// Insert Ignore: INSERT only
+	return fmt.Sprintf(pattern+";", table, queryHolderStr, insertKeyStr, duplicateKeyStr, insertKeyStr, insertValueStr)
 }
diff --git a/contrib/drivers/mssql/mssql_result.go b/contrib/drivers/mssql/mssql_result.go
new file mode 100644
index 000000000..57f3f41a9
--- /dev/null
+++ b/contrib/drivers/mssql/mssql_result.go
@@ -0,0 +1,22 @@
+// 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 mssql
+
+// Result instance of sql.Result
+type Result struct {
+	lastInsertId int64
+	rowsAffected int64
+	err          error
+}
+
+func (r *Result) LastInsertId() (int64, error) {
+	return r.lastInsertId, r.err
+}
+
+func (r *Result) RowsAffected() (int64, error) {
+	return r.rowsAffected, r.err
+}
diff --git a/contrib/drivers/mssql/mssql_table_fields.go b/contrib/drivers/mssql/mssql_table_fields.go
index db2a9ba3e..607d8e6fd 100644
--- a/contrib/drivers/mssql/mssql_table_fields.go
+++ b/contrib/drivers/mssql/mssql_table_fields.go
@@ -17,32 +17,32 @@ import (
 var (
 	tableFieldsSqlTmp = `
 SELECT 
-	a.name Field,
-	CASE b.name 
-		WHEN 'datetime' THEN 'datetime'
-		WHEN 'numeric' THEN b.name + '(' + convert(varchar(20), a.xprec) + ',' + convert(varchar(20), a.xscale) + ')' 
-		WHEN 'char' THEN b.name + '(' + convert(varchar(20), a.length)+ ')'
-		WHEN 'varchar' THEN b.name + '(' + convert(varchar(20), a.length)+ ')'
-		ELSE b.name + '(' + convert(varchar(20),a.length)+ ')' END AS Type,
-	CASE WHEN a.isnullable=1 THEN 'YES' ELSE 'NO' end AS [Null],
-	CASE WHEN exists (
-		SELECT 1 FROM sysobjects WHERE xtype='PK' AND name IN (
-			SELECT name FROM sysindexes WHERE indid IN (
-				SELECT indid FROM sysindexkeys WHERE id = a.id AND colid=a.colid
-			)
-		)
-	) THEN 'PRI' ELSE '' END AS [Key],
-	CASE WHEN COLUMNPROPERTY(a.id,a.name,'IsIdentity')=1 THEN 'auto_increment' ELSE '' END Extra,
-	isnull(e.text,'') AS [Default],
-	isnull(g.[value],'') AS [Comment]
-FROM syscolumns a
-LEFT  JOIN systypes b ON a.xtype=b.xtype AND a.xusertype=b.xusertype
-INNER JOIN sysobjects d ON a.id=d.id AND d.xtype='U' AND d.name<>'dtproperties'
-LEFT  JOIN syscomments e ON a.cdefault=e.id
-LEFT  JOIN sys.extended_properties g ON a.id=g.major_id AND a.colid=g.minor_id
-LEFT  JOIN sys.extended_properties f ON d.id=f.major_id AND f.minor_id =0
-WHERE d.name='%s'
-ORDER BY a.id,a.colorder
+	c.name AS Field,
+	CASE 
+		WHEN t.name IN ('datetime', 'datetime2', 'smalldatetime', 'date', 'time', 'text', 'ntext', 'image', 'xml') THEN t.name
+		WHEN t.name IN ('decimal', 'numeric') THEN t.name + '(' + CAST(c.precision AS varchar(20)) + ',' + CAST(c.scale AS varchar(20)) + ')'
+		WHEN t.name IN ('char', 'varchar', 'binary', 'varbinary') THEN t.name + '(' + CASE WHEN c.max_length = -1 THEN 'max' ELSE CAST(c.max_length AS varchar(20)) END + ')'
+		WHEN t.name IN ('nchar', 'nvarchar') THEN t.name + '(' + CASE WHEN c.max_length = -1 THEN 'max' ELSE CAST(c.max_length/2 AS varchar(20)) END + ')'
+		ELSE t.name
+	END AS Type,
+	CASE WHEN c.is_nullable = 1 THEN 'YES' ELSE 'NO' END AS [Null],
+	CASE WHEN pk.column_id IS NOT NULL THEN 'PRI' ELSE '' END AS [Key],
+	CASE WHEN c.is_identity = 1 THEN 'IDENTITY' ELSE '' END AS Extra,
+	ISNULL(dc.definition, '') AS [Default],
+	ISNULL(CAST(ep.value AS nvarchar(max)), '') AS [Comment]
+FROM sys.columns c
+INNER JOIN sys.objects o ON c.object_id = o.object_id AND o.type = 'U' AND o.is_ms_shipped = 0
+INNER JOIN sys.types t ON c.user_type_id = t.user_type_id
+LEFT JOIN sys.default_constraints dc ON c.default_object_id = dc.object_id
+LEFT JOIN sys.extended_properties ep ON c.object_id = ep.major_id AND c.column_id = ep.minor_id AND ep.name = 'MS_Description'
+LEFT JOIN (
+	SELECT ic.object_id, ic.column_id
+	FROM sys.index_columns ic
+	INNER JOIN sys.indexes i ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+	WHERE i.is_primary_key = 1
+) pk ON c.object_id = pk.object_id AND c.column_id = pk.column_id
+WHERE o.name = '%s'
+ORDER BY c.column_id
 `
 )
 
diff --git a/contrib/drivers/mssql/mssql_tables.go b/contrib/drivers/mssql/mssql_tables.go
index 4cd2d2da2..d1d39a5c6 100644
--- a/contrib/drivers/mssql/mssql_tables.go
+++ b/contrib/drivers/mssql/mssql_tables.go
@@ -13,7 +13,7 @@ import (
 )
 
 const (
-	tablesSqlTmp = `SELECT NAME FROM SYSOBJECTS WHERE XTYPE='U' AND STATUS >= 0 ORDER BY NAME`
+	tablesSqlTmp = `SELECT name FROM sys.objects WHERE type='U' AND is_ms_shipped = 0 ORDER BY name`
 )
 
 // Tables retrieves and returns the tables of current schema.
diff --git a/contrib/drivers/mssql/mssql_z_unit_basic_test.go b/contrib/drivers/mssql/mssql_z_unit_basic_test.go
index d39116a3c..49635776d 100644
--- a/contrib/drivers/mssql/mssql_z_unit_basic_test.go
+++ b/contrib/drivers/mssql/mssql_z_unit_basic_test.go
@@ -13,11 +13,15 @@ import (
 	"testing"
 	"time"
 
+	"github.com/gogf/gf/v2/database/gdb"
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/encoding/gxml"
 	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gctx"
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/test/gtest"
+
+	"github.com/gogf/gf/contrib/drivers/mssql/v2"
 )
 
 func TestTables(t *testing.T) {
@@ -42,7 +46,7 @@ func TestTables(t *testing.T) {
 			gtest.AssertEQ(find, true)
 		}
 
-		result, err = db.Tables(context.Background(), "master")
+		result, err = db.Tables(context.Background(), TestSchema)
 		gtest.AssertNil(err)
 		for i := 0; i < len(tables); i++ {
 			find := false
@@ -88,7 +92,7 @@ func TestTableFields(t *testing.T) {
 			gtest.AssertEQ(res[k].Comment, v[5])
 		}
 
-		res, err = db.TableFields(context.Background(), "t_user", "master")
+		res, err = db.TableFields(context.Background(), "t_user", TestSchema)
 		gtest.AssertNil(err)
 
 		for k, v := range expect {
@@ -134,20 +138,72 @@ func TestDoInsert(t *testing.T) {
 
 		i := 10
 		data := g.Map{
-			"id":          i,
+			// "id":          i,
 			"passport":    fmt.Sprintf(`t%d`, i),
 			"password":    fmt.Sprintf(`p%d`, i),
 			"nickname":    fmt.Sprintf(`T%d`, i),
 			"create_time": gtime.Now(),
 		}
+		// Save without OnConflict should fail (missing conflict columns)
 		_, err := db.Save(context.Background(), "t_user", data, 10)
 		gtest.AssertNE(err, nil)
 
+		// Replace should fail because primary key 'id' is not in the data
 		_, err = db.Replace(context.Background(), "t_user", data, 10)
 		gtest.AssertNE(err, nil)
 	})
 }
 
+func TestDoInsertGetId(t *testing.T) {
+	// create test table
+	createInsertAndGetIdTableForTest()
+	gtest.C(t, func(t *gtest.T) {
+		table := "ip_to_id"
+		data := map[string]interface{}{
+			"ip": "192.168.179.1",
+		}
+		id, err := db.InsertAndGetId(gctx.New(), table, data)
+		t.AssertNil(err)
+		t.AssertGT(id, 0)
+		// fmt.Println("id:", id)
+
+		// multiple insert test
+		dataAry := []map[string]interface{}{{"ip": "192.168.5.9"}, {"ip": "192.168.5.10"}}
+		id1, err1 := db.InsertAndGetId(gctx.New(), table, dataAry)
+		t.AssertNil(err1)
+		t.AssertGT(id1, 0)
+	})
+}
+
+func TestGetTableFromSql(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		okTable := "ip_to_id"
+		sqlStr := "INSERT INTO \"ip_to_id\"(\"ip\") VALUES(?)"
+		dbWrapper, ok := db.GetCore().GetDB().(*gdb.DriverWrapperDB)
+		t.Assert(ok, true)
+		dbMssql, ok := dbWrapper.DB.(*mssql.Driver)
+		t.Assert(ok, true)
+		table := dbMssql.GetTableNameFromSql(sqlStr)
+		// fmt.Println("default table:", table)
+		t.Assert(table, okTable)
+
+		sqlStr = "INSERT INTO \"MyLogDb\".\"dbo\".\"ip_to_id\"(\"ip\") VALUES(?)"
+		table = dbMssql.GetTableNameFromSql(sqlStr)
+		// fmt.Println("MyLogDb.dbo.ip_to_id table:", table)
+		t.Assert(table, okTable)
+
+		sqlStr = "INSERT INTO \"ip_to_id\" as \"tt\" (\"ip\") VALUES(?)"
+		table = dbMssql.GetTableNameFromSql(sqlStr)
+		// fmt.Println("ip_to_id as tt table:", table)
+		t.Assert(table, okTable)
+
+		sqlStr = "INSERT INTO \"ip_to_id\" \"tt\" (\"ip\") VALUES(?)"
+		table = dbMssql.GetTableNameFromSql(sqlStr)
+		// fmt.Println("ip_to_id tt table:", table)
+		t.Assert(table, okTable)
+	})
+}
+
 func Test_DB_Ping(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		err1 := db.PingMaster()
diff --git a/contrib/drivers/mssql/mssql_z_unit_init_test.go b/contrib/drivers/mssql/mssql_z_unit_init_test.go
index 08e925c5a..f714b4001 100644
--- a/contrib/drivers/mssql/mssql_z_unit_init_test.go
+++ b/contrib/drivers/mssql/mssql_z_unit_init_test.go
@@ -25,13 +25,18 @@ var (
 )
 
 const (
-	TableSize  = 10
-	TestDbUser = "sa"
-	TestDbPass = "LoremIpsum86"
+	TableSize        = 10
+	TableName        = "t_user"
+	TestSchema       = "test"
+	TableNamePrefix1 = "gf_"
+	TestDbUser       = "sa"
+	TestDbPass       = "LoremIpsum86"
+	CreateTime       = "2018-10-24 10:00:00"
 )
 
 func init() {
-	node := gdb.ConfigNode{
+	// First connect to master database to create test database
+	nodemaster := gdb.ConfigNode{
 		Host:             "127.0.0.1",
 		Port:             "1433",
 		User:             TestDbUser,
@@ -45,6 +50,33 @@ func init() {
 		MaxOpenConnCount: 10,
 	}
 
+	tempDb, err := gdb.New(nodemaster)
+	if err != nil {
+		gtest.Fatal(err)
+	}
+
+	// Create test database
+	if _, err := tempDb.Exec(context.Background(), fmt.Sprintf(`
+		IF NOT EXISTS (SELECT name FROM sys.databases WHERE name = '%s')
+		CREATE DATABASE [%s]
+	`, TestSchema, TestSchema)); err != nil {
+		gtest.Fatal(err)
+	}
+
+	node := gdb.ConfigNode{
+		Host:             "127.0.0.1",
+		Port:             "1433",
+		User:             TestDbUser,
+		Pass:             TestDbPass,
+		Name:             TestSchema,
+		Type:             "mssql",
+		Role:             "master",
+		Charset:          "utf8",
+		Weight:           1,
+		MaxIdleConnCount: 10,
+		MaxOpenConnCount: 10,
+	}
+
 	nodeLink := gdb.ConfigNode{
 		Type: "mssql",
 		Name: "master",
@@ -95,8 +127,8 @@ func createTable(table ...string) (name string) {
 	dropTable(name)
 
 	if _, err := db.Exec(context.Background(), fmt.Sprintf(`
-		IF NOT EXISTS (SELECT * FROM sysobjects WHERE name='%s' and xtype='U')
-		CREATE TABLE %s (
+		IF NOT EXISTS (SELECT * FROM sys.objects WHERE name='%s' and type='U')
+		CREATE TABLE [%s] (
 		ID numeric(10,0) NOT NULL,
 		PASSPORT VARCHAR(45)  NULL,
 		PASSWORD VARCHAR(32)  NULL,
@@ -109,7 +141,6 @@ func createTable(table ...string) (name string) {
 		gtest.Fatal(err)
 	}
 
-	db.Schema("test")
 	return
 }
 
@@ -136,9 +167,33 @@ func createInitTable(table ...string) (name string) {
 
 func dropTable(table string) {
 	if _, err := db.Exec(context.Background(), fmt.Sprintf(`
-		IF EXISTS (SELECT * FROM sysobjects WHERE name='%s' and xtype='U')
-		DROP TABLE %s
+		IF EXISTS (SELECT * FROM sys.objects WHERE name='%s' and type='U')
+		DROP TABLE [%s]
 	`, table, table)); err != nil {
 		gtest.Fatal(err)
 	}
 }
+
+// createInsertAndGetIdTableForTest tests InsertAndGetId functionality
+func createInsertAndGetIdTableForTest() (name string) {
+
+	if _, err := db.Exec(context.Background(), `
+IF NOT EXISTS (SELECT * FROM sys.objects WHERE name='ip_to_id' and type='U')
+begin
+	CREATE TABLE [ip_to_id](
+		[id] [int] IDENTITY(1,1) NOT NULL,
+		[ip] [varchar](128) NULL,
+	 CONSTRAINT [PK_ip_to_id] PRIMARY KEY CLUSTERED 
+	(
+		[id] ASC
+	)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
+	) ON [PRIMARY]
+end
+	`); err != nil {
+		gtest.Fatal(err)
+	}
+
+	db.Schema(db.GetConfig().Name)
+	name = "ip_to_id"
+	return
+}
diff --git a/contrib/drivers/mssql/mssql_z_unit_model_test.go b/contrib/drivers/mssql/mssql_z_unit_model_test.go
index 6fff5e30f..99ee09e8f 100644
--- a/contrib/drivers/mssql/mssql_z_unit_model_test.go
+++ b/contrib/drivers/mssql/mssql_z_unit_model_test.go
@@ -29,21 +29,21 @@ func Test_Page(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		result, err := db.Model(table).Page(1, 2).Order("id").All()
 		t.AssertNil(err)
-		fmt.Println("page:1--------", result)
+		// fmt.Println("page:1--------", result)
 		gtest.Assert(len(result), 2)
 		gtest.Assert(result[0]["ID"], 1)
 		gtest.Assert(result[1]["ID"], 2)
 
 		result, err = db.Model(table).Page(2, 2).Order("id").All()
 		t.AssertNil(err)
-		fmt.Println("page: 2--------", result)
+		// fmt.Println("page: 2--------", result)
 		gtest.Assert(len(result), 2)
 		gtest.Assert(result[0]["ID"], 3)
 		gtest.Assert(result[1]["ID"], 4)
 
 		result, err = db.Model(table).Page(3, 2).Order("id").All()
 		t.AssertNil(err)
-		fmt.Println("page:3 --------", result)
+		// fmt.Println("page:3 --------", result)
 		gtest.Assert(len(result), 2)
 		gtest.Assert(result[0]["ID"], 5)
 
@@ -61,7 +61,6 @@ func Test_Model_Insert(t *testing.T) {
 		user := db.Model(table)
 		result, err := user.Data(g.Map{
 			"id":          1,
-			"uid":         1,
 			"passport":    "t1",
 			"password":    "25d55ad283aa400af464c76d713c07ad",
 			"nickname":    "name_1",
@@ -71,7 +70,6 @@ func Test_Model_Insert(t *testing.T) {
 
 		result, err = db.Model(table).Data(g.Map{
 			"id":          "2",
-			"uid":         "2",
 			"passport":    "t2",
 			"password":    "25d55ad283aa400af464c76d713c07ad",
 			"nickname":    "name_2",
@@ -81,7 +79,6 @@ func Test_Model_Insert(t *testing.T) {
 
 		type User struct {
 			Id         int         `gconv:"id"`
-			Uid        int         `gconv:"uid"`
 			Passport   string      `json:"passport"`
 			Password   string      `gconv:"password"`
 			Nickname   string      `gconv:"nickname"`
@@ -90,7 +87,6 @@ func Test_Model_Insert(t *testing.T) {
 		// Model inserting.
 		result, err = db.Model(table).Data(User{
 			Id:       3,
-			Uid:      3,
 			Passport: "t3",
 			Password: "25d55ad283aa400af464c76d713c07ad",
 			Nickname: "name_3",
@@ -103,7 +99,6 @@ func Test_Model_Insert(t *testing.T) {
 
 		result, err = db.Model(table).Data(&User{
 			Id:         4,
-			Uid:        4,
 			Passport:   "t4",
 			Password:   "25d55ad283aa400af464c76d713c07ad",
 			Nickname:   "T4",
@@ -122,6 +117,48 @@ func Test_Model_Insert(t *testing.T) {
 	})
 }
 
+func Test_Model_InsertIgnore(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	// db.SetDebug(true)
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    fmt.Sprintf(`t%d`, 777),
+			"password":    fmt.Sprintf(`p%d`, 777),
+			"nickname":    fmt.Sprintf(`T%d`, 777),
+			"create_time": gtime.Now(),
+		}
+		_, err := db.Model(table).Data(data).InsertIgnore()
+		t.AssertNil(err)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["PASSPORT"].String(), "user_1")
+
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, TableSize)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"passport":    fmt.Sprintf(`t%d`, 777),
+			"password":    fmt.Sprintf(`p%d`, 777),
+			"nickname":    fmt.Sprintf(`T%d`, 777),
+			"create_time": gtime.Now(),
+		}
+		_, err := db.Model(table).Data(data).InsertIgnore()
+		t.AssertNE(err, nil)
+
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, TableSize)
+	})
+}
+
 func Test_Model_Insert_KeyFieldNameMapping(t *testing.T) {
 	table := createTable()
 	defer dropTable(table)
@@ -213,7 +250,6 @@ func Test_Model_BatchInsertWithArrayStruct(t *testing.T) {
 		for i := 1; i <= TableSize; i++ {
 			array.Append(g.Map{
 				"id":          i,
-				"uid":         i,
 				"passport":    fmt.Sprintf("t%d", i),
 				"password":    "25d55ad283aa400af464c76d713c07ad",
 				"nickname":    fmt.Sprintf("name_%d", i),
@@ -235,7 +271,6 @@ func Test_Model_Batch(t *testing.T) {
 		_, err := db.Model(table).Data(g.List{
 			{
 				"id":          2,
-				"uid":         2,
 				"passport":    "t2",
 				"password":    "25d55ad283aa400af464c76d713c07ad",
 				"nickname":    "name_2",
@@ -243,7 +278,6 @@ func Test_Model_Batch(t *testing.T) {
 			},
 			{
 				"id":          3,
-				"uid":         3,
 				"passport":    "t3",
 				"password":    "25d55ad283aa400af464c76d713c07ad",
 				"nickname":    "name_3",
@@ -1607,7 +1641,6 @@ func Test_Model_Option_Where(t *testing.T) {
 		n, _ := r.RowsAffected()
 		t.Assert(n, TableSize)
 	})
-	return
 	gtest.C(t, func(t *gtest.T) {
 		table := createInitTable()
 		defer dropTable(table)
@@ -2326,7 +2359,12 @@ func Test_Model_Raw(t *testing.T) {
 			OrderDesc("id").
 			Count()
 		t.AssertNil(err)
-		t.Assert(count, int64(6))
+		// After fix for issue #4500, Where conditions are correctly applied to Raw SQL Count.
+		// Raw SQL matches: id in (1, 5, 7, 8, 9, 10)
+		// WhereLT("id", 8): id < 8 -> (1, 5, 7)
+		// WhereIn("id", {1-7}): id in (1, 2, 3, 4, 5, 6, 7) -> (1, 5, 7)
+		// Result: 3 records match all conditions
+		t.Assert(count, int64(3))
 	})
 }
 
@@ -2667,13 +2705,131 @@ func Test_Model_Replace(t *testing.T) {
 	defer dropTable(table)
 
 	gtest.C(t, func(t *gtest.T) {
-		_, err := db.Model(table).Data(g.Map{
+		// Insert initial record
+		result, err := db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "t1",
+			"password":    "pass1",
+			"nickname":    "T1",
+			"create_time": "2018-10-24 10:00:00",
+		}).Insert()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+
+		// Replace with new data (should update existing record using MERGE)
+		result, err = db.Model(table).Data(g.Map{
 			"id":          1,
 			"passport":    "t11",
 			"password":    "25d55ad283aa400af464c76d713c07ad",
 			"nickname":    "T11",
 			"create_time": "2018-10-24 10:00:00",
 		}).Replace()
-		t.Assert(err, "Replace operation is not supported by mssql driver")
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+
+		// Verify the data was replaced
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["PASSPORT"].String(), "t11")
+		t.Assert(one["NICKNAME"].String(), "T11")
+
+		// Replace with non-existing record (should insert new record)
+		result, err = db.Model(table).Data(g.Map{
+			"id":          2,
+			"passport":    "t222",
+			"password":    "pass2",
+			"nickname":    "T222",
+			"create_time": "2018-10-24 11:00:00",
+		}).Replace()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1) // MERGE reports: 1 for insert
+
+		// Verify the new record was inserted
+		one, err = db.Model(table).WherePri(2).One()
+		t.AssertNil(err)
+		t.Assert(one["PASSPORT"].String(), "t222")
+		t.Assert(one["NICKNAME"].String(), "T222")
+	})
+}
+
+// Test_Model_Insert_RowsAffected tests the RowsAffected result for INSERT operations.
+// This test ensures that the rowsAffected value is correctly returned from the database,
+// especially for batch INSERT statements.
+func Test_Model_Insert_RowsAffected(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	// Test single insert - rowsAffected should be 1
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "user_1",
+			"password":    "pass_1",
+			"nickname":    "name_1",
+			"create_time": gtime.Now().String(),
+		}).Insert()
+		t.AssertNil(err)
+
+		n, err := result.RowsAffected()
+		t.AssertNil(err)
+		t.Assert(n, 1)
+	})
+
+	// Test batch insert with 3 rows - rowsAffected should be 3
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Data(g.List{
+			{
+				"id":          2,
+				"passport":    "user_2",
+				"password":    "pass_2",
+				"nickname":    "name_2",
+				"create_time": gtime.Now().String(),
+			},
+			{
+				"id":          3,
+				"passport":    "user_3",
+				"password":    "pass_3",
+				"nickname":    "name_3",
+				"create_time": gtime.Now().String(),
+			},
+			{
+				"id":          4,
+				"passport":    "user_4",
+				"password":    "pass_4",
+				"nickname":    "name_4",
+				"create_time": gtime.Now().String(),
+			},
+		}).Insert()
+		t.AssertNil(err)
+
+		n, err := result.RowsAffected()
+		t.AssertNil(err)
+		t.Assert(n, 3)
+	})
+
+	// Test batch insert with 5 rows - rowsAffected should be 5
+	gtest.C(t, func(t *gtest.T) {
+		result, err := db.Model(table).Data(g.List{
+			{"id": 5, "passport": "user_5", "password": "pass_5", "nickname": "name_5", "create_time": gtime.Now().String()},
+			{"id": 6, "passport": "user_6", "password": "pass_6", "nickname": "name_6", "create_time": gtime.Now().String()},
+			{"id": 7, "passport": "user_7", "password": "pass_7", "nickname": "name_7", "create_time": gtime.Now().String()},
+			{"id": 8, "passport": "user_8", "password": "pass_8", "nickname": "name_8", "create_time": gtime.Now().String()},
+			{"id": 9, "passport": "user_9", "password": "pass_9", "nickname": "name_9", "create_time": gtime.Now().String()},
+		}).Insert()
+		t.AssertNil(err)
+
+		n, err := result.RowsAffected()
+		t.AssertNil(err)
+		t.Assert(n, 5)
+	})
+
+	// Verify total count in table
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, 9)
 	})
 }
diff --git a/contrib/drivers/mysql/go.mod b/contrib/drivers/mysql/go.mod
index 4062c4a66..7ea870802 100644
--- a/contrib/drivers/mysql/go.mod
+++ b/contrib/drivers/mysql/go.mod
@@ -4,13 +4,13 @@ go 1.23.0
 
 require (
 	github.com/go-sql-driver/mysql v1.7.1
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -19,21 +19,21 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/drivers/mysql/go.sum b/contrib/drivers/mysql/go.sum
index f349de96e..f96db96f2 100644
--- a/contrib/drivers/mysql/go.sum
+++ b/contrib/drivers/mysql/go.sum
@@ -4,8 +4,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -31,8 +31,9 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -41,36 +42,38 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/contrib/drivers/mysql/mysql.go b/contrib/drivers/mysql/mysql.go
index ce142f513..8e13aa28d 100644
--- a/contrib/drivers/mysql/mysql.go
+++ b/contrib/drivers/mysql/mysql.go
@@ -27,7 +27,7 @@ func init() {
 	var (
 		err         error
 		driverObj   = New()
-		driverNames = g.SliceStr{"mysql", "mariadb", "tidb"}
+		driverNames = g.SliceStr{"mysql", "mariadb", "tidb"} // TODO remove mariadb and tidb in future versions.
 	)
 	for _, driverName := range driverNames {
 		if err = gdb.Register(driverName, driverObj); err != nil {
diff --git a/contrib/drivers/mysql/mysql_table_fields.go b/contrib/drivers/mysql/mysql_table_fields.go
index 72ffa7e29..3a0b69ae6 100644
--- a/contrib/drivers/mysql/mysql_table_fields.go
+++ b/contrib/drivers/mysql/mysql_table_fields.go
@@ -15,6 +15,9 @@ import (
 )
 
 var (
+	// tableFieldsSqlByMariadb is the query statement for retrieving table fields' information in MariaDB.
+	// Deprecated: Use package `contrib/drivers/mariadb` instead.
+	// TODO remove in next version.
 	tableFieldsSqlByMariadb = `
 SELECT
 	c.COLUMN_NAME AS 'Field',
@@ -29,6 +32,7 @@ SELECT
 FROM
 	information_schema.COLUMNS AS c
 	LEFT JOIN information_schema.CHECK_CONSTRAINTS AS ch ON c.TABLE_NAME = ch.TABLE_NAME 
+    AND c.TABLE_SCHEMA = ch.CONSTRAINT_SCHEMA
 	AND c.COLUMN_NAME = ch.CONSTRAINT_NAME 
 WHERE
 	c.TABLE_SCHEMA = '%s' 
@@ -68,6 +72,8 @@ func (d *Driver) TableFields(ctx context.Context, table string, schema ...string
 	}
 	dbType := d.GetConfig().Type
 	switch dbType {
+	// Deprecated: Use package `contrib/drivers/mariadb` instead.
+	// TODO remove in next version.
 	case "mariadb":
 		tableFieldsSql = fmt.Sprintf(tableFieldsSqlByMariadb, usedSchema, table)
 	default:
diff --git a/contrib/drivers/mysql/mysql_z_unit_core_bench_test.go b/contrib/drivers/mysql/mysql_z_unit_core_bench_test.go
new file mode 100644
index 000000000..6c1b2fc53
--- /dev/null
+++ b/contrib/drivers/mysql/mysql_z_unit_core_bench_test.go
@@ -0,0 +1,46 @@
+// 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.
+
+// go test *.go -bench=".*"
+
+package mysql_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/util/grand"
+)
+
+func Benchmark_BatchInsert(b *testing.B) {
+	table := createTable()
+	defer dropTable(table)
+	type User struct {
+		Id         int         `c:"id"`
+		Passport   string      `c:"passport"`
+		Password   string      `c:"password"`
+		NickName   string      `c:"nickname"`
+		CreateTime *gtime.Time `c:"create_time"`
+	}
+	var users []*User
+	for i := 0; i < 10000; i++ {
+		users = append(users, &User{
+			Passport:   grand.S(10),
+			Password:   grand.S(10),
+			NickName:   grand.S(10),
+			CreateTime: gtime.Now(),
+		})
+	}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		result, err := db.Insert(ctx, table, users)
+		if err != nil {
+			b.Fatalf("insert error: %v", err)
+		}
+		n, _ := result.RowsAffected()
+		b.Logf("insert %d rows", n)
+	}
+}
diff --git a/contrib/drivers/mysql/mysql_z_unit_core_test.go b/contrib/drivers/mysql/mysql_z_unit_core_test.go
index 604740606..b9334e445 100644
--- a/contrib/drivers/mysql/mysql_z_unit_core_test.go
+++ b/contrib/drivers/mysql/mysql_z_unit_core_test.go
@@ -466,6 +466,31 @@ func Test_DB_BatchInsert(t *testing.T) {
 		n, _ := result.RowsAffected()
 		t.Assert(n, 1)
 	})
+
+	// Batch insert with different fields
+	gtest.C(t, func(t *gtest.T) {
+		table := createTable()
+		defer dropTable(table)
+		r, err := db.Insert(ctx, table, g.List{
+			{
+				"id":          2,
+				"passport":    "t2",
+				"password":    "25d55ad283aa400af464c76d713c07ac",
+				"create_time": gtime.Now().String(),
+			},
+			{
+				"id":          3,
+				"passport":    "user_3",
+				"password":    "25d55ad283aa400af464c76d713c07ad",
+				"nickname":    "name_3",
+				"create_time": gtime.Now().String(),
+			},
+		}, 1)
+		t.AssertNil(err)
+		n, err := r.RowsAffected()
+		t.AssertNil(err)
+		t.Assert(n, 2)
+	})
 }
 
 func Test_DB_BatchInsert_Struct(t *testing.T) {
diff --git a/contrib/drivers/mysql/mysql_z_unit_init_test.go b/contrib/drivers/mysql/mysql_z_unit_init_test.go
index 3c0f2f762..0269d898e 100644
--- a/contrib/drivers/mysql/mysql_z_unit_init_test.go
+++ b/contrib/drivers/mysql/mysql_z_unit_init_test.go
@@ -178,7 +178,7 @@ func Test_PartitionTable(t *testing.T) {
 	createShopDBTable()
 	insertShopDBData()
 
-	//defer dropShopDBTable()
+	// defer dropShopDBTable()
 	gtest.C(t, func(t *gtest.T) {
 		data, err := db3.Ctx(ctx).Model("dbx_order").Partition("p3", "p4").All()
 		t.AssertNil(err)
diff --git a/contrib/drivers/mysql/mysql_z_unit_issue_test.go b/contrib/drivers/mysql/mysql_z_unit_issue_test.go
index 6f4656bec..edb4b2a18 100644
--- a/contrib/drivers/mysql/mysql_z_unit_issue_test.go
+++ b/contrib/drivers/mysql/mysql_z_unit_issue_test.go
@@ -853,8 +853,8 @@ func Test_Issue2561(t *testing.T) {
 		}
 		result, err := db.Model(table).Data(data).Insert()
 		t.AssertNil(err)
-		m, _ := result.LastInsertId()
-		t.Assert(m, 3)
+		// m, _ := result.LastInsertId() // TODO: The order of LastInsertId cannot be guaranteed
+		// t.Assert(m, 3)
 
 		n, _ := result.RowsAffected()
 		t.Assert(n, 3)
@@ -1002,11 +1002,11 @@ func Test_Issue3086(t *testing.T) {
 		}
 		data := g.Slice{
 			User{
-				Id:       nil,
+				Id:       1,
 				Passport: "user_1",
 			},
 			User{
-				Id:       2,
+				Id:       1,
 				Passport: "user_2",
 			},
 		}
@@ -1024,11 +1024,11 @@ func Test_Issue3086(t *testing.T) {
 		}
 		data := g.Slice{
 			User{
-				Id:       1,
+				Id:       3,
 				Passport: "user_1",
 			},
 			User{
-				Id:       2,
+				Id:       4,
 				Passport: "user_2",
 			},
 		}
@@ -1865,3 +1865,87 @@ func Test_Issue4086(t *testing.T) {
 		})
 	})
 }
+
+// https://github.com/gogf/gf/issues/4500
+// Raw() Count ignores Where condition
+func Test_Issue4500(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	// Test 1: Raw SQL with WHERE + external Where condition + Count
+	// This tests that formatCondition correctly uses AND when Raw SQL already has WHERE
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.
+			Raw(fmt.Sprintf("SELECT * FROM %s WHERE id IN (?)", table), g.Slice{1, 5, 7, 8, 9, 10}).
+			WhereLT("id", 8).
+			Count()
+		t.AssertNil(err)
+		// Raw SQL: id IN (1,5,7,8,9,10) = 6 records
+		// Where: id < 8 filters to {1,5,7} = 3 records
+		t.Assert(count, 3)
+	})
+
+	// Test 2: Raw SQL without WHERE + external Where condition + Count
+	// This tests that formatCondition correctly adds WHERE
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.
+			Raw(fmt.Sprintf("SELECT * FROM %s", table)).
+			WhereLT("id", 5).
+			Count()
+		t.AssertNil(err)
+		// Raw SQL: all 10 records
+		// Where: id < 5 = {1,2,3,4} = 4 records
+		t.Assert(count, 4)
+	})
+
+	// Test 3: Raw + Where + ScanAndCount
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id       int
+			Passport string
+		}
+		var users []User
+		var total int
+		err := db.
+			Raw(fmt.Sprintf("SELECT * FROM %s WHERE id IN (?)", table), g.Slice{1, 5, 7, 8, 9, 10}).
+			WhereLT("id", 8).
+			ScanAndCount(&users, &total, false)
+		t.AssertNil(err)
+		// Both scan result and count should respect Where condition
+		t.Assert(len(users), 3)
+		t.Assert(total, 3)
+	})
+
+	// Test 4: Raw + multiple Where conditions + Count
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.
+			Raw(fmt.Sprintf("SELECT * FROM %s WHERE id > ?", table), 0).
+			WhereLT("id", 5).
+			WhereGTE("id", 2).
+			Count()
+		t.AssertNil(err)
+		// Raw: id > 0 (all 10 records)
+		// Where: id < 5 AND id >= 2 = {2, 3, 4} = 3 records
+		t.Assert(count, 3)
+	})
+
+	// Test 5: Raw SQL with no external Where + Count (baseline test)
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.
+			Raw(fmt.Sprintf("SELECT * FROM %s WHERE id IN (?)", table), g.Slice{1, 2, 3}).
+			Count()
+		t.AssertNil(err)
+		// Should count 3 records
+		t.Assert(count, 3)
+	})
+
+	// Test 6: Verify All() still works correctly with Raw + Where
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.
+			Raw(fmt.Sprintf("SELECT * FROM %s WHERE id IN (?)", table), g.Slice{1, 5, 7, 8, 9, 10}).
+			WhereLT("id", 8).
+			All()
+		t.AssertNil(err)
+		t.Assert(len(all), 3)
+	})
+}
diff --git a/contrib/drivers/mysql/mysql_z_unit_model_test.go b/contrib/drivers/mysql/mysql_z_unit_model_test.go
index e4190e663..cd56d5d16 100644
--- a/contrib/drivers/mysql/mysql_z_unit_model_test.go
+++ b/contrib/drivers/mysql/mysql_z_unit_model_test.go
@@ -2944,7 +2944,9 @@ func Test_Model_Raw(t *testing.T) {
 			Limit(2).
 			Count()
 		t.AssertNil(err)
-		t.Assert(count, int64(6))
+		// Raw SQL selects {1,5,7,8,9,10}, Where filters to id < 8 AND id IN {1,2,3,4,5,6,7}
+		// Result: {1,5,7} = 3 records
+		t.Assert(count, int64(3))
 	})
 }
 
@@ -3783,6 +3785,7 @@ func Test_Model_FixGdbJoin(t *testing.T) {
 				FieldsPrefix(`rules_template`, "name").
 				FieldsPrefix(`common_resource`, `src_instance_id`, "database_kind", "source_type", "ip", "port")
 			all, err := orm.OrderAsc("src_instance_id").All()
+			t.Assert(err, nil)
 			t.Assert(len(all), 4)
 			t.Assert(all[0]["pay_mode"], 1)
 			t.Assert(all[0]["src_instance_id"], 2)
diff --git a/contrib/drivers/mysql/testdata/fix_gdb_join_expect.sql b/contrib/drivers/mysql/testdata/fix_gdb_join_expect.sql
index c391675cb..2ee4a53a4 100644
--- a/contrib/drivers/mysql/testdata/fix_gdb_join_expect.sql
+++ b/contrib/drivers/mysql/testdata/fix_gdb_join_expect.sql
@@ -1 +1 @@
-SELECT managed_resource.resource_id,managed_resource.user,managed_resource.status,managed_resource.status_message,managed_resource.safe_publication,managed_resource.rule_template_id,managed_resource.created_at,managed_resource.comments,managed_resource.expired_at,managed_resource.resource_mark_id,managed_resource.instance_id,managed_resource.resource_name,managed_resource.pay_mode,resource_mark.mark_name,resource_mark.color,rules_template.name,common_resource.src_instance_id,common_resource.database_kind,common_resource.source_type,common_resource.ip,common_resource.port FROM `managed_resource` LEFT JOIN `common_resource` ON (`managed_resource`.`resource_id`=`common_resource`.`resource_id`) LEFT JOIN `resource_mark` ON (`managed_resource`.`resource_mark_id` = `resource_mark`.`id`) LEFT JOIN `rules_template` ON (`managed_resource`.`rule_template_id` = `rules_template`.`template_id`) ORDER BY `src_instance_id` ASC
\ No newline at end of file
+SELECT `managed_resource`.`resource_id`,`managed_resource`.`user`,`managed_resource`.`status`,`managed_resource`.`status_message`,`managed_resource`.`safe_publication`,`managed_resource`.`rule_template_id`,`managed_resource`.`created_at`,`managed_resource`.`comments`,`managed_resource`.`expired_at`,`managed_resource`.`resource_mark_id`,`managed_resource`.`instance_id`,`managed_resource`.`resource_name`,`managed_resource`.`pay_mode`,`resource_mark`.`mark_name`,`resource_mark`.`color`,`rules_template`.`name`,`common_resource`.`src_instance_id`,`common_resource`.`database_kind`,`common_resource`.`source_type`,`common_resource`.`ip`,`common_resource`.`port` FROM `managed_resource` LEFT JOIN `common_resource` ON (`managed_resource`.`resource_id`=`common_resource`.`resource_id`) LEFT JOIN `resource_mark` ON (`managed_resource`.`resource_mark_id` = `resource_mark`.`id`) LEFT JOIN `rules_template` ON (`managed_resource`.`rule_template_id` = `rules_template`.`template_id`) ORDER BY `src_instance_id` ASC
\ No newline at end of file
diff --git a/contrib/drivers/oceanbase/go.mod b/contrib/drivers/oceanbase/go.mod
new file mode 100644
index 000000000..98a192c0d
--- /dev/null
+++ b/contrib/drivers/oceanbase/go.mod
@@ -0,0 +1,44 @@
+module github.com/gogf/gf/contrib/drivers/oceanbase/v2
+
+go 1.23.0
+
+require (
+	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.8
+	github.com/gogf/gf/v2 v2.9.8
+)
+
+require (
+	github.com/BurntSushi/toml v1.5.0 // indirect
+	github.com/clbanning/mxj/v2 v2.7.0 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
+	github.com/fatih/color v1.18.0 // indirect
+	github.com/fsnotify/fsnotify v1.9.0 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-sql-driver/mysql v1.7.1 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/gorilla/websocket v1.5.3 // indirect
+	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
+	github.com/magiconair/properties v1.8.10 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/olekukonko/errors v1.1.0 // indirect
+	github.com/olekukonko/ll v0.0.9 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/sys v0.35.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
+
+replace (
+	github.com/gogf/gf/contrib/drivers/mysql/v2 => ../mysql
+	github.com/gogf/gf/v2 => ../../../
+)
diff --git a/contrib/drivers/oceanbase/go.sum b/contrib/drivers/oceanbase/go.sum
new file mode 100644
index 000000000..f96db96f2
--- /dev/null
+++ b/contrib/drivers/oceanbase/go.sum
@@ -0,0 +1,81 @@
+github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
+github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
+github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyME=
+github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
+github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
+github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
+github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtgzltlQbOBae4=
+github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
+github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
+github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
+github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
+github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/contrib/drivers/oceanbase/oceanbase.go b/contrib/drivers/oceanbase/oceanbase.go
new file mode 100644
index 000000000..30f90a763
--- /dev/null
+++ b/contrib/drivers/oceanbase/oceanbase.go
@@ -0,0 +1,49 @@
+// 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 oceanbase implements gdb.Driver, which supports operations for database OceanBase.
+package oceanbase
+
+import (
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+
+	"github.com/gogf/gf/contrib/drivers/mysql/v2"
+)
+
+// Driver is the driver for OceanBase database.
+//
+// OceanBase is a distributed relational database developed by Ant Group. It supports both MySQL and Oracle
+// protocol modes. This driver uses the MySQL protocol to communicate with OceanBase database in MySQL
+// compatibility mode.
+//
+// Although OceanBase is compatible with MySQL protocol, it is packaged as a separate driver component
+// rather than reusing the mysql adapter directly. This design allows for future extensibility,
+// such as implementing OceanBase-specific features like distributed transactions or Oracle mode support.
+type Driver struct {
+	*mysql.Driver
+}
+
+func init() {
+	var (
+		err         error
+		driverObj   = New()
+		driverNames = g.SliceStr{"oceanbase"}
+	)
+	for _, driverName := range driverNames {
+		if err = gdb.Register(driverName, driverObj); err != nil {
+			panic(err)
+		}
+	}
+}
+
+// New creates and returns a driver that implements gdb.Driver, which supports operations for OceanBase.
+func New() gdb.Driver {
+	mysqlDriver := mysql.New().(*mysql.Driver)
+	return &Driver{
+		Driver: mysqlDriver,
+	}
+}
diff --git a/contrib/drivers/oracle/go.mod b/contrib/drivers/oracle/go.mod
index 08899feeb..57966aca3 100644
--- a/contrib/drivers/oracle/go.mod
+++ b/contrib/drivers/oracle/go.mod
@@ -3,14 +3,14 @@ module github.com/gogf/gf/contrib/drivers/oracle/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 	github.com/sijms/go-ora/v2 v2.7.10
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -19,21 +19,21 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/drivers/oracle/go.sum b/contrib/drivers/oracle/go.sum
index 93a1fcc6b..0c0e996d5 100644
--- a/contrib/drivers/oracle/go.sum
+++ b/contrib/drivers/oracle/go.sum
@@ -4,8 +4,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -29,8 +29,9 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -39,38 +40,40 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/sijms/go-ora/v2 v2.7.10 h1:GSLdj0PYYgSndhsnm7b6p32OqgnwnUZSkFb3j+htfhI=
 github.com/sijms/go-ora/v2 v2.7.10/go.mod h1:EHxlY6x7y9HAsdfumurRfTd+v8NrEOTR3Xl4FWlH6xk=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/contrib/drivers/oracle/oracle.go b/contrib/drivers/oracle/oracle.go
index ae6a1c5dd..51aa4df25 100644
--- a/contrib/drivers/oracle/oracle.go
+++ b/contrib/drivers/oracle/oracle.go
@@ -5,10 +5,6 @@
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package oracle implements gdb.Driver, which supports operations for database Oracle.
-//
-// Note:
-// 1. It does not support Save/Replace features.
-// 2. It does not support LastInsertId.
 package oracle
 
 import (
diff --git a/contrib/drivers/oracle/oracle_do_exec.go b/contrib/drivers/oracle/oracle_do_exec.go
new file mode 100644
index 000000000..d7fe4a39d
--- /dev/null
+++ b/contrib/drivers/oracle/oracle_do_exec.go
@@ -0,0 +1,120 @@
+// 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 oracle
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+)
+
+const (
+	returningClause = " RETURNING %s INTO ?"
+)
+
+// DoExec commits the sql string and its arguments to underlying driver
+// through given link object and returns the execution result.
+// It handles INSERT statements specially to support LastInsertId.
+func (d *Driver) DoExec(
+	ctx context.Context, link gdb.Link, sql string, args ...interface{},
+) (result sql.Result, err error) {
+	var (
+		isUseCoreDoExec = true
+		primaryKey      string
+		pkField         gdb.TableField
+	)
+
+	// Transaction checks.
+	if link == nil {
+		if tx := gdb.TXFromCtx(ctx, d.GetGroup()); tx != nil {
+			link = tx
+		} else if link, err = d.MasterLink(); err != nil {
+			return nil, err
+		}
+	} else if !link.IsTransaction() {
+		if tx := gdb.TXFromCtx(ctx, d.GetGroup()); tx != nil {
+			link = tx
+		}
+	}
+
+	// Check if it is an insert operation with primary key from context.
+	if value := ctx.Value(internalPrimaryKeyInCtx); value != nil {
+		if field, ok := value.(gdb.TableField); ok {
+			pkField = field
+			isUseCoreDoExec = false
+		}
+	}
+
+	// Check if it is an INSERT statement with primary key.
+	if !isUseCoreDoExec && pkField.Name != "" && strings.Contains(strings.ToUpper(sql), "INSERT INTO") {
+		primaryKey = pkField.Name
+		// Oracle supports RETURNING clause to get the last inserted id
+		sql += fmt.Sprintf(returningClause, d.QuoteWord(primaryKey))
+	} else {
+		// Use default DoExec for non-INSERT or no primary key scenarios
+		return d.Core.DoExec(ctx, link, sql, args...)
+	}
+
+	// Only the insert operation with primary key can execute the following code
+
+	// SQL filtering.
+	sql, args = d.FormatSqlBeforeExecuting(sql, args)
+	sql, args, err = d.DoFilter(ctx, link, sql, args)
+	if err != nil {
+		return nil, err
+	}
+
+	// Prepare output variable for RETURNING clause
+	var lastInsertId int64
+	// Append the output parameter for the RETURNING clause
+	args = append(args, &lastInsertId)
+
+	// Link execution.
+	_, err = d.DoCommit(ctx, gdb.DoCommitInput{
+		Link:          link,
+		Sql:           sql,
+		Args:          args,
+		Stmt:          nil,
+		Type:          gdb.SqlTypeExecContext,
+		IsTransaction: link.IsTransaction(),
+	})
+
+	if err != nil {
+		return &Result{
+			lastInsertId:      0,
+			rowsAffected:      0,
+			lastInsertIdError: err,
+		}, err
+	}
+
+	// Get rows affected from the result
+	// For single insert with RETURNING clause, affected is always 1
+	var affected int64 = 1
+
+	// Check if the primary key field type supports LastInsertId
+	if !strings.Contains(strings.ToLower(pkField.Type), "int") {
+		return &Result{
+			lastInsertId: 0,
+			rowsAffected: affected,
+			lastInsertIdError: gerror.NewCodef(
+				gcode.CodeNotSupported,
+				"LastInsertId is not supported by primary key type: %s",
+				pkField.Type,
+			),
+		}, nil
+	}
+
+	return &Result{
+		lastInsertId: lastInsertId,
+		rowsAffected: affected,
+	}, nil
+}
diff --git a/contrib/drivers/oracle/oracle_do_insert.go b/contrib/drivers/oracle/oracle_do_insert.go
index d59bdf95b..ec0273f93 100644
--- a/contrib/drivers/oracle/oracle_do_insert.go
+++ b/contrib/drivers/oracle/oracle_do_insert.go
@@ -16,11 +16,17 @@ import (
 	"github.com/gogf/gf/v2/database/gdb"
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/os/gctx"
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
+const (
+	internalPrimaryKeyInCtx gctx.StrKey = "primary_key_field"
+)
+
 // DoInsert inserts or updates data for given table.
+// The list parameter must contain at least one record, which was previously validated.
 func (d *Driver) DoInsert(
 	ctx context.Context, link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
 ) (result sql.Result, err error) {
@@ -29,10 +35,39 @@ func (d *Driver) DoInsert(
 		return d.doSave(ctx, link, table, list, option)
 
 	case gdb.InsertOptionReplace:
-		return nil, gerror.NewCode(
-			gcode.CodeNotSupported,
-			`Replace operation is not supported by oracle driver`,
-		)
+		// Oracle does not support REPLACE INTO syntax, use SAVE instead.
+		return d.doSave(ctx, link, table, list, option)
+
+	case gdb.InsertOptionIgnore:
+		// Oracle does not support INSERT IGNORE syntax, use MERGE instead.
+		return d.doInsertIgnore(ctx, link, table, list, option)
+
+	case gdb.InsertOptionDefault:
+		// For default insert, set primary key field in context to support LastInsertId.
+		// Only set it when the primary key is not provided in the data, for performance reason.
+		tableFields, err := d.GetCore().GetDB().TableFields(ctx, table)
+		if err == nil && len(list) > 0 {
+			for _, field := range tableFields {
+				if strings.EqualFold(field.Key, "pri") {
+					// Check if primary key is provided in the data.
+					pkProvided := false
+					for key := range list[0] {
+						if strings.EqualFold(key, field.Name) {
+							pkProvided = true
+							break
+						}
+					}
+					// Only use RETURNING when primary key is not provided, for performance reason.
+					if !pkProvided {
+						pkField := *field
+						ctx = context.WithValue(ctx, internalPrimaryKeyInCtx, pkField)
+					}
+					break
+				}
+			}
+		}
+
+	default:
 	}
 	var (
 		keys   []string
@@ -55,8 +90,8 @@ func (d *Driver) DoInsert(
 		valueHolderStr = strings.Join(valueHolder, ",")
 	)
 	// Format "INSERT...INTO..." statement.
-	intoStrArray := make([]string, 0)
-	for i := 0; i < len(list); i++ {
+	// Note: Use standard INSERT INTO syntax instead of INSERT ALL to ensure triggers fire
+	for i := 0; i < listLength; i++ {
 		for _, k := range keys {
 			if s, ok := list[i][k].(gdb.Raw); ok {
 				params = append(params, gconv.String(s))
@@ -65,30 +100,22 @@ func (d *Driver) DoInsert(
 			}
 		}
 		values = append(values, valueHolderStr)
-		intoStrArray = append(
-			intoStrArray,
-			fmt.Sprintf(
-				"INTO %s(%s) VALUES(%s)",
-				table, keyStr, valueHolderStr,
-			),
-		)
-		if len(intoStrArray) == option.BatchCount || (i == listLength-1 && len(valueHolder) > 0) {
-			r, err := d.DoExec(ctx, link, fmt.Sprintf(
-				"INSERT ALL %s SELECT * FROM DUAL",
-				strings.Join(intoStrArray, " "),
-			), params...)
-			if err != nil {
-				return r, err
-			}
-			if n, err := r.RowsAffected(); err != nil {
-				return r, err
-			} else {
-				batchResult.Result = r
-				batchResult.Affected += n
-			}
-			params = params[:0]
-			intoStrArray = intoStrArray[:0]
+
+		// Execute individual INSERT for each record to trigger row-level triggers
+		r, err := d.DoExec(ctx, link, fmt.Sprintf(
+			"INSERT INTO %s(%s) VALUES(%s)",
+			table, keyStr, valueHolderStr,
+		), params...)
+		if err != nil {
+			return r, err
 		}
+		if n, err := r.RowsAffected(); err != nil {
+			return r, err
+		} else {
+			batchResult.Result = r
+			batchResult.Affected += n
+		}
+		params = params[:0]
 	}
 	return batchResult, nil
 }
@@ -97,25 +124,64 @@ func (d *Driver) DoInsert(
 func (d *Driver) doSave(ctx context.Context,
 	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
 ) (result sql.Result, err error) {
-	if len(option.OnConflict) == 0 {
-		return nil, gerror.NewCode(
-			gcode.CodeMissingParameter, `Please specify conflict columns`,
-		)
-	}
+	return d.doMergeInsert(ctx, link, table, list, option, true)
+}
 
-	if len(list) == 0 {
-		return nil, gerror.NewCode(
-			gcode.CodeInvalidRequest, `Save operation list is empty by oracle driver`,
-		)
+// doInsertIgnore implements INSERT IGNORE operation using MERGE statement for Oracle database.
+// It only inserts records when there's no conflict on primary/unique keys.
+func (d *Driver) doInsertIgnore(ctx context.Context,
+	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
+) (result sql.Result, err error) {
+	return d.doMergeInsert(ctx, link, table, list, option, false)
+}
+
+// doMergeInsert implements MERGE-based insert operations for Oracle database.
+// When withUpdate is true, it performs upsert (insert or update).
+// When withUpdate is false, it performs insert ignore (insert only when no conflict).
+func (d *Driver) doMergeInsert(
+	ctx context.Context,
+	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption, withUpdate bool,
+) (result sql.Result, err error) {
+	// If OnConflict is not specified, automatically get the primary key of the table
+	conflictKeys := option.OnConflict
+	if len(conflictKeys) == 0 {
+		primaryKeys, err := d.Core.GetPrimaryKeys(ctx, table)
+		if err != nil {
+			return nil, gerror.WrapCode(
+				gcode.CodeInternalError,
+				err,
+				`failed to get primary keys for table`,
+			)
+		}
+		foundPrimaryKey := false
+		for _, primaryKey := range primaryKeys {
+			for dataKey := range list[0] {
+				if strings.EqualFold(dataKey, primaryKey) {
+					foundPrimaryKey = true
+					break
+				}
+			}
+			if foundPrimaryKey {
+				break
+			}
+		}
+		if !foundPrimaryKey {
+			return nil, gerror.NewCodef(
+				gcode.CodeMissingParameter,
+				`Replace/Save/InsertIgnore operation requires conflict detection: `+
+					`either specify OnConflict() columns or ensure table '%s' has a primary key in the data`,
+				table,
+			)
+		}
+		// TODO consider composite primary keys.
+		conflictKeys = primaryKeys
 	}
 
 	var (
-		one          = list[0]
-		oneLen       = len(one)
-		charL, charR = d.GetChars()
-
-		conflictKeys   = option.OnConflict
-		conflictKeySet = gset.New(false)
+		one            = list[0]
+		oneLen         = len(one)
+		charL, charR   = d.GetChars()
+		conflictKeySet = gset.NewStrSet(false)
 
 		// queryHolders:	Handle data with Holder that need to be upsert
 		// queryValues:		Handle data that need to be upsert
@@ -142,9 +208,9 @@ func (d *Driver) doSave(ctx context.Context,
 		insertKeys[index] = keyWithChar
 		insertValues[index] = fmt.Sprintf("T2.%s", keyWithChar)
 
-		// filter conflict keys in updateValues.
-		// And the key is not a soft created field.
-		if !(conflictKeySet.Contains(key) || d.Core.IsSoftCreatedFieldName(key)) {
+		// Build updateValues only when withUpdate is true
+		// Filter conflict keys and soft created fields from updateValues
+		if withUpdate && !(conflictKeySet.Contains(key) || d.Core.IsSoftCreatedFieldName(key)) {
 			updateValues = append(
 				updateValues,
 				fmt.Sprintf(`T1.%s = T2.%s`, keyWithChar, keyWithChar),
@@ -153,8 +219,10 @@ func (d *Driver) doSave(ctx context.Context,
 		index++
 	}
 
-	batchResult := new(gdb.SqlResult)
-	sqlStr := parseSqlForUpsert(table, queryHolders, insertKeys, insertValues, updateValues, conflictKeys)
+	var (
+		batchResult = new(gdb.SqlResult)
+		sqlStr      = parseSqlForMerge(table, queryHolders, insertKeys, insertValues, updateValues, conflictKeys)
+	)
 	r, err := d.DoExec(ctx, link, sqlStr, queryValues...)
 	if err != nil {
 		return r, err
@@ -168,40 +236,43 @@ func (d *Driver) doSave(ctx context.Context,
 	return batchResult, nil
 }
 
-// parseSqlForUpsert
-// MERGE INTO {{table}} T1
-// USING ( SELECT {{queryHolders}} FROM DUAL T2
-// ON (T1.{{duplicateKey}} = T2.{{duplicateKey}} AND ...)
-// WHEN NOT MATCHED THEN
-// INSERT {{insertKeys}} VALUES {{insertValues}}
-// WHEN MATCHED THEN
-// UPDATE SET {{updateValues}}
-func parseSqlForUpsert(table string,
+// parseSqlForMerge generates MERGE statement for Oracle database.
+// When updateValues is empty, it only inserts (INSERT IGNORE behavior).
+// When updateValues is provided, it performs upsert (INSERT or UPDATE).
+// Examples:
+// - INSERT IGNORE: MERGE INTO table T1 USING (...) T2 ON (...) WHEN NOT MATCHED THEN INSERT(...) VALUES (...)
+// - UPSERT: MERGE INTO table T1 USING (...) T2 ON (...) WHEN NOT MATCHED THEN INSERT(...) VALUES (...) WHEN MATCHED THEN UPDATE SET ...
+func parseSqlForMerge(table string,
 	queryHolders, insertKeys, insertValues, updateValues, duplicateKey []string,
 ) (sqlStr string) {
 	var (
 		queryHolderStr  = strings.Join(queryHolders, ",")
 		insertKeyStr    = strings.Join(insertKeys, ",")
 		insertValueStr  = strings.Join(insertValues, ",")
-		updateValueStr  = strings.Join(updateValues, ",")
 		duplicateKeyStr string
-		pattern         = gstr.Trim(`MERGE INTO %s T1 USING (SELECT %s FROM DUAL) T2 ON (%s) WHEN NOT MATCHED THEN INSERT(%s) VALUES (%s) WHEN MATCHED THEN UPDATE SET %s`)
 	)
 
+	// Build ON condition
 	for index, keys := range duplicateKey {
 		if index != 0 {
 			duplicateKeyStr += " AND "
 		}
-		duplicateTmp := fmt.Sprintf("T1.%s = T2.%s", keys, keys)
-		duplicateKeyStr += duplicateTmp
+		duplicateKeyStr += fmt.Sprintf("T1.%s = T2.%s", keys, keys)
 	}
 
-	return fmt.Sprintf(pattern,
-		table,
-		queryHolderStr,
-		duplicateKeyStr,
-		insertKeyStr,
-		insertValueStr,
-		updateValueStr,
+	// Build SQL based on whether UPDATE is needed
+	pattern := gstr.Trim(
+		`MERGE INTO %s T1 USING (SELECT %s FROM DUAL) T2 ON (%s) WHEN ` +
+			`NOT MATCHED THEN INSERT(%s) VALUES (%s)`,
 	)
+	if len(updateValues) > 0 {
+		// Upsert: INSERT or UPDATE
+		pattern += gstr.Trim(` WHEN MATCHED THEN UPDATE SET %s`)
+		return fmt.Sprintf(
+			pattern, table, queryHolderStr, duplicateKeyStr, insertKeyStr, insertValueStr,
+			strings.Join(updateValues, ","),
+		)
+	}
+	// Insert Ignore: INSERT only
+	return fmt.Sprintf(pattern, table, queryHolderStr, duplicateKeyStr, insertKeyStr, insertValueStr)
 }
diff --git a/contrib/drivers/oracle/oracle_result.go b/contrib/drivers/oracle/oracle_result.go
new file mode 100644
index 000000000..a4795530b
--- /dev/null
+++ b/contrib/drivers/oracle/oracle_result.go
@@ -0,0 +1,24 @@
+// 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 oracle
+
+// Result implements sql.Result interface for Oracle database.
+type Result struct {
+	lastInsertId      int64
+	rowsAffected      int64
+	lastInsertIdError error
+}
+
+// LastInsertId returns the last insert id.
+func (r *Result) LastInsertId() (int64, error) {
+	return r.lastInsertId, r.lastInsertIdError
+}
+
+// RowsAffected returns the rows affected.
+func (r *Result) RowsAffected() (int64, error) {
+	return r.rowsAffected, nil
+}
diff --git a/contrib/drivers/oracle/oracle_table_fields.go b/contrib/drivers/oracle/oracle_table_fields.go
index aa20858dc..8efb9c110 100644
--- a/contrib/drivers/oracle/oracle_table_fields.go
+++ b/contrib/drivers/oracle/oracle_table_fields.go
@@ -18,13 +18,23 @@ import (
 var (
 	tableFieldsSqlTmp = `
 SELECT 
-    COLUMN_NAME AS FIELD, 
+    c.COLUMN_NAME AS FIELD, 
     CASE   
-    WHEN (DATA_TYPE='NUMBER' AND NVL(DATA_SCALE,0)=0) THEN 'INT'||'('||DATA_PRECISION||','||DATA_SCALE||')'
-    WHEN (DATA_TYPE='NUMBER' AND NVL(DATA_SCALE,0)>0) THEN 'FLOAT'||'('||DATA_PRECISION||','||DATA_SCALE||')'
-    WHEN DATA_TYPE='FLOAT' THEN DATA_TYPE||'('||DATA_PRECISION||','||DATA_SCALE||')' 
-    ELSE DATA_TYPE||'('||DATA_LENGTH||')' END AS TYPE,NULLABLE
-FROM USER_TAB_COLUMNS WHERE TABLE_NAME = '%s' ORDER BY COLUMN_ID
+    WHEN (c.DATA_TYPE='NUMBER' AND NVL(c.DATA_SCALE,0)=0) THEN 'INT'||'('||c.DATA_PRECISION||','||c.DATA_SCALE||')'
+    WHEN (c.DATA_TYPE='NUMBER' AND NVL(c.DATA_SCALE,0)>0) THEN 'FLOAT'||'('||c.DATA_PRECISION||','||c.DATA_SCALE||')'
+    WHEN c.DATA_TYPE='FLOAT' THEN c.DATA_TYPE||'('||c.DATA_PRECISION||','||c.DATA_SCALE||')' 
+    ELSE c.DATA_TYPE||'('||c.DATA_LENGTH||')' END AS TYPE,
+    c.NULLABLE,
+    CASE WHEN pk.COLUMN_NAME IS NOT NULL THEN 'PRI' ELSE '' END AS KEY
+FROM USER_TAB_COLUMNS c
+LEFT JOIN (
+    SELECT cols.COLUMN_NAME 
+    FROM USER_CONSTRAINTS cons 
+    JOIN USER_CONS_COLUMNS cols ON cons.CONSTRAINT_NAME = cols.CONSTRAINT_NAME 
+    WHERE cons.TABLE_NAME = '%s' AND cons.CONSTRAINT_TYPE = 'P'
+) pk ON c.COLUMN_NAME = pk.COLUMN_NAME
+WHERE c.TABLE_NAME = '%s' 
+ORDER BY c.COLUMN_ID
 `
 )
 
@@ -44,7 +54,8 @@ func (d *Driver) TableFields(ctx context.Context, table string, schema ...string
 		result       gdb.Result
 		link         gdb.Link
 		usedSchema   = gutil.GetOrDefaultStr(d.GetSchema(), schema...)
-		structureSql = fmt.Sprintf(tableFieldsSqlTmp, strings.ToUpper(table))
+		upperTable   = strings.ToUpper(table)
+		structureSql = fmt.Sprintf(tableFieldsSqlTmp, upperTable, upperTable)
 	)
 	if link, err = d.SlaveLink(usedSchema); err != nil {
 		return nil, err
@@ -53,6 +64,7 @@ func (d *Driver) TableFields(ctx context.Context, table string, schema ...string
 	if err != nil {
 		return nil, err
 	}
+
 	fields = make(map[string]*gdb.TableField)
 	for i, m := range result {
 		isNull := false
@@ -65,6 +77,7 @@ func (d *Driver) TableFields(ctx context.Context, table string, schema ...string
 			Name:  m["FIELD"].String(),
 			Type:  m["TYPE"].String(),
 			Null:  isNull,
+			Key:   m["KEY"].String(),
 		}
 	}
 	return fields, nil
diff --git a/contrib/drivers/oracle/oracle_z_unit_basic_test.go b/contrib/drivers/oracle/oracle_z_unit_basic_test.go
index 7a0af2624..24836455a 100644
--- a/contrib/drivers/oracle/oracle_z_unit_basic_test.go
+++ b/contrib/drivers/oracle/oracle_z_unit_basic_test.go
@@ -139,10 +139,10 @@ func Test_Do_Insert(t *testing.T) {
 			"CREATE_TIME": gtime.Now().String(),
 		}
 		_, err := db.Save(ctx, "t_user", data, 10)
-		gtest.AssertNE(err, nil)
+		gtest.AssertNil(err)
 
 		_, err = db.Replace(ctx, "t_user", data, 10)
-		gtest.AssertNE(err, nil)
+		gtest.AssertNil(err)
 	})
 }
 
@@ -185,6 +185,7 @@ func Test_DB_Insert(t *testing.T) {
 	table := createTable()
 	defer dropTable(table)
 
+	// db.SetDebug(true)
 	gtest.C(t, func(t *gtest.T) {
 		_, err := db.Insert(ctx, table, g.Map{
 			"ID":          1,
@@ -233,7 +234,7 @@ func Test_DB_Insert(t *testing.T) {
 
 		one, err := db.Model(table).Where("ID", 3).One()
 		t.AssertNil(err)
-		fmt.Println(one)
+		// fmt.Println(one)
 		t.Assert(one["ID"].Int(), 3)
 		t.Assert(one["PASSPORT"].String(), "user_3")
 		t.Assert(one["PASSWORD"].String(), "25d55ad283aa400af464c76d713c07ad")
diff --git a/contrib/drivers/oracle/oracle_z_unit_init_test.go b/contrib/drivers/oracle/oracle_z_unit_init_test.go
index 3e549d4b2..74bf9f26e 100644
--- a/contrib/drivers/oracle/oracle_z_unit_init_test.go
+++ b/contrib/drivers/oracle/oracle_z_unit_init_test.go
@@ -113,16 +113,48 @@ func createTable(table ...string) (name string) {
 
 	dropTable(name)
 
-	if _, err := db.Exec(ctx, fmt.Sprintf(`
-	CREATE TABLE %s (
-		ID NUMBER(10) NOT NULL,
-		PASSPORT VARCHAR(45) NOT NULL,
-		PASSWORD CHAR(32) NOT NULL,
-		NICKNAME VARCHAR(45) NOT NULL,
-		CREATE_TIME varchar(45),
-	    SALARY NUMBER(18,2),
-		PRIMARY KEY (ID))
-	`, name)); err != nil {
+	// Step 1: Create table
+	createTableSQL := fmt.Sprintf(`
+    CREATE TABLE %s (
+        ID NUMBER(10) NOT NULL,
+        PASSPORT VARCHAR(45) NOT NULL,
+        PASSWORD CHAR(32) NOT NULL,
+        NICKNAME VARCHAR(45) NOT NULL,
+        CREATE_TIME VARCHAR(45),
+        SALARY NUMBER(18,2),
+        PRIMARY KEY (ID)
+    )`, name)
+
+	if _, err := db.Exec(ctx, createTableSQL); err != nil {
+		gtest.Fatal(err)
+	}
+
+	// Step 2: Create sequence
+	createSeqSQL := fmt.Sprintf(`
+    CREATE SEQUENCE %s_ID_SEQ
+    START WITH 1
+    INCREMENT BY 1
+    MINVALUE 1
+    MAXVALUE 9999999999
+    NOCYCLE
+    NOCACHE`, name)
+
+	if _, err := db.Exec(ctx, createSeqSQL); err != nil {
+		gtest.Fatal(err)
+	}
+
+	// Step 3: Create trigger - only set ID from sequence when it's NULL
+	createTriggerSQL := fmt.Sprintf(`
+CREATE OR REPLACE TRIGGER %s_ID_TRG
+BEFORE INSERT ON %s
+FOR EACH ROW
+BEGIN
+    IF :NEW.ID IS NULL THEN
+        :NEW.ID := %s_ID_SEQ.NEXTVAL;
+    END IF;
+END;`, name, name, name)
+
+	if _, err := db.Exec(ctx, createTriggerSQL); err != nil {
 		gtest.Fatal(err)
 	}
 
@@ -160,7 +192,15 @@ func dropTable(table string) {
 	if count == 0 {
 		return
 	}
+
+	// Drop table
 	if _, err = db.Exec(ctx, fmt.Sprintf("DROP TABLE %s", table)); err != nil {
 		gtest.Fatal(err)
 	}
+
+	// Drop sequence if exists
+	seqCount, err := db.GetCount(ctx, "SELECT COUNT(*) FROM USER_SEQUENCES WHERE SEQUENCE_NAME = ?", strings.ToUpper(table+"_ID_SEQ"))
+	if err == nil && seqCount > 0 {
+		db.Exec(ctx, fmt.Sprintf("DROP SEQUENCE %s_ID_SEQ", table))
+	}
 }
diff --git a/contrib/drivers/oracle/oracle_z_unit_model_test.go b/contrib/drivers/oracle/oracle_z_unit_model_test.go
index 26031615e..f10e91eab 100644
--- a/contrib/drivers/oracle/oracle_z_unit_model_test.go
+++ b/contrib/drivers/oracle/oracle_z_unit_model_test.go
@@ -233,6 +233,67 @@ func Test_Model_Insert(t *testing.T) {
 	})
 }
 
+func Test_Model_InsertIgnore(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	// db.SetDebug(true)
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"id":          1,
+			"passport":    fmt.Sprintf(`t%d`, 777),
+			"password":    fmt.Sprintf(`p%d`, 777),
+			"nickname":    fmt.Sprintf(`T%d`, 777),
+			"create_time": gtime.Now(),
+		}
+		_, err := db.Model(table).Data(data).InsertIgnore()
+		t.AssertNil(err)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["PASSPORT"].String(), "user_1")
+
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, TableSize)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"passport":    fmt.Sprintf(`t%d`, 777),
+			"password":    fmt.Sprintf(`p%d`, 777),
+			"nickname":    fmt.Sprintf(`T%d`, 777),
+			"create_time": gtime.Now(),
+		}
+		_, err := db.Model(table).Data(data).InsertIgnore()
+		t.AssertNE(err, nil)
+
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, TableSize)
+	})
+}
+
+func Test_Model_InsertAndGetId(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			// "id":          1,
+			"passport":    fmt.Sprintf(`t%d`, 1),
+			"password":    fmt.Sprintf(`p%d`, 1),
+			"nickname":    fmt.Sprintf(`T%d`, 1),
+			"create_time": gtime.Now(),
+		}
+		lastId, err := db.Model(table).Data(data).InsertAndGetId()
+		t.AssertNil(err)
+		t.AssertGT(lastId, 0)
+	})
+
+}
+
 // https://github.com/gogf/gf/issues/3286
 func Test_Model_Insert_Raw(t *testing.T) {
 	table := createTable()
@@ -1179,14 +1240,73 @@ func Test_Model_Replace(t *testing.T) {
 	defer dropTable(table)
 
 	gtest.C(t, func(t *gtest.T) {
-		_, err := db.Model(table).Data(g.Map{
+		// Insert initial record
+		result, err := db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "t1",
+			"password":    "pass1",
+			"nickname":    "T1",
+			"create_time": "2018-10-24 10:00:00",
+		}).Insert()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+
+		// Replace with new data (should update existing record using MERGE)
+		result, err = db.Model(table).Data(g.Map{
 			"id":          1,
 			"passport":    "t11",
 			"password":    "25d55ad283aa400af464c76d713c07ad",
 			"nickname":    "T11",
 			"create_time": "2018-10-24 10:00:00",
+		}).OnConflict("id").Replace()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+
+		// Verify the data was replaced
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one["PASSPORT"].String(), "t11")
+		t.Assert(one["PASSWORD"].String(), "25d55ad283aa400af464c76d713c07ad")
+		t.Assert(one["NICKNAME"].String(), "T11")
+
+		// Replace with new ID (insert new record)
+		result, err = db.Model(table).Data(g.Map{
+			"id":          2,
+			"passport":    "t222",
+			"password":    "pass2",
+			"nickname":    "T222",
+			"create_time": "2018-10-24 11:00:00",
+		}).OnConflict("id").Replace()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+
+		// Verify new record was inserted
+		one, err = db.Model(table).Where("id", 2).One()
+		t.AssertNil(err)
+		t.Assert(one["PASSPORT"].String(), "t222")
+		t.Assert(one["NICKNAME"].String(), "T222")
+
+		// Replace without OnConflict (primary key auto-detection is implemented)
+		_, err = db.Model(table).Data(g.Map{
+			"id":          3,
+			"passport":    "t3",
+			"password":    "pass3",
+			"nickname":    "T3",
+			"create_time": "2018-10-24 12:00:00",
 		}).Replace()
-		t.Assert(err, "Replace operation is not supported by oracle driver")
+		t.AssertNil(err)
+
+		_, err = db.Model(table).Data(g.Map{
+			// "id":          3,
+			"passport":    "t3",
+			"password":    "pass3",
+			"nickname":    "T3",
+			"create_time": "2018-10-24 12:00:00",
+		}).Replace()
+		t.AssertNE(err, nil)
 	})
 }
 
@@ -1227,7 +1347,12 @@ func Test_Model_Raw(t *testing.T) {
 			OrderDesc("ID").
 			Count()
 		t.AssertNil(err)
-		t.Assert(count, 6)
+		// After fix for issue #4500, Where conditions are correctly applied to Raw SQL Count.
+		// Raw SQL matches: id in (1, 5, 7, 8, 9, 10)
+		// WhereLT("ID", 8): id < 8 -> (1, 5, 7)
+		// WhereIn("ID", {1-7}): id in (1, 2, 3, 4, 5, 6, 7) -> (1, 5, 7)
+		// Result: 3 records match all conditions
+		t.Assert(count, int64(3))
 	})
 }
 
diff --git a/contrib/drivers/pgsql/go.mod b/contrib/drivers/pgsql/go.mod
index 3efdb465f..6803cf891 100644
--- a/contrib/drivers/pgsql/go.mod
+++ b/contrib/drivers/pgsql/go.mod
@@ -3,37 +3,37 @@ module github.com/gogf/gf/contrib/drivers/pgsql/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
+	github.com/google/uuid v1.6.0
 	github.com/lib/pq v1.10.9
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/drivers/pgsql/go.sum b/contrib/drivers/pgsql/go.sum
index f358f4198..24ff1ee8b 100644
--- a/contrib/drivers/pgsql/go.sum
+++ b/contrib/drivers/pgsql/go.sum
@@ -4,8 +4,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -31,8 +31,9 @@ github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
 github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -41,36 +42,38 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/contrib/drivers/pgsql/pgsql.go b/contrib/drivers/pgsql/pgsql.go
index b7a18a810..3c3272240 100644
--- a/contrib/drivers/pgsql/pgsql.go
+++ b/contrib/drivers/pgsql/pgsql.go
@@ -5,10 +5,6 @@
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package pgsql implements gdb.Driver, which supports operations for database PostgreSQL.
-//
-// Note:
-// 1. It does not support Replace features.
-// 2. It does not support Insert Ignore features.
 package pgsql
 
 import (
diff --git a/contrib/drivers/pgsql/pgsql_convert.go b/contrib/drivers/pgsql/pgsql_convert.go
index 00e1e92fa..55c310b65 100644
--- a/contrib/drivers/pgsql/pgsql_convert.go
+++ b/contrib/drivers/pgsql/pgsql_convert.go
@@ -11,6 +11,7 @@ import (
 	"reflect"
 	"strings"
 
+	"github.com/google/uuid"
 	"github.com/lib/pq"
 
 	"github.com/gogf/gf/v2/database/gdb"
@@ -43,6 +44,26 @@ func (d *Driver) ConvertValueForField(ctx context.Context, fieldType string, fie
 }
 
 // CheckLocalTypeForField checks and returns corresponding local golang type for given db type.
+// The parameter `fieldType` is in lower case, like:
+// `int2`, `int4`, `int8`, `_int2`, `_int4`, `_int8`, `_float4`, `_float8`, etc.
+//
+// PostgreSQL type mapping:
+//
+//	| PostgreSQL Type              | Local Go Type |
+//	|------------------------------|---------------|
+//	| int2, int4                   | int           |
+//	| int8                         | int64         |
+//	| uuid                         | uuid.UUID     |
+//	| _int2, _int4                 | []int32       | // Note: pq package does not provide Int16Array; int32 is used for compatibility
+//	| _int8                        | []int64       |
+//	| _float4                      | []float32     |
+//	| _float8                      | []float64     |
+//	| _bool                        | []bool        |
+//	| _varchar, _text              | []string      |
+//	| _char, _bpchar               | []string      |
+//	| _numeric, _decimal, _money   | []float64     |
+//	| _bytea                       | [][]byte      |
+//	| _uuid                        | []uuid.UUID   |
 func (d *Driver) CheckLocalTypeForField(ctx context.Context, fieldType string, fieldValue any) (gdb.LocalType, error) {
 	var typeName string
 	match, _ := gregex.MatchString(`(.+?)\((.+)\)`, fieldType)
@@ -53,31 +74,42 @@ func (d *Driver) CheckLocalTypeForField(ctx context.Context, fieldType string, f
 	}
 	typeName = strings.ToLower(typeName)
 	switch typeName {
-	case
-		// For pgsql, int2 = smallint.
-		"int2",
-		// For pgsql, int4 = integer
-		"int4":
+	case "int2", "int4":
 		return gdb.LocalTypeInt, nil
 
-	case
-		// For pgsql, int8 = bigint
-		"int8":
+	case "int8":
 		return gdb.LocalTypeInt64, nil
 
-	case
-		"_int2",
-		"_int4":
-		return gdb.LocalTypeIntSlice, nil
+	case "uuid":
+		return gdb.LocalTypeUUID, nil
 
-	case
-		"_int8":
+	case "_int2", "_int4":
+		return gdb.LocalTypeInt32Slice, nil
+
+	case "_int8":
 		return gdb.LocalTypeInt64Slice, nil
 
-	case
-		"_varchar", "_text":
+	case "_float4":
+		return gdb.LocalTypeFloat32Slice, nil
+
+	case "_float8":
+		return gdb.LocalTypeFloat64Slice, nil
+
+	case "_bool":
+		return gdb.LocalTypeBoolSlice, nil
+
+	case "_varchar", "_text", "_char", "_bpchar":
 		return gdb.LocalTypeStringSlice, nil
 
+	case "_uuid":
+		return gdb.LocalTypeUUIDSlice, nil
+
+	case "_numeric", "_decimal", "_money":
+		return gdb.LocalTypeFloat64Slice, nil
+
+	case "_bytea":
+		return gdb.LocalTypeBytesSlice, nil
+
 	default:
 		return d.Core.CheckLocalTypeForField(ctx, fieldType, fieldValue)
 	}
@@ -85,51 +117,140 @@ func (d *Driver) CheckLocalTypeForField(ctx context.Context, fieldType string, f
 
 // ConvertValueForLocal converts value to local Golang type of value according field type name from database.
 // The parameter `fieldType` is in lower case, like:
-// `float(5,2)`, `unsigned double(5,2)`, `decimal(10,2)`, `char(45)`, `varchar(100)`, etc.
+// `int2`, `int4`, `int8`, `_int2`, `_int4`, `_int8`, `uuid`, `_uuid`, etc.
+//
+// See: https://www.postgresql.org/docs/current/datatype.html
+//
+// PostgreSQL type mapping:
+//
+//	| PostgreSQL Type | SQL Type                       | pq Type         | Go Type     |
+//	|-----------------|--------------------------------|-----------------|-------------|
+//	| int2            | int2, smallint                 | -               | int         |
+//	| int4            | int4, integer                  | -               | int         |
+//	| int8            | int8, bigint, bigserial        | -               | int64       |
+//	| uuid            | uuid                           | -               | uuid.UUID   |
+//	| _int2           | int2[], smallint[]             | pq.Int32Array   | []int32     |
+//	| _int4           | int4[], integer[]              | pq.Int32Array   | []int32     |
+//	| _int8           | int8[], bigint[]               | pq.Int64Array   | []int64     |
+//	| _float4         | float4[], real[]               | pq.Float32Array | []float32   |
+//	| _float8         | float8[], double precision[]   | pq.Float64Array | []float64   |
+//	| _bool           | boolean[], bool[]              | pq.BoolArray    | []bool      |
+//	| _varchar        | varchar[], character varying[] | pq.StringArray  | []string    |
+//	| _text           | text[]                         | pq.StringArray  | []string    |
+//	| _char, _bpchar  | char[], character[]            | pq.StringArray  | []string    |
+//	| _numeric        | numeric[]                      | pq.Float64Array | []float64   |
+//	| _decimal        | decimal[]                      | pq.Float64Array | []float64   |
+//	| _money          | money[]                        | pq.Float64Array | []float64   |
+//	| _bytea          | bytea[]                        | pq.ByteaArray   | [][]byte    |
+//	| _uuid           | uuid[]                         | pq.StringArray  | []uuid.UUID |
+//
+// Note: PostgreSQL also supports these array types but they are not yet mapped:
+//   - _date (date[]), _timestamp (timestamp[]), _timestamptz (timestamptz[])
+//   - _jsonb (jsonb[]), _json (json[])
 func (d *Driver) ConvertValueForLocal(ctx context.Context, fieldType string, fieldValue any) (any, error) {
 	typeName, _ := gregex.ReplaceString(`\(.+\)`, "", fieldType)
 	typeName = strings.ToLower(typeName)
+
+	// Basic types are mostly handled by Core layer, only handle array types here
 	switch typeName {
-	// For pgsql, int2 = smallint and int4 = integer.
-	case "int2", "int4":
-		return gconv.Int(gconv.String(fieldValue)), nil
 
-	// For pgsql, int8 = bigint.
-	case "int8":
-		return gconv.Int64(gconv.String(fieldValue)), nil
+	// []int32
+	case "_int2", "_int4":
+		var result pq.Int32Array
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []int32(result), nil
 
-	// Int32 slice.
-	case
-		"_int2", "_int4":
-		return gconv.Ints(
-			gstr.ReplaceByMap(gconv.String(fieldValue),
-				map[string]string{
-					"{": "[",
-					"}": "]",
-				},
-			),
-		), nil
+	// []int64
+	case "_int8":
+		var result pq.Int64Array
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []int64(result), nil
 
-	// Int64 slice.
-	case
-		"_int8":
-		return gconv.Int64s(
-			gstr.ReplaceByMap(gconv.String(fieldValue),
-				map[string]string{
-					"{": "[",
-					"}": "]",
-				},
-			),
-		), nil
+	// []float32
+	case "_float4":
+		var result pq.Float32Array
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []float32(result), nil
 
-	// String slice.
-	case "_varchar", "_text":
-		var result = make(pq.StringArray, 0)
+	// []float64
+	case "_float8":
+		var result pq.Float64Array
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []float64(result), nil
+
+	// []bool
+	case "_bool":
+		var result pq.BoolArray
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []bool(result), nil
+
+	// []string
+	case "_varchar", "_text", "_char", "_bpchar":
+		var result pq.StringArray
 		if err := result.Scan(fieldValue); err != nil {
 			return nil, err
 		}
 		return []string(result), nil
 
+	// uuid.UUID
+	case "uuid":
+		var uuidStr string
+		switch v := fieldValue.(type) {
+		case []byte:
+			uuidStr = string(v)
+		case string:
+			uuidStr = v
+		default:
+			uuidStr = gconv.String(fieldValue)
+		}
+		result, err := uuid.Parse(uuidStr)
+		if err != nil {
+			return nil, err
+		}
+		return result, nil
+
+	// []uuid.UUID
+	case "_uuid":
+		var strArray pq.StringArray
+		if err := strArray.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		result := make([]uuid.UUID, len(strArray))
+		for i, s := range strArray {
+			parsed, err := uuid.Parse(s)
+			if err != nil {
+				return nil, err
+			}
+			result[i] = parsed
+		}
+		return result, nil
+
+	// []float64
+	case "_numeric", "_decimal", "_money":
+		var result pq.Float64Array
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return []float64(result), nil
+
+	// [][]byte
+	case "_bytea":
+		var result pq.ByteaArray
+		if err := result.Scan(fieldValue); err != nil {
+			return nil, err
+		}
+		return [][]byte(result), nil
+
 	default:
 		return d.Core.ConvertValueForLocal(ctx, fieldType, fieldValue)
 	}
diff --git a/contrib/drivers/pgsql/pgsql_do_insert.go b/contrib/drivers/pgsql/pgsql_do_insert.go
index ec24edde3..6bd0ba142 100644
--- a/contrib/drivers/pgsql/pgsql_do_insert.go
+++ b/contrib/drivers/pgsql/pgsql_do_insert.go
@@ -9,6 +9,7 @@ package pgsql
 import (
 	"context"
 	"database/sql"
+	"strings"
 
 	"github.com/gogf/gf/v2/database/gdb"
 	"github.com/gogf/gf/v2/errors/gcode"
@@ -16,25 +17,68 @@ import (
 )
 
 // DoInsert inserts or updates data for given table.
-func (d *Driver) DoInsert(ctx context.Context, link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption) (result sql.Result, err error) {
+// The list parameter must contain at least one record, which was previously validated.
+func (d *Driver) DoInsert(
+	ctx context.Context,
+	link gdb.Link, table string, list gdb.List, option gdb.DoInsertOption,
+) (result sql.Result, err error) {
 	switch option.InsertOption {
-	case gdb.InsertOptionReplace:
-		return nil, gerror.NewCode(
-			gcode.CodeNotSupported,
-			`Replace operation is not supported by pgsql driver`,
-		)
+	case
+		gdb.InsertOptionSave,
+		gdb.InsertOptionReplace:
+		// PostgreSQL does not support REPLACE INTO syntax, use Save (ON CONFLICT ... DO UPDATE) instead.
+		// Automatically detect primary keys if OnConflict is not specified.
+		if len(option.OnConflict) == 0 {
+			primaryKeys, err := d.Core.GetPrimaryKeys(ctx, table)
+			if err != nil {
+				return nil, gerror.WrapCode(
+					gcode.CodeInternalError,
+					err,
+					`failed to get primary keys for Save/Replace operation`,
+				)
+			}
+			foundPrimaryKey := false
+			for _, primaryKey := range primaryKeys {
+				for dataKey := range list[0] {
+					if strings.EqualFold(dataKey, primaryKey) {
+						foundPrimaryKey = true
+						break
+					}
+				}
+				if foundPrimaryKey {
+					break
+				}
+			}
+			if !foundPrimaryKey {
+				return nil, gerror.NewCodef(
+					gcode.CodeMissingParameter,
+					`Replace/Save operation requires conflict detection: `+
+						`either specify OnConflict() columns or ensure table '%s' has a primary key in the data`,
+					table,
+				)
+			}
+			// TODO consider composite primary keys.
+			option.OnConflict = primaryKeys
+		}
+		// Treat Replace as Save operation
+		option.InsertOption = gdb.InsertOptionSave
 
-	case gdb.InsertOptionDefault:
+	// pgsql support InsertIgnore natively, so no need to set primary key in context.
+	case gdb.InsertOptionIgnore, gdb.InsertOptionDefault:
+		// Get table fields to retrieve the primary key TableField object (not just the name)
+		// because DoExec needs the `TableField.Type` to determine if LastInsertId is supported.
 		tableFields, err := d.GetCore().GetDB().TableFields(ctx, table)
 		if err == nil {
 			for _, field := range tableFields {
-				if field.Key == "pri" {
+				if strings.EqualFold(field.Key, "pri") {
 					pkField := *field
 					ctx = context.WithValue(ctx, internalPrimaryKeyInCtx, pkField)
 					break
 				}
 			}
 		}
+
+	default:
 	}
 	return d.Core.DoInsert(ctx, link, table, list, option)
 }
diff --git a/contrib/drivers/pgsql/pgsql_format_upsert.go b/contrib/drivers/pgsql/pgsql_format_upsert.go
index fc003cb4c..81f989700 100644
--- a/contrib/drivers/pgsql/pgsql_format_upsert.go
+++ b/contrib/drivers/pgsql/pgsql_format_upsert.go
@@ -52,6 +52,10 @@ func (d *Driver) FormatUpsert(columns []string, list gdb.List, option gdb.DoInse
 				if columnVal < 0 {
 					operator, columnVal = "-", -columnVal
 				}
+				// Note: In PostgreSQL ON CONFLICT DO UPDATE, we use EXCLUDED to reference
+				// the value that was proposed for insertion. This differs from MySQL's
+				// ON DUPLICATE KEY UPDATE behavior where the column name without prefix
+				// references the current row's value.
 				onDuplicateStr += fmt.Sprintf(
 					"%s=EXCLUDED.%s%s%s",
 					d.QuoteWord(k),
diff --git a/contrib/drivers/pgsql/pgsql_table_fields.go b/contrib/drivers/pgsql/pgsql_table_fields.go
index d53667c08..8573648f6 100644
--- a/contrib/drivers/pgsql/pgsql_table_fields.go
+++ b/contrib/drivers/pgsql/pgsql_table_fields.go
@@ -16,18 +16,24 @@ import (
 
 var (
 	tableFieldsSqlTmp = `
-SELECT a.attname AS field, t.typname AS type,a.attnotnull as null,
-    (case when d.contype = 'p' then 'pri' when d.contype = 'u' then 'uni' else '' end)  as key
-      ,ic.column_default as default_value,b.description as comment
-      ,coalesce(character_maximum_length, numeric_precision, -1) as length
-      ,numeric_scale as scale
+SELECT
+    a.attname                                                                            AS field,
+    t.typname                                                                            AS type,
+    a.attnotnull                                                                         AS null,
+    (CASE WHEN d.contype = 'p' THEN 'pri' WHEN d.contype = 'u' THEN 'uni' ELSE '' END)   AS key,
+    ic.column_default                                                                    AS default_value,
+    b.description                                                                        AS comment,
+    COALESCE(character_maximum_length, numeric_precision, -1)                            AS length,
+    numeric_scale                                                                        AS scale
 FROM pg_attribute a
-         left join pg_class c on a.attrelid = c.oid
-         left join pg_constraint d on d.conrelid = c.oid and a.attnum = d.conkey[1]
-         left join pg_description b ON a.attrelid=b.objoid AND a.attnum = b.objsubid
-         left join pg_type t ON a.atttypid = t.oid
-         left join information_schema.columns ic on ic.column_name = a.attname and ic.table_name = c.relname
-WHERE c.relname = '%s' and a.attisdropped is false and a.attnum > 0
+    LEFT JOIN pg_class c                 ON a.attrelid = c.oid
+    LEFT JOIN pg_constraint d            ON d.conrelid = c.oid AND a.attnum = d.conkey[1]
+    LEFT JOIN pg_description b           ON a.attrelid = b.objoid AND a.attnum = b.objsubid
+    LEFT JOIN pg_type t                  ON a.atttypid = t.oid
+    LEFT JOIN information_schema.columns ic ON ic.column_name = a.attname AND ic.table_name = c.relname
+WHERE c.oid = '%s'::regclass
+    AND a.attisdropped IS FALSE
+    AND a.attnum > 0
 ORDER BY a.attnum`
 )
 
@@ -57,20 +63,39 @@ func (d *Driver) TableFields(ctx context.Context, table string, schema ...string
 	}
 	fields = make(map[string]*gdb.TableField)
 	var (
-		index = 0
-		name  string
-		ok    bool
+		index         = 0
+		name          string
+		ok            bool
+		existingField *gdb.TableField
 	)
 	for _, m := range result {
 		name = m["field"].String()
-		// Filter duplicated fields.
-		if _, ok = fields[name]; ok {
+		// Merge duplicated fields, especially for key constraints.
+		// Priority: pri > uni > others
+		if existingField, ok = fields[name]; ok {
+			currentKey := m["key"].String()
+			// Merge key information with priority: pri > uni
+			if currentKey == "pri" || (currentKey == "uni" && existingField.Key != "pri") {
+				existingField.Key = currentKey
+			}
 			continue
 		}
+
+		var (
+			fieldType  string
+			dataType   = m["type"].String()
+			dataLength = m["length"].Int()
+		)
+		if dataLength > 0 {
+			fieldType = fmt.Sprintf("%s(%d)", dataType, dataLength)
+		} else {
+			fieldType = dataType
+		}
+
 		fields[name] = &gdb.TableField{
 			Index:   index,
 			Name:    name,
-			Type:    m["type"].String(),
+			Type:    fieldType,
 			Null:    !m["null"].Bool(),
 			Key:     m["key"].String(),
 			Default: m["default_value"].Val(),
diff --git a/contrib/drivers/pgsql/pgsql_z_unit_convert_test.go b/contrib/drivers/pgsql/pgsql_z_unit_convert_test.go
new file mode 100644
index 000000000..62bf92e6e
--- /dev/null
+++ b/contrib/drivers/pgsql/pgsql_z_unit_convert_test.go
@@ -0,0 +1,409 @@
+// 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 pgsql_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/google/uuid"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/test/gtest"
+
+	"github.com/gogf/gf/contrib/drivers/pgsql/v2"
+)
+
+// Test_CheckLocalTypeForField tests the CheckLocalTypeForField method
+// for various PostgreSQL types
+func Test_CheckLocalTypeForField(t *testing.T) {
+	var (
+		ctx    = context.Background()
+		driver = pgsql.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test basic integer types
+		localType, err := driver.CheckLocalTypeForField(ctx, "int2", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeInt)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "int4", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeInt)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "int8", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeInt64)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test integer array types
+		localType, err := driver.CheckLocalTypeForField(ctx, "_int2", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeInt32Slice)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "_int4", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeInt32Slice)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "_int8", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeInt64Slice)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test float array types
+		localType, err := driver.CheckLocalTypeForField(ctx, "_float4", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeFloat32Slice)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "_float8", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeFloat64Slice)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test boolean array type
+		localType, err := driver.CheckLocalTypeForField(ctx, "_bool", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeBoolSlice)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test string array types
+		localType, err := driver.CheckLocalTypeForField(ctx, "_varchar", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeStringSlice)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "_text", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeStringSlice)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "_char", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeStringSlice)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "_bpchar", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeStringSlice)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test numeric array types
+		localType, err := driver.CheckLocalTypeForField(ctx, "_numeric", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeFloat64Slice)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "_decimal", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeFloat64Slice)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "_money", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeFloat64Slice)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test bytea array type
+		localType, err := driver.CheckLocalTypeForField(ctx, "_bytea", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeBytesSlice)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test uuid type
+		localType, err := driver.CheckLocalTypeForField(ctx, "uuid", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeUUID)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test uuid array type
+		localType, err := driver.CheckLocalTypeForField(ctx, "_uuid", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeUUIDSlice)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test type with precision, e.g., "numeric(10,2)"
+		localType, err := driver.CheckLocalTypeForField(ctx, "int2(5)", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeInt)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "int4(10)", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeInt)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "INT8(20)", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeInt64)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test uppercase type names
+		localType, err := driver.CheckLocalTypeForField(ctx, "INT2", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeInt)
+
+		localType, err = driver.CheckLocalTypeForField(ctx, "_INT4", nil)
+		t.AssertNil(err)
+		t.Assert(localType, gdb.LocalTypeInt32Slice)
+	})
+}
+
+// Test_ConvertValueForLocal tests the ConvertValueForLocal method
+func Test_ConvertValueForLocal(t *testing.T) {
+	var (
+		ctx    = context.Background()
+		driver = pgsql.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _int2 array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_int2", []byte(`{1,2,3}`))
+		t.AssertNil(err)
+		t.Assert(result, []int32{1, 2, 3})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _int4 array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_int4", []byte(`{10,20,30}`))
+		t.AssertNil(err)
+		t.Assert(result, []int32{10, 20, 30})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _int8 array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_int8", []byte(`{100,200,300}`))
+		t.AssertNil(err)
+		t.Assert(result, []int64{100, 200, 300})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _float4 array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_float4", []byte(`{1.1,2.2,3.3}`))
+		t.AssertNil(err)
+		resultArr := result.([]float32)
+		t.Assert(len(resultArr), 3)
+		t.Assert(resultArr[0] > 1.0 && resultArr[0] < 1.2, true)
+		t.Assert(resultArr[1] > 2.1 && resultArr[1] < 2.3, true)
+		t.Assert(resultArr[2] > 3.2 && resultArr[2] < 3.4, true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _float8 array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_float8", []byte(`{1.11,2.22,3.33}`))
+		t.AssertNil(err)
+		resultArr := result.([]float64)
+		t.Assert(len(resultArr), 3)
+		t.Assert(resultArr[0] > 1.1 && resultArr[0] < 1.12, true)
+		t.Assert(resultArr[1] > 2.21 && resultArr[1] < 2.23, true)
+		t.Assert(resultArr[2] > 3.32 && resultArr[2] < 3.34, true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _bool array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_bool", []byte(`{t,f,t}`))
+		t.AssertNil(err)
+		t.Assert(result, []bool{true, false, true})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _varchar array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_varchar", []byte(`{a,b,c}`))
+		t.AssertNil(err)
+		t.Assert(result, []string{"a", "b", "c"})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _text array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_text", []byte(`{hello,world}`))
+		t.AssertNil(err)
+		t.Assert(result, []string{"hello", "world"})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _char array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_char", []byte(`{x,y,z}`))
+		t.AssertNil(err)
+		t.Assert(result, []string{"x", "y", "z"})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _bpchar array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_bpchar", []byte(`{a,b}`))
+		t.AssertNil(err)
+		t.Assert(result, []string{"a", "b"})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _numeric array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_numeric", []byte(`{1.11,2.22}`))
+		t.AssertNil(err)
+		resultArr := result.([]float64)
+		t.Assert(len(resultArr), 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _decimal array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_decimal", []byte(`{3.33,4.44}`))
+		t.AssertNil(err)
+		resultArr := result.([]float64)
+		t.Assert(len(resultArr), 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _money array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_money", []byte(`{5.55,6.66}`))
+		t.AssertNil(err)
+		resultArr := result.([]float64)
+		t.Assert(len(resultArr), 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _bytea array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_bytea", []byte(`{"\\x68656c6c6f","\\x776f726c64"}`))
+		t.AssertNil(err)
+		resultArr := result.([][]byte)
+		t.Assert(len(resultArr), 2)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test uuid conversion from []byte
+		result, err := driver.ConvertValueForLocal(ctx, "uuid", []byte(`550e8400-e29b-41d4-a716-446655440000`))
+		t.AssertNil(err)
+		t.Assert(result.(uuid.UUID).String(), "550e8400-e29b-41d4-a716-446655440000")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test uuid conversion from string
+		result, err := driver.ConvertValueForLocal(ctx, "uuid", "550e8400-e29b-41d4-a716-446655440000")
+		t.AssertNil(err)
+		t.Assert(result.(uuid.UUID).String(), "550e8400-e29b-41d4-a716-446655440000")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test uuid conversion error case with invalid uuid
+		_, err := driver.ConvertValueForLocal(ctx, "uuid", "invalid-uuid")
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _uuid array conversion
+		result, err := driver.ConvertValueForLocal(ctx, "_uuid", []byte(`{550e8400-e29b-41d4-a716-446655440000,6ba7b810-9dad-11d1-80b4-00c04fd430c8}`))
+		t.AssertNil(err)
+		resultArr := result.([]uuid.UUID)
+		t.Assert(len(resultArr), 2)
+		t.Assert(resultArr[0].String(), "550e8400-e29b-41d4-a716-446655440000")
+		t.Assert(resultArr[1].String(), "6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test _uuid array conversion error case
+		_, err := driver.ConvertValueForLocal(ctx, "_uuid", []byte(`{invalid-uuid}`))
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test error case with invalid data for _int2
+		_, err := driver.ConvertValueForLocal(ctx, "_int2", "invalid")
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test error case with invalid data for _int4
+		_, err := driver.ConvertValueForLocal(ctx, "_int4", "invalid")
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test error case with invalid data for _int8
+		_, err := driver.ConvertValueForLocal(ctx, "_int8", "invalid")
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test error case with invalid data for _float4
+		_, err := driver.ConvertValueForLocal(ctx, "_float4", "invalid")
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test error case with invalid data for _float8
+		_, err := driver.ConvertValueForLocal(ctx, "_float8", "invalid")
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test error case with invalid data for _bool
+		_, err := driver.ConvertValueForLocal(ctx, "_bool", "invalid")
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test error case with invalid data for _varchar
+		_, err := driver.ConvertValueForLocal(ctx, "_varchar", 12345)
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test error case with invalid data for _numeric
+		_, err := driver.ConvertValueForLocal(ctx, "_numeric", "invalid")
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test error case with invalid data for _bytea
+		_, err := driver.ConvertValueForLocal(ctx, "_bytea", "invalid")
+		t.AssertNE(err, nil)
+	})
+}
+
+// Test_ConvertValueForField tests the ConvertValueForField method
+func Test_ConvertValueForField(t *testing.T) {
+	var (
+		ctx    = context.Background()
+		driver = pgsql.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test nil value
+		result, err := driver.ConvertValueForField(ctx, "varchar", nil)
+		t.AssertNil(err)
+		t.Assert(result, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test slice value for non-json type (should convert [] to {})
+		result, err := driver.ConvertValueForField(ctx, "int4[]", []int{1, 2, 3})
+		t.AssertNil(err)
+		t.Assert(result, "{1,2,3}")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test slice value for non-json type with strings
+		// Note: gconv.String for []string{"a","b","c"} produces ["a","b","c"] which then gets converted to {"a","b","c"}
+		result, err := driver.ConvertValueForField(ctx, "varchar[]", []string{"a", "b", "c"})
+		t.AssertNil(err)
+		t.Assert(result, `{"a","b","c"}`)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test slice value for json type (should keep [] as is)
+		result, err := driver.ConvertValueForField(ctx, "json", []int{1, 2, 3})
+		t.AssertNil(err)
+		t.Assert(result, "[1,2,3]")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test slice value for jsonb type (should keep [] as is)
+		result, err := driver.ConvertValueForField(ctx, "jsonb", []string{"a", "b"})
+		t.AssertNil(err)
+		t.Assert(result, `["a","b"]`)
+	})
+}
diff --git a/contrib/drivers/pgsql/pgsql_z_unit_db_test.go b/contrib/drivers/pgsql/pgsql_z_unit_db_test.go
index 3dd264c9c..a83cb38bf 100644
--- a/contrib/drivers/pgsql/pgsql_z_unit_db_test.go
+++ b/contrib/drivers/pgsql/pgsql_z_unit_db_test.go
@@ -90,7 +90,7 @@ func Test_DB_Save(t *testing.T) {
 			"create_time": gtime.Now().String(),
 		}
 		_, err := db.Save(ctx, "t_user", data, 10)
-		gtest.AssertNE(err, nil)
+		gtest.AssertNil(err)
 	})
 }
 
@@ -99,6 +99,7 @@ func Test_DB_Replace(t *testing.T) {
 		createTable("t_user")
 		defer dropTable("t_user")
 
+		// Insert initial record
 		i := 10
 		data := g.Map{
 			"id":          i,
@@ -107,8 +108,26 @@ func Test_DB_Replace(t *testing.T) {
 			"nickname":    fmt.Sprintf(`T%d`, i),
 			"create_time": gtime.Now().String(),
 		}
-		_, err := db.Replace(ctx, "t_user", data, 10)
-		gtest.AssertNE(err, nil)
+		_, err := db.Insert(ctx, "t_user", data)
+		gtest.AssertNil(err)
+
+		// Replace with new data
+		data2 := g.Map{
+			"id":          i,
+			"passport":    fmt.Sprintf(`t%d_new`, i),
+			"password":    fmt.Sprintf(`p%d_new`, i),
+			"nickname":    fmt.Sprintf(`T%d_new`, i),
+			"create_time": gtime.Now().String(),
+		}
+		_, err = db.Replace(ctx, "t_user", data2)
+		gtest.AssertNil(err)
+
+		// Verify the data was replaced
+		one, err := db.GetOne(ctx, fmt.Sprintf("SELECT * FROM t_user WHERE id=?"), i)
+		gtest.AssertNil(err)
+		gtest.Assert(one["passport"].String(), fmt.Sprintf(`t%d_new`, i))
+		gtest.Assert(one["password"].String(), fmt.Sprintf(`p%d_new`, i))
+		gtest.Assert(one["nickname"].String(), fmt.Sprintf(`T%d_new`, i))
 	})
 }
 
@@ -302,12 +321,12 @@ func Test_DB_TableFields(t *testing.T) {
 		defer dropTable(table)
 
 		var expect = map[string][]any{
-			//[]string: Index Type Null Key Default Comment
-			//id is bigserial so the default is a pgsql function
-			"id":          {0, "int8", false, "pri", fmt.Sprintf("nextval('%s_id_seq'::regclass)", table), ""},
-			"passport":    {1, "varchar", false, "", nil, ""},
-			"password":    {2, "varchar", false, "", nil, ""},
-			"nickname":    {3, "varchar", false, "", nil, ""},
+			// []string: Index Type Null Key Default Comment
+			// id is bigserial so the default is a pgsql function
+			"id":          {0, "int8(64)", false, "pri", fmt.Sprintf("nextval('%s_id_seq'::regclass)", table), ""},
+			"passport":    {1, "varchar(45)", false, "", nil, ""},
+			"password":    {2, "varchar(32)", false, "", nil, ""},
+			"nickname":    {3, "varchar(45)", false, "", nil, ""},
 			"create_time": {4, "timestamp", false, "", nil, ""},
 		}
 
@@ -339,8 +358,8 @@ int_col INT);`
 		IntCol int64
 	}
 	// pgsql converts table names to lowercase
+	// mark: [c.oid = '%s'::regclass] is not case-sensitive
 	tableName := "Error_table"
-	errStr := fmt.Sprintf(`The table "%s" may not exist, or the table contains no fields`, tableName)
 	_, err := db.Exec(ctx, fmt.Sprintf(createSql, tableName))
 	gtest.AssertNil(err)
 	defer dropTable(tableName)
@@ -351,7 +370,7 @@ int_col INT);`
 			IntCol: 2,
 		}
 		_, err = db.Model(tableName).Data(data).Insert()
-		t.Assert(err, errStr)
+		t.AssertNE(err, nil)
 
 		// Insert a piece of test data using lowercase
 		_, err = db.Model(strings.ToLower(tableName)).Data(data).Insert()
@@ -360,7 +379,7 @@ int_col INT);`
 		_, err = db.Model(tableName).Where("id", 1).Data(g.Map{
 			"int_col": 9999,
 		}).Update()
-		t.Assert(err, errStr)
+		t.AssertNE(err, nil)
 
 	})
 	// The inserted field does not exist in the table
@@ -370,7 +389,7 @@ int_col INT);`
 			"int_col_22": 11111,
 		}
 		_, err = db.Model(tableName).Data(data).Insert()
-		t.Assert(err, errStr)
+		t.Assert(err, fmt.Errorf(`input data match no fields in table "%s"`, tableName))
 
 		lowerTableName := strings.ToLower(tableName)
 		_, err = db.Model(lowerTableName).Data(data).Insert()
@@ -384,6 +403,91 @@ int_col INT);`
 
 }
 
+func Test_DB_TableFields_DuplicateConstraints(t *testing.T) {
+	// Test for the fix of duplicate field results with multiple constraints
+	// This test verifies that when a field has multiple constraints (e.g., both primary key and unique),
+	// the TableFields method correctly merges the results with proper priority (pri > uni > others)
+	gtest.C(t, func(t *gtest.T) {
+		tableName := "test_multi_constraint"
+		createSql := fmt.Sprintf(`
+			CREATE TABLE %s (
+				id bigserial NOT NULL PRIMARY KEY,
+				email varchar(100) NOT NULL UNIQUE,
+				username varchar(50) NOT NULL,
+				status int NOT NULL DEFAULT 1
+			)`, tableName)
+
+		_, err := db.Exec(ctx, createSql)
+		t.AssertNil(err)
+		defer dropTable(tableName)
+
+		// Get table fields
+		fields, err := db.TableFields(ctx, tableName)
+		t.AssertNil(err)
+
+		// Verify id field has primary key constraint
+		t.AssertNE(fields["id"], nil)
+		t.Assert(fields["id"].Key, "pri")
+		t.Assert(fields["id"].Name, "id")
+		t.Assert(fields["id"].Type, "int8(64)")
+
+		// Verify email field has unique constraint
+		t.AssertNE(fields["email"], nil)
+		t.Assert(fields["email"].Key, "uni")
+		t.Assert(fields["email"].Name, "email")
+		t.Assert(fields["email"].Type, "varchar(100)")
+
+		// Verify username field has no constraint
+		t.AssertNE(fields["username"], nil)
+		t.Assert(fields["username"].Key, "")
+		t.Assert(fields["username"].Name, "username")
+
+		// Verify status field has no constraint and has default value
+		t.AssertNE(fields["status"], nil)
+		t.Assert(fields["status"].Key, "")
+		t.Assert(fields["status"].Name, "status")
+		t.Assert(fields["status"].Default, 1)
+
+		// Verify field count is correct (no duplicates)
+		t.Assert(len(fields), 4)
+	})
+
+	// Test table with composite constraints
+	gtest.C(t, func(t *gtest.T) {
+		tableName := "test_composite_constraint"
+		createSql := fmt.Sprintf(`
+			CREATE TABLE %s (
+				user_id bigint NOT NULL,
+				project_id bigint NOT NULL,
+				role varchar(50) NOT NULL,
+				PRIMARY KEY (user_id, project_id)
+			)`, tableName)
+
+		_, err := db.Exec(ctx, createSql)
+		t.AssertNil(err)
+		defer dropTable(tableName)
+
+		// Get table fields
+		fields, err := db.TableFields(ctx, tableName)
+		t.AssertNil(err)
+
+		// In PostgreSQL, composite primary keys may appear in query results
+		// The first field in the composite key should be marked as 'pri'
+		t.AssertNE(fields["user_id"], nil)
+		t.Assert(fields["user_id"].Name, "user_id")
+
+		t.AssertNE(fields["project_id"], nil)
+		t.Assert(fields["project_id"].Name, "project_id")
+
+		t.AssertNE(fields["role"], nil)
+		t.Assert(fields["role"].Name, "role")
+		t.Assert(fields["role"].Key, "")
+
+		// Verify field count is correct (no duplicates)
+		t.Assert(len(fields), 3)
+	})
+}
+
 func Test_DB_InsertIgnore(t *testing.T) {
 	table := createTable()
 	defer dropTable(table)
diff --git a/contrib/drivers/pgsql/pgsql_z_unit_field_test.go b/contrib/drivers/pgsql/pgsql_z_unit_field_test.go
new file mode 100644
index 000000000..22a8f25a2
--- /dev/null
+++ b/contrib/drivers/pgsql/pgsql_z_unit_field_test.go
@@ -0,0 +1,954 @@
+// 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 pgsql_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/google/uuid"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+// Test_TableFields tests the TableFields method for retrieving table field information
+func Test_TableFields(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		fields, err := db.TableFields(ctx, table)
+		t.AssertNil(err)
+		t.Assert(len(fields) > 0, true)
+
+		// Test primary key field
+		t.Assert(fields["id"].Name, "id")
+		t.Assert(fields["id"].Key, "pri")
+
+		// Test integer types
+		t.Assert(fields["col_int2"].Name, "col_int2")
+		t.Assert(fields["col_int4"].Name, "col_int4")
+		t.Assert(fields["col_int8"].Name, "col_int8")
+
+		// Test float types
+		t.Assert(fields["col_float4"].Name, "col_float4")
+		t.Assert(fields["col_float8"].Name, "col_float8")
+		t.Assert(fields["col_numeric"].Name, "col_numeric")
+
+		// Test character types
+		t.Assert(fields["col_char"].Name, "col_char")
+		t.Assert(fields["col_varchar"].Name, "col_varchar")
+		t.Assert(fields["col_text"].Name, "col_text")
+
+		// Test boolean type
+		t.Assert(fields["col_bool"].Name, "col_bool")
+
+		// Test date/time types
+		t.Assert(fields["col_date"].Name, "col_date")
+		t.Assert(fields["col_timestamp"].Name, "col_timestamp")
+
+		// Test JSON types
+		t.Assert(fields["col_json"].Name, "col_json")
+		t.Assert(fields["col_jsonb"].Name, "col_jsonb")
+
+		// Test array types
+		t.Assert(fields["col_int2_arr"].Name, "col_int2_arr")
+		t.Assert(fields["col_int4_arr"].Name, "col_int4_arr")
+		t.Assert(fields["col_varchar_arr"].Name, "col_varchar_arr")
+	})
+}
+
+// Test_TableFields_Types tests field type information
+func Test_TableFields_Types(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		fields, err := db.TableFields(ctx, table)
+		t.AssertNil(err)
+
+		// Test integer type names
+		t.Assert(fields["col_int2"].Type, "int2(16)")
+		t.Assert(fields["col_int4"].Type, "int4(32)")
+		t.Assert(fields["col_int8"].Type, "int8(64)")
+
+		// Test float type names
+		t.Assert(fields["col_float4"].Type, "float4(24)")
+		t.Assert(fields["col_float8"].Type, "float8(53)")
+		t.Assert(fields["col_numeric"].Type, "numeric(10)")
+
+		// Test character type names
+		t.Assert(fields["col_char"].Type, "bpchar(10)")
+		t.Assert(fields["col_varchar"].Type, "varchar(100)")
+		t.Assert(fields["col_text"].Type, "text")
+
+		// Test boolean type name
+		t.Assert(fields["col_bool"].Type, "bool")
+
+		// Test date/time type names
+		t.Assert(fields["col_date"].Type, "date")
+		t.Assert(fields["col_timestamp"].Type, "timestamp")
+		t.Assert(fields["col_timestamptz"].Type, "timestamptz")
+
+		// Test JSON type names
+		t.Assert(fields["col_json"].Type, "json")
+		t.Assert(fields["col_jsonb"].Type, "jsonb")
+
+		// Test array type names (PostgreSQL uses _ prefix for array types)
+		t.Assert(fields["col_int2_arr"].Type, "_int2")
+		t.Assert(fields["col_int4_arr"].Type, "_int4")
+		t.Assert(fields["col_int8_arr"].Type, "_int8")
+		t.Assert(fields["col_float4_arr"].Type, "_float4")
+		t.Assert(fields["col_float8_arr"].Type, "_float8")
+		t.Assert(fields["col_numeric_arr"].Type, "_numeric")
+		t.Assert(fields["col_varchar_arr"].Type, "_varchar")
+		t.Assert(fields["col_text_arr"].Type, "_text")
+		t.Assert(fields["col_bool_arr"].Type, "_bool")
+	})
+}
+
+// Test_TableFields_Nullable tests field nullable information
+func Test_TableFields_Nullable(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		fields, err := db.TableFields(ctx, table)
+		t.AssertNil(err)
+
+		// NOT NULL fields should have Null = false
+		t.Assert(fields["col_int2"].Null, false)
+		t.Assert(fields["col_int4"].Null, false)
+		t.Assert(fields["col_numeric"].Null, false)
+		t.Assert(fields["col_varchar"].Null, false)
+		t.Assert(fields["col_bool"].Null, false)
+		t.Assert(fields["col_varchar_arr"].Null, false)
+
+		// Nullable fields should have Null = true
+		t.Assert(fields["col_int8"].Null, true)
+		t.Assert(fields["col_text"].Null, true)
+		t.Assert(fields["col_json"].Null, true)
+	})
+}
+
+// Test_TableFields_Comments tests field comment information
+func Test_TableFields_Comments(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		fields, err := db.TableFields(ctx, table)
+		t.AssertNil(err)
+
+		// Test fields with comments
+		t.Assert(fields["id"].Comment, "Primary key ID")
+		t.Assert(fields["col_int2"].Comment, "int2 type (smallint)")
+		t.Assert(fields["col_int4"].Comment, "int4 type (integer)")
+		t.Assert(fields["col_int8"].Comment, "int8 type (bigint)")
+		t.Assert(fields["col_numeric"].Comment, "numeric type with precision")
+		t.Assert(fields["col_varchar"].Comment, "varchar type")
+		t.Assert(fields["col_bool"].Comment, "boolean type")
+		t.Assert(fields["col_timestamp"].Comment, "timestamp type")
+		t.Assert(fields["col_json"].Comment, "json type")
+		t.Assert(fields["col_jsonb"].Comment, "jsonb type")
+
+		// Test array field comments
+		t.Assert(fields["col_int2_arr"].Comment, "int2 array type (_int2)")
+		t.Assert(fields["col_int4_arr"].Comment, "int4 array type (_int4)")
+		t.Assert(fields["col_int8_arr"].Comment, "int8 array type (_int8)")
+		t.Assert(fields["col_numeric_arr"].Comment, "numeric array type (_numeric)")
+		t.Assert(fields["col_varchar_arr"].Comment, "varchar array type (_varchar)")
+		t.Assert(fields["col_text_arr"].Comment, "text array type (_text)")
+	})
+}
+
+// Test_Field_Type_Conversion tests type conversion for various PostgreSQL types
+func Test_Field_Type_Conversion(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query a single record
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+
+		// Test integer type conversions
+		t.Assert(one["col_int2"].Int(), 1)
+		t.Assert(one["col_int4"].Int(), 10)
+		t.Assert(one["col_int8"].Int64(), int64(100))
+
+		// Test float type conversions
+		t.Assert(one["col_float4"].Float32() > 0, true)
+		t.Assert(one["col_float8"].Float64() > 0, true)
+
+		// Test string type conversions
+		t.AssertNE(one["col_varchar"].String(), "")
+		t.AssertNE(one["col_text"].String(), "")
+
+		// Test boolean type conversion
+		t.Assert(one["col_bool"].Bool(), false) // i=1, 1%2==0 is false
+	})
+}
+
+// Test_Field_Array_Type_Conversion tests array type conversion
+func Test_Field_Array_Type_Conversion(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query a single record
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+
+		// Test integer array type conversions
+		int2Arr := one["col_int2_arr"].Ints()
+		t.Assert(len(int2Arr), 3)
+		t.Assert(int2Arr[0], 1)
+		t.Assert(int2Arr[1], 2)
+		t.Assert(int2Arr[2], 1)
+
+		int4Arr := one["col_int4_arr"].Ints()
+		t.Assert(len(int4Arr), 3)
+		t.Assert(int4Arr[0], 10)
+		t.Assert(int4Arr[1], 20)
+		t.Assert(int4Arr[2], 1)
+
+		int8Arr := one["col_int8_arr"].Int64s()
+		t.Assert(len(int8Arr), 3)
+		t.Assert(int8Arr[0], int64(100))
+		t.Assert(int8Arr[1], int64(200))
+		t.Assert(int8Arr[2], int64(1))
+
+		// Test string array type conversions
+		varcharArr := one["col_varchar_arr"].Strings()
+		t.Assert(len(varcharArr), 3)
+		t.Assert(varcharArr[0], "a")
+		t.Assert(varcharArr[1], "b")
+		t.Assert(varcharArr[2], "c1")
+
+		textArr := one["col_text_arr"].Strings()
+		t.Assert(len(textArr), 3)
+		t.Assert(textArr[0], "x")
+		t.Assert(textArr[1], "y")
+		t.Assert(textArr[2], "z1")
+
+		// Test boolean array type conversions
+		// col_bool_arr is '{true, false, %t}' where %t = i%2==0, for i=1 it's false
+		boolArr := one["col_bool_arr"].Bools()
+		t.Assert(len(boolArr), 3)
+		t.Assert(boolArr[0], true)  // literal true
+		t.Assert(boolArr[1], false) // literal false
+		t.Assert(boolArr[2], false) // i=1, 1%2==0 is false
+	})
+}
+
+// Test_Field_Array_Insert tests inserting array data
+func Test_Field_Array_Insert(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with array values
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_int2_arr":    []int{1, 2, 3},
+			"col_int4_arr":    []int{10, 20, 30},
+			"col_varchar_arr": []string{"a", "b", "c"},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		t.Assert(one["col_int2"].Int(), 1)
+		t.Assert(one["col_varchar"].String(), "test")
+		t.Assert(one["col_bool"].Bool(), true)
+
+		int2Arr := one["col_int2_arr"].Ints()
+		t.Assert(len(int2Arr), 3)
+		t.Assert(int2Arr[0], 1)
+		t.Assert(int2Arr[1], 2)
+		t.Assert(int2Arr[2], 3)
+
+		varcharArr := one["col_varchar_arr"].Strings()
+		t.Assert(len(varcharArr), 3)
+		t.Assert(varcharArr[0], "a")
+		t.Assert(varcharArr[1], "b")
+		t.Assert(varcharArr[2], "c")
+	})
+}
+
+// Test_Field_Array_Update tests updating array data
+func Test_Field_Array_Update(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Update array values
+		_, err := db.Model(table).Where("id", 1).Data(g.Map{
+			"col_int2_arr":    []int{100, 200, 300},
+			"col_varchar_arr": []string{"x", "y", "z"},
+		}).Update()
+		t.AssertNil(err)
+
+		// Query and verify
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+
+		int2Arr := one["col_int2_arr"].Ints()
+		t.Assert(len(int2Arr), 3)
+		t.Assert(int2Arr[0], 100)
+		t.Assert(int2Arr[1], 200)
+		t.Assert(int2Arr[2], 300)
+
+		varcharArr := one["col_varchar_arr"].Strings()
+		t.Assert(len(varcharArr), 3)
+		t.Assert(varcharArr[0], "x")
+		t.Assert(varcharArr[1], "y")
+		t.Assert(varcharArr[2], "z")
+	})
+}
+
+// Test_Field_JSON_Type tests JSON/JSONB type handling
+func Test_Field_JSON_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with JSON values
+		testData := g.Map{
+			"name":  "test",
+			"value": 123,
+			"items": []string{"a", "b", "c"},
+		}
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":    1,
+			"col_int4":    10,
+			"col_numeric": 99.99,
+			"col_varchar": "test",
+			"col_bool":    true,
+			"col_json":    testData,
+			"col_jsonb":   testData,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Test JSON field
+		jsonMap := one["col_json"].Map()
+		t.Assert(jsonMap["name"], "test")
+		t.Assert(jsonMap["value"], 123)
+
+		// Test JSONB field
+		jsonbMap := one["col_jsonb"].Map()
+		t.Assert(jsonbMap["name"], "test")
+		t.Assert(jsonbMap["value"], 123)
+	})
+}
+
+// Test_Field_Scan_To_Struct tests scanning results to struct
+func Test_Field_Scan_To_Struct(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	type TestRecord struct {
+		Id         int64    `json:"id"`
+		ColInt2    int16    `json:"col_int2"`
+		ColInt4    int32    `json:"col_int4"`
+		ColInt8    int64    `json:"col_int8"`
+		ColVarchar string   `json:"col_varchar"`
+		ColBool    bool     `json:"col_bool"`
+		ColInt2Arr []int    `json:"col_int2_arr"`
+		ColInt4Arr []int    `json:"col_int4_arr"`
+		ColInt8Arr []int64  `json:"col_int8_arr"`
+		ColTextArr []string `json:"col_text_arr"`
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		var record TestRecord
+		err := db.Model(table).Where("id", 1).Scan(&record)
+		t.AssertNil(err)
+
+		t.Assert(record.Id, int64(1))
+		t.Assert(record.ColInt2, int16(1))
+		t.Assert(record.ColInt4, int32(10))
+		t.Assert(record.ColInt8, int64(100))
+		t.AssertNE(record.ColVarchar, "")
+		t.Assert(record.ColBool, false)
+
+		// Test array fields scanned to struct
+		t.Assert(len(record.ColInt2Arr), 3)
+		t.Assert(record.ColInt2Arr[0], 1)
+		t.Assert(record.ColInt2Arr[1], 2)
+		t.Assert(record.ColInt2Arr[2], 1)
+
+		t.Assert(len(record.ColTextArr), 3)
+		t.Assert(record.ColTextArr[0], "x")
+		t.Assert(record.ColTextArr[1], "y")
+		t.Assert(record.ColTextArr[2], "z1")
+	})
+}
+
+// Test_Field_Scan_To_Struct_Slice tests scanning multiple results to struct slice
+func Test_Field_Scan_To_Struct_Slice(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	type TestRecord struct {
+		Id         int64    `json:"id"`
+		ColInt2    int16    `json:"col_int2"`
+		ColVarchar string   `json:"col_varchar"`
+		ColInt2Arr []int    `json:"col_int2_arr"`
+		ColTextArr []string `json:"col_text_arr"`
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		var records []TestRecord
+		err := db.Model(table).OrderAsc("id").Limit(5).Scan(&records)
+		t.AssertNil(err)
+
+		t.Assert(len(records), 5)
+
+		// Verify first record
+		t.Assert(records[0].Id, int64(1))
+		t.Assert(records[0].ColInt2, int16(1))
+		t.Assert(len(records[0].ColInt2Arr), 3)
+
+		// Verify last record
+		t.Assert(records[4].Id, int64(5))
+		t.Assert(records[4].ColInt2, int16(5))
+	})
+}
+
+// Test_Field_Empty_Array tests handling empty arrays
+func Test_Field_Empty_Array(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with empty array values (using default)
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":    1,
+			"col_int4":    10,
+			"col_numeric": 99.99,
+			"col_varchar": "test",
+			"col_bool":    true,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify empty arrays
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Default empty arrays
+		int2Arr := one["col_int2_arr"].Ints()
+		t.Assert(len(int2Arr), 0)
+
+		varcharArr := one["col_varchar_arr"].Strings()
+		t.Assert(len(varcharArr), 0)
+	})
+}
+
+// Test_Field_Null_Values tests handling NULL values
+func Test_Field_Null_Values(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert minimal required fields, leaving nullable fields as NULL
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_varchar_arr": []string{},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify NULL handling
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Nullable fields should return appropriate zero values
+		t.Assert(one["col_text"].IsNil() || one["col_text"].IsEmpty(), true)
+		t.Assert(one["col_int8_arr"].IsNil() || one["col_int8_arr"].IsEmpty(), true)
+	})
+}
+
+// Test_Field_Float_Array_Type_Conversion tests float array type conversion (_float4, _float8)
+func Test_Field_Float_Array_Type_Conversion(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query a single record
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+
+		// Test float4 array type conversions
+		float4Arr := one["col_float4_arr"].Float32s()
+		t.Assert(len(float4Arr), 3)
+		t.Assert(float4Arr[0] > 0, true)
+		t.Assert(float4Arr[1] > 0, true)
+
+		// Test float8 array type conversions
+		float8Arr := one["col_float8_arr"].Float64s()
+		t.Assert(len(float8Arr), 3)
+		t.Assert(float8Arr[0] > 0, true)
+		t.Assert(float8Arr[1] > 0, true)
+	})
+}
+
+// Test_Field_Numeric_Array_Type_Conversion tests numeric/decimal array type conversion
+func Test_Field_Numeric_Array_Type_Conversion(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query a single record
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+
+		// Test numeric array type conversions
+		numericArr := one["col_numeric_arr"].Float64s()
+		t.Assert(len(numericArr), 3)
+		t.Assert(numericArr[0] > 0, true)
+		t.Assert(numericArr[1] > 0, true)
+
+		// Test decimal array type conversions
+		decimalArr := one["col_decimal_arr"].Float64s()
+		if !one["col_decimal_arr"].IsNil() {
+			t.Assert(len(decimalArr) > 0, true)
+		}
+	})
+}
+
+// Test_Field_Bool_Array_Type_Conversion tests bool array type conversion more thoroughly
+func Test_Field_Bool_Array_Type_Conversion(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with specific bool array values
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":     1,
+			"col_int4":     10,
+			"col_numeric":  99.99,
+			"col_varchar":  "test",
+			"col_bool":     true,
+			"col_bool_arr": []bool{true, false, true},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Test bool array
+		boolArr := one["col_bool_arr"].Bools()
+		t.Assert(len(boolArr), 3)
+		t.Assert(boolArr[0], true)
+		t.Assert(boolArr[1], false)
+		t.Assert(boolArr[2], true)
+	})
+}
+
+// Test_Field_Char_Array_Type tests char array type (_char)
+func Test_Field_Char_Array_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with char array values
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_char_arr":    []string{"a", "b", "c"},
+			"col_varchar_arr": []string{},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Test char array
+		charArr := one["col_char_arr"].Strings()
+		t.Assert(len(charArr), 3)
+	})
+}
+
+// Test_Field_Bytea_Type tests bytea (binary) type conversion
+func Test_Field_Bytea_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with binary data
+		binaryData := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f} // "Hello" in hex
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_bytea":       binaryData,
+			"col_varchar_arr": []string{},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Test bytea field
+		result := one["col_bytea"].Bytes()
+		t.Assert(len(result), 5)
+		t.Assert(result[0], 0x48) // 'H'
+	})
+}
+
+// Test_Field_Bytea_Array_Type tests bytea array type (_bytea)
+func Test_Field_Bytea_Array_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with bytea array values using raw SQL
+		// PostgreSQL bytea array literal format: ARRAY[E'\\x010203', E'\\x040506']::bytea[]
+		_, err := db.Exec(ctx, fmt.Sprintf(`
+			INSERT INTO %s (col_int2, col_int4, col_numeric, col_varchar, col_bool, col_varchar_arr, col_bytea_arr)
+			VALUES (1, 10, 99.99, 'test', true, '{}', ARRAY[E'\\x010203', E'\\x040506']::bytea[])
+		`, table))
+		t.AssertNil(err)
+
+		// Query and verify bytea array
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Test bytea array field - should be converted to [][]byte
+		byteaArrVal := one["col_bytea_arr"]
+		t.Assert(byteaArrVal.IsNil(), false)
+
+		// Verify the array contains the expected data
+		byteaArr := byteaArrVal.Interfaces()
+		t.Assert(len(byteaArr), 2)
+	})
+}
+
+// Test_Field_Date_Array_Type tests date array type (_date)
+func Test_Field_Date_Array_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Note: PostgreSQL _date array is not yet mapped in the driver
+		// This test documents the limitation but can be extended when support is added
+
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_varchar_arr": []string{},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify NULL date array is handled gracefully
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+		// date array should be nil or empty
+		t.Assert(one["col_date_arr"].IsNil() || one["col_date_arr"].IsEmpty(), true)
+	})
+}
+
+// Test_Field_Timestamp_Array_Type tests timestamp array type (_timestamp)
+func Test_Field_Timestamp_Array_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Note: PostgreSQL _timestamp array is not yet mapped in the driver
+		// This test documents the limitation but can be extended when support is added
+
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_varchar_arr": []string{},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify NULL timestamp array is handled gracefully
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+		// timestamp array should be nil or empty
+		t.Assert(one["col_timestamp_arr"].IsNil() || one["col_timestamp_arr"].IsEmpty(), true)
+	})
+}
+
+// Test_Field_JSONB_Array_Type tests JSONB array type (_jsonb)
+func Test_Field_JSONB_Array_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Note: PostgreSQL _jsonb array is not yet mapped in the driver
+		// This test documents the limitation but can be extended when support is added
+
+		_, err := db.Model(table).Data(g.Map{
+			"col_int2":        1,
+			"col_int4":        10,
+			"col_numeric":     99.99,
+			"col_varchar":     "test",
+			"col_bool":        true,
+			"col_varchar_arr": []string{},
+		}).Insert()
+		t.AssertNil(err)
+
+		// Query and verify NULL jsonb array is handled gracefully
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+		// jsonb array should be nil or empty
+		t.Assert(one["col_jsonb_arr"].IsNil() || one["col_jsonb_arr"].IsEmpty(), true)
+	})
+}
+
+// Test_Field_UUID_Array_Type tests UUID array type (_uuid)
+func Test_Field_UUID_Array_Type(t *testing.T) {
+	table := createAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with UUID array values using raw SQL
+		// PostgreSQL uuid array literal format: ARRAY['uuid1', 'uuid2']::uuid[]
+		uuid1 := "550e8400-e29b-41d4-a716-446655440000"
+		uuid2 := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+		uuid3 := "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
+		_, err := db.Exec(ctx, fmt.Sprintf(`
+			INSERT INTO %s (col_int2, col_int4, col_numeric, col_varchar, col_bool, col_varchar_arr, col_uuid_arr)
+			VALUES (1, 10, 99.99, 'test', true, '{}', ARRAY['%s', '%s', '%s']::uuid[])
+		`, table, uuid1, uuid2, uuid3))
+		t.AssertNil(err)
+
+		// Query and verify UUID array
+		one, err := db.Model(table).OrderDesc("id").One()
+		t.AssertNil(err)
+
+		// Test UUID array field - should be converted to []uuid.UUID
+		uuidArrVal := one["col_uuid_arr"]
+		t.Assert(uuidArrVal.IsNil(), false)
+
+		// Verify the array contains the expected data as []uuid.UUID
+		uuidArr := uuidArrVal.Interfaces()
+		t.Assert(len(uuidArr), 3)
+
+		// Verify each element is uuid.UUID type
+		u1, ok := uuidArr[0].(uuid.UUID)
+		t.Assert(ok, true)
+		t.Assert(u1.String(), uuid1)
+
+		u2, ok := uuidArr[1].(uuid.UUID)
+		t.Assert(ok, true)
+		t.Assert(u2.String(), uuid2)
+
+		u3, ok := uuidArr[2].(uuid.UUID)
+		t.Assert(ok, true)
+		t.Assert(u3.String(), uuid3)
+	})
+}
+
+// Test_Field_UUID_Type tests UUID type
+func Test_Field_UUID_Type(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query and verify UUID field
+		one, err := db.Model(table).OrderAsc("id").One()
+		t.AssertNil(err)
+
+		// Test UUID field - should be converted to uuid.UUID
+		uuidVal := one["col_uuid"]
+		t.Assert(uuidVal.IsNil(), false)
+
+		// Verify the value is uuid.UUID type
+		uuidObj, ok := uuidVal.Val().(uuid.UUID)
+		t.Assert(ok, true)
+
+		// Verify the UUID format
+		uuidStr := uuidObj.String()
+		t.Assert(len(uuidStr) > 0, true)
+		// UUID should contain the pattern from insert: 550e8400-e29b-41d4-a716-44665544000X
+		t.Assert(uuidStr, "550e8400-e29b-41d4-a716-446655440001")
+
+		// Also verify we can still get string representation via .String()
+		t.Assert(uuidVal.String(), "550e8400-e29b-41d4-a716-446655440001")
+	})
+}
+
+// Test_Field_Bytea_Array_Type_Scan tests bytea array type and scanning
+func Test_Field_Bytea_Array_Type_Scan(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query and verify bytea array field
+		one, err := db.Model(table).OrderAsc("id").One()
+		t.AssertNil(err)
+
+		// Test bytea array field
+		byteaArrVal := one["col_bytea_arr"]
+		// bytea array should not be nil since we inserted data
+		t.Assert(byteaArrVal.IsNil(), false)
+	})
+}
+
+// Test_Field_Date_Array_Type_Scan tests date array type and scanning
+func Test_Field_Date_Array_Type_Scan(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query and verify date array field
+		one, err := db.Model(table).OrderAsc("id").One()
+		t.AssertNil(err)
+
+		// Test date array field
+		dateArrVal := one["col_date_arr"]
+		t.Assert(dateArrVal.IsNil(), false)
+
+		// Verify the array contains the expected data
+		dateArr := dateArrVal.Strings()
+		t.Assert(len(dateArr) > 0, true)
+	})
+}
+
+// Test_Field_Timestamp_Array_Type_Scan tests timestamp array type and scanning
+func Test_Field_Timestamp_Array_Type_Scan(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query and verify timestamp array field
+		one, err := db.Model(table).OrderAsc("id").One()
+		t.AssertNil(err)
+
+		// Test timestamp array field
+		timestampArrVal := one["col_timestamp_arr"]
+		t.Assert(timestampArrVal.IsNil(), false)
+
+		// Verify the array contains the expected data
+		timestampArr := timestampArrVal.Strings()
+		t.Assert(len(timestampArr) > 0, true)
+	})
+}
+
+// Test_Field_JSONB_Array_Type_Scan tests JSONB array type and scanning
+func Test_Field_JSONB_Array_Type_Scan(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Query and verify JSONB array field
+		one, err := db.Model(table).OrderAsc("id").One()
+		t.AssertNil(err)
+
+		// Test JSONB array field
+		jsonbArrVal := one["col_jsonb_arr"]
+		t.Assert(jsonbArrVal.IsNil(), false)
+	})
+}
+
+// Test_Field_UUID_Query tests querying by UUID field
+func Test_Field_UUID_Query(t *testing.T) {
+	table := createInitAllTypesTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test 1: Query by UUID string
+		uuidStr := "550e8400-e29b-41d4-a716-446655440001"
+		one, err := db.Model(table).Where("col_uuid", uuidStr).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+		t.Assert(one["id"].Int(), 1)
+
+		// Verify the returned UUID is correct
+		uuidObj, ok := one["col_uuid"].Val().(uuid.UUID)
+		t.Assert(ok, true)
+		t.Assert(uuidObj.String(), uuidStr)
+
+		// Test 2: Query by uuid.UUID type directly
+		uuidVal, err := uuid.Parse("550e8400-e29b-41d4-a716-446655440002")
+		t.AssertNil(err)
+		one, err = db.Model(table).Where("col_uuid", uuidVal).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+		t.Assert(one["id"].Int(), 2)
+
+		// Test 3: Query by UUID string using g.Map
+		one, err = db.Model(table).Where(g.Map{
+			"col_uuid": "550e8400-e29b-41d4-a716-446655440003",
+		}).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+		t.Assert(one["id"].Int(), 3)
+
+		// Test 4: Query by uuid.UUID type using g.Map
+		uuidVal, err = uuid.Parse("550e8400-e29b-41d4-a716-446655440004")
+		t.AssertNil(err)
+		one, err = db.Model(table).Where(g.Map{
+			"col_uuid": uuidVal,
+		}).One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), false)
+		t.Assert(one["id"].Int(), 4)
+
+		// Test 5: Query non-existent UUID
+		one, err = db.Model(table).Where("col_uuid", "00000000-0000-0000-0000-000000000000").One()
+		t.AssertNil(err)
+		t.Assert(one.IsEmpty(), true)
+
+		// Test 6: Query multiple records by UUID IN clause with strings
+		all, err := db.Model(table).WhereIn("col_uuid", g.Slice{
+			"550e8400-e29b-41d4-a716-446655440001",
+			"550e8400-e29b-41d4-a716-446655440002",
+		}).OrderAsc("id").All()
+		t.AssertNil(err)
+		t.Assert(len(all), 2)
+		t.Assert(all[0]["id"].Int(), 1)
+		t.Assert(all[1]["id"].Int(), 2)
+
+		// Test 7: Query multiple records by UUID IN clause with uuid.UUID types
+		uuid1, _ := uuid.Parse("550e8400-e29b-41d4-a716-446655440003")
+		uuid2, _ := uuid.Parse("550e8400-e29b-41d4-a716-446655440004")
+		all, err = db.Model(table).WhereIn("col_uuid", g.Slice{uuid1, uuid2}).OrderAsc("id").All()
+		t.AssertNil(err)
+		t.Assert(len(all), 2)
+		t.Assert(all[0]["id"].Int(), 3)
+		t.Assert(all[1]["id"].Int(), 4)
+	})
+}
diff --git a/contrib/drivers/pgsql/pgsql_z_unit_filter_test.go b/contrib/drivers/pgsql/pgsql_z_unit_filter_test.go
new file mode 100644
index 000000000..28cf17d06
--- /dev/null
+++ b/contrib/drivers/pgsql/pgsql_z_unit_filter_test.go
@@ -0,0 +1,274 @@
+// 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 pgsql_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/gogf/gf/v2/test/gtest"
+
+	"github.com/gogf/gf/contrib/drivers/pgsql/v2"
+)
+
+// Test_DoFilter_LimitOffset tests LIMIT OFFSET conversion
+func Test_DoFilter_LimitOffset(t *testing.T) {
+	var (
+		ctx    = gctx.New()
+		driver = pgsql.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test MySQL style LIMIT x,y to PostgreSQL style LIMIT y OFFSET x
+		sql := "SELECT * FROM users LIMIT 10, 20"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users LIMIT 20 OFFSET 10")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test with different numbers
+		sql := "SELECT * FROM users LIMIT 0, 100"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users LIMIT 100 OFFSET 0")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test no conversion needed
+		sql := "SELECT * FROM users LIMIT 50"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users LIMIT 50")
+	})
+}
+
+// Test_DoFilter_InsertIgnore tests INSERT IGNORE conversion
+func Test_DoFilter_InsertIgnore(t *testing.T) {
+	var (
+		ctx    = gctx.New()
+		driver = pgsql.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test INSERT IGNORE conversion
+		sql := "INSERT IGNORE INTO users (name) VALUES ($1)"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "INSERT INTO users (name) VALUES ($1) ON CONFLICT DO NOTHING")
+	})
+}
+
+// Test_DoFilter_PlaceholderConversion tests placeholder conversion
+func Test_DoFilter_PlaceholderConversion(t *testing.T) {
+	var (
+		ctx    = gctx.New()
+		driver = pgsql.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test ? placeholder conversion to $n
+		sql := "SELECT * FROM users WHERE id = ? AND name = ?"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users WHERE id = $1 AND name = $2")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test multiple placeholders
+		sql := "INSERT INTO users (a, b, c, d, e) VALUES (?, ?, ?, ?, ?)"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "INSERT INTO users (a, b, c, d, e) VALUES ($1, $2, $3, $4, $5)")
+	})
+}
+
+// Test_DoFilter_JsonbOperator tests JSONB operator handling
+func Test_DoFilter_JsonbOperator(t *testing.T) {
+	var (
+		ctx    = gctx.New()
+		driver = pgsql.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test jsonb ?| operator
+		// The jsonb ? is first converted to $1, then restored to ?
+		// So the next placeholder becomes $2
+		sql := "SELECT * FROM users WHERE (data)::jsonb ?| ?"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		// After placeholder conversion, the ? in jsonb should be preserved
+		t.Assert(newSql, "SELECT * FROM users WHERE (data)::jsonb ?| $2")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test jsonb ?& operator
+		sql := "SELECT * FROM users WHERE (data)::jsonb &? ?"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users WHERE (data)::jsonb &? $2")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test jsonb ? operator
+		sql := "SELECT * FROM users WHERE (data)::jsonb ? ?"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users WHERE (data)::jsonb ? $2")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test combination of jsonb and regular placeholders
+		sql := "SELECT * FROM users WHERE id = ? AND (data)::jsonb ?| ?"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users WHERE id = $1 AND (data)::jsonb ?| $3")
+	})
+}
+
+// Test_DoFilter_ComplexQuery tests complex queries with multiple features
+func Test_DoFilter_ComplexQuery(t *testing.T) {
+	var (
+		ctx    = gctx.New()
+		driver = pgsql.Driver{}
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test complex query with LIMIT and placeholders
+		sql := "SELECT * FROM users WHERE status = ? AND age > ? LIMIT 5, 10"
+		newSql, _, err := driver.DoFilter(ctx, nil, sql, nil)
+		t.AssertNil(err)
+		t.Assert(newSql, "SELECT * FROM users WHERE status = $1 AND age > $2 LIMIT 10 OFFSET 5")
+	})
+}
+
+// Test_Tables tests the Tables method
+func Test_Tables_Method(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		tables, err := db.Tables(ctx)
+		t.AssertNil(err)
+		t.Assert(len(tables) >= 0, true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test with specific schema - use the test schema
+		tables, err := db.Tables(ctx, "test")
+		t.AssertNil(err)
+		t.Assert(len(tables) >= 0, true)
+	})
+}
+
+// Test_OrderRandomFunction tests the OrderRandomFunction method
+func Test_OrderRandomFunction(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test ORDER BY RANDOM()
+		all, err := db.Model(table).OrderRandom().All()
+		t.AssertNil(err)
+		t.Assert(len(all), TableSize)
+	})
+}
+
+// Test_GetChars tests the GetChars method
+func Test_GetChars(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := pgsql.Driver{}
+		left, right := driver.GetChars()
+		t.Assert(left, `"`)
+		t.Assert(right, `"`)
+	})
+}
+
+// Test_New tests the New method
+func Test_New(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := pgsql.New()
+		t.AssertNE(driver, nil)
+	})
+}
+
+// Test_DoExec_NonIntPrimaryKey tests DoExec with non-integer primary key
+func Test_DoExec_NonIntPrimaryKey(t *testing.T) {
+	// Create a table with UUID primary key
+	tableName := "t_uuid_pk_test"
+	_, err := db.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS `+tableName+` (
+			id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+			name varchar(100)
+		)
+	`)
+	if err != nil {
+		// If gen_random_uuid is not available, skip this test
+		t.Log("Skipping UUID test:", err)
+		return
+	}
+	defer db.Exec(ctx, "DROP TABLE IF EXISTS "+tableName)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert with UUID primary key
+		result, err := db.Model(tableName).Data(g.Map{
+			"name": "test_user",
+		}).Insert()
+		t.AssertNil(err)
+
+		// LastInsertId should return error for non-integer primary key
+		_, err = result.LastInsertId()
+		// For UUID, LastInsertId is not supported
+		t.AssertNE(err, nil)
+
+		// RowsAffected should still work
+		affected, err := result.RowsAffected()
+		t.AssertNil(err)
+		t.Assert(affected, int64(1))
+	})
+}
+
+// Test_TableFields_WithSchema tests TableFields with specific schema
+func Test_TableFields_WithSchema(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test with schema parameter
+		fields, err := db.TableFields(ctx, table, "test")
+		t.AssertNil(err)
+		t.Assert(len(fields) > 0, true)
+	})
+}
+
+// Test_TableFields_UniqueKey tests TableFields with unique key constraint
+func Test_TableFields_UniqueKey(t *testing.T) {
+	tableName := "t_unique_test"
+
+	// Create table with unique constraint
+	_, err := db.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS `+tableName+` (
+			id bigserial PRIMARY KEY,
+			email varchar(100) UNIQUE NOT NULL,
+			name varchar(100)
+		)
+	`)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer db.Exec(ctx, "DROP TABLE IF EXISTS "+tableName)
+
+	gtest.C(t, func(t *gtest.T) {
+		fields, err := db.TableFields(ctx, tableName)
+		t.AssertNil(err)
+
+		// Check primary key
+		t.Assert(fields["id"].Key, "pri")
+
+		// Check unique key
+		t.Assert(fields["email"].Key, "uni")
+	})
+}
diff --git a/contrib/drivers/pgsql/pgsql_z_unit_init_test.go b/contrib/drivers/pgsql/pgsql_z_unit_init_test.go
index e317d3000..c65b20d2c 100644
--- a/contrib/drivers/pgsql/pgsql_z_unit_init_test.go
+++ b/contrib/drivers/pgsql/pgsql_z_unit_init_test.go
@@ -9,6 +9,7 @@ package pgsql_test
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	_ "github.com/gogf/gf/contrib/drivers/pgsql/v2"
 
@@ -37,8 +38,8 @@ func init() {
 		Link: `pgsql:postgres:12345678@tcp(127.0.0.1:5432)`,
 	}
 
-	//pgsql only permit to connect to the designation database.
-	//so you need to create the pgsql database before you use orm
+	// pgsql only permit to connect to the designation database.
+	// so you need to create the pgsql database before you use orm
 	gdb.AddConfigNode(gdb.DefaultGroupName, configNode)
 	if r, err := gdb.New(configNode); err != nil {
 		gtest.Fatal(err)
@@ -85,6 +86,8 @@ func createTableWithDb(db gdb.DB, table ...string) (name string) {
 		   	create_time timestamp NOT NULL,
 		    favorite_movie varchar[],
 		    favorite_music text[],
+			numeric_values numeric[],
+			decimal_values decimal[],
 		   	PRIMARY KEY (id)
 		) ;`, name,
 	)); err != nil {
@@ -124,3 +127,217 @@ func dropTableWithDb(db gdb.DB, table string) {
 		gtest.Error(err)
 	}
 }
+
+// createAllTypesTable creates a table with all common PostgreSQL types for testing
+func createAllTypesTable(table ...string) string {
+	return createAllTypesTableWithDb(db, table...)
+}
+
+func createAllTypesTableWithDb(db gdb.DB, table ...string) (name string) {
+	if len(table) > 0 {
+		name = table[0]
+	} else {
+		name = fmt.Sprintf(`%s_%d`, TablePrefix+"all_types", gtime.TimestampNano())
+	}
+
+	dropTableWithDb(db, name)
+
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+		CREATE TABLE %s (
+			-- Basic integer types
+			id bigserial PRIMARY KEY,
+			col_int2 int2 NOT NULL DEFAULT 0,
+			col_int4 int4 NOT NULL DEFAULT 0,
+			col_int8 int8 DEFAULT 0,
+			col_smallint smallint,
+			col_integer integer,
+			col_bigint bigint,
+
+			-- Float types
+			col_float4 float4 DEFAULT 0.0,
+			col_float8 float8 DEFAULT 0.0,
+			col_real real,
+			col_double double precision,
+			col_numeric numeric(10,2) NOT NULL DEFAULT 0.00,
+			col_decimal decimal(10,2),
+
+			-- Character types
+			col_char char(10) DEFAULT '',
+			col_varchar varchar(100) NOT NULL DEFAULT '',
+			col_text text,
+
+			-- Boolean type
+			col_bool boolean NOT NULL DEFAULT false,
+
+			-- Date/Time types
+			col_date date DEFAULT CURRENT_DATE,
+			col_time time,
+			col_timetz timetz,
+			col_timestamp timestamp DEFAULT CURRENT_TIMESTAMP,
+			col_timestamptz timestamptz,
+			col_interval interval,
+
+			-- Binary type
+			col_bytea bytea,
+
+			-- JSON types
+			col_json json DEFAULT '{}',
+			col_jsonb jsonb DEFAULT '{}',
+
+			-- UUID type
+			col_uuid uuid,
+
+			-- Network types
+			col_inet inet,
+			col_cidr cidr,
+			col_macaddr macaddr,
+
+			-- Array types - integers
+			col_int2_arr int2[] DEFAULT '{}',
+			col_int4_arr int4[] DEFAULT '{}',
+			col_int8_arr int8[],
+
+			-- Array types - floats
+			col_float4_arr float4[],
+			col_float8_arr float8[],
+			col_numeric_arr numeric[] DEFAULT '{}',
+			col_decimal_arr decimal[],
+
+			-- Array types - characters
+			col_varchar_arr varchar[] NOT NULL DEFAULT '{}',
+			col_text_arr text[],
+			col_char_arr char(10)[],
+
+			-- Array types - boolean
+			col_bool_arr boolean[],
+
+			-- Array types - bytea
+			col_bytea_arr bytea[],
+
+			-- Array types - date/time
+			col_date_arr date[],
+			col_timestamp_arr timestamp[],
+
+			-- Array types - JSON
+			col_jsonb_arr jsonb[],
+
+			-- Array types - UUID
+			col_uuid_arr uuid[]
+		);
+
+		-- Add comments for columns
+		COMMENT ON TABLE %s IS 'Test table with all PostgreSQL types';
+		COMMENT ON COLUMN %s.id IS 'Primary key ID';
+		COMMENT ON COLUMN %s.col_int2 IS 'int2 type (smallint)';
+		COMMENT ON COLUMN %s.col_int4 IS 'int4 type (integer)';
+		COMMENT ON COLUMN %s.col_int8 IS 'int8 type (bigint)';
+		COMMENT ON COLUMN %s.col_numeric IS 'numeric type with precision';
+		COMMENT ON COLUMN %s.col_varchar IS 'varchar type';
+		COMMENT ON COLUMN %s.col_bool IS 'boolean type';
+		COMMENT ON COLUMN %s.col_timestamp IS 'timestamp type';
+		COMMENT ON COLUMN %s.col_json IS 'json type';
+		COMMENT ON COLUMN %s.col_jsonb IS 'jsonb type';
+		COMMENT ON COLUMN %s.col_int2_arr IS 'int2 array type (_int2)';
+		COMMENT ON COLUMN %s.col_int4_arr IS 'int4 array type (_int4)';
+		COMMENT ON COLUMN %s.col_int8_arr IS 'int8 array type (_int8)';
+		COMMENT ON COLUMN %s.col_numeric_arr IS 'numeric array type (_numeric)';
+		COMMENT ON COLUMN %s.col_varchar_arr IS 'varchar array type (_varchar)';
+		COMMENT ON COLUMN %s.col_text_arr IS 'text array type (_text)';
+		`, name,
+		name, name, name, name, name, name, name, name, name, name, name, name, name, name, name, name, name)); err != nil {
+		gtest.Fatal(err)
+	}
+	return
+}
+
+// createInitAllTypesTable creates and initializes a table with all common PostgreSQL types
+func createInitAllTypesTable(table ...string) string {
+	return createInitAllTypesTableWithDb(db, table...)
+}
+
+func createInitAllTypesTableWithDb(db gdb.DB, table ...string) (name string) {
+	name = createAllTypesTableWithDb(db, table...)
+
+	// Insert test data
+	for i := 1; i <= TableSize; i++ {
+		var sql strings.Builder
+
+		// Write INSERT statement header
+		sql.WriteString(fmt.Sprintf(`INSERT INTO %s (
+			col_int2, col_int4, col_int8, col_smallint, col_integer, col_bigint,
+			col_float4, col_float8, col_real, col_double, col_numeric, col_decimal,
+			col_char, col_varchar, col_text, col_bool,
+			col_date, col_time, col_timestamp,
+			col_json, col_jsonb,
+			col_bytea,
+			col_uuid,
+			col_int2_arr, col_int4_arr, col_int8_arr,
+			col_float4_arr, col_float8_arr, col_numeric_arr, col_decimal_arr,
+			col_varchar_arr, col_text_arr, col_bool_arr, col_bytea_arr, col_date_arr, col_timestamp_arr, col_jsonb_arr, col_uuid_arr
+		) VALUES (`, name))
+
+		// Integer types: col_int2, col_int4, col_int8, col_smallint, col_integer, col_bigint
+		sql.WriteString(fmt.Sprintf("%d, %d, %d, %d, %d, %d, ",
+			i, i*10, i*100, i, i*10, i*100))
+
+		// Float types: col_float4, col_float8, col_real, col_double, col_numeric, col_decimal
+		sql.WriteString(fmt.Sprintf("%d.5, %d.5, %d.5, %d.5, %d.99, %d.99, ",
+			i, i, i, i, i, i))
+
+		// Character types: col_char, col_varchar, col_text, col_bool
+		sql.WriteString(fmt.Sprintf("'char_%d', 'varchar_%d', 'text_%d', %t, ",
+			i, i, i, i%2 == 0))
+
+		// Date/Time types: col_date, col_time, col_timestamp
+		// Calculate day as integer in range 1-28; %02d in fmt.Sprintf ensures two-digit zero-padded format
+		dayOfMonth := (i-1)%28 + 1
+		sql.WriteString(fmt.Sprintf("'2024-01-%02d', '10:00:%02d', '2024-01-%02d 10:00:00', ",
+			dayOfMonth, (i-1)%60, dayOfMonth))
+
+		// JSON types: col_json, col_jsonb
+		sql.WriteString(fmt.Sprintf(`'{"key": "value%d"}', '{"key": "value%d"}', `, i, i))
+
+		// Bytea type: col_bytea
+		sql.WriteString(`E'\\xDEADBEEF', `)
+
+		// UUID type: col_uuid (use %x for hex representation, padded to ensure valid UUID)
+		sql.WriteString(fmt.Sprintf("'550e8400-e29b-41d4-a716-4466554400%02x', ", i))
+
+		// Integer array types: col_int2_arr, col_int4_arr, col_int8_arr
+		sql.WriteString(fmt.Sprintf("'{1, 2, %d}', '{10, 20, %d}', '{100, 200, %d}', ",
+			i, i, i))
+
+		// Float array types: col_float4_arr, col_float8_arr, col_numeric_arr, col_decimal_arr
+		sql.WriteString(fmt.Sprintf("'{1.1, 2.2, %d.3}', '{1.1, 2.2, %d.3}', '{1.11, 2.22, %d.33}', '{1.11, 2.22, %d.33}', ",
+			i, i, i, i))
+
+		// Character array types: col_varchar_arr, col_text_arr
+		sql.WriteString(fmt.Sprintf(`'{"a", "b", "c%d"}', '{"x", "y", "z%d"}', `, i, i))
+
+		// Boolean array type: col_bool_arr
+		sql.WriteString(fmt.Sprintf("'{true, false, %t}', ", i%2 == 0))
+
+		// Bytea array type: col_bytea_arr (use ARRAY syntax for bytea)
+		sql.WriteString(`ARRAY[E'\\xDEADBEEF', E'\\xCAFEBABE']::bytea[], `)
+
+		// Date array type: col_date_arr
+		sql.WriteString(fmt.Sprintf(`'{"2024-01-%02d", "2024-01-%02d"}', `, dayOfMonth, (dayOfMonth%28)+1))
+
+		// Timestamp array type: col_timestamp_arr
+		sql.WriteString(fmt.Sprintf(`'{"2024-01-%02d 10:00:00", "2024-01-%02d 11:00:00"}', `, dayOfMonth, dayOfMonth))
+
+		// JSONB array type: col_jsonb_arr (store as text array first, then cast to jsonb array)
+		sql.WriteString(`ARRAY['{"key": "value1"}', '{"key": "value2"}']::jsonb[], `)
+
+		// UUID array type: col_uuid_arr
+		sql.WriteString(fmt.Sprintf("ARRAY['550e8400-e29b-41d4-a716-4466554400%02x'::uuid, '6ba7b810-9dad-11d1-80b4-00c04fd430c8'::uuid]", i))
+
+		// Close VALUES
+		sql.WriteString(")")
+
+		if _, err := db.Exec(ctx, sql.String()); err != nil {
+			gtest.Fatal(err)
+		}
+	}
+	return
+}
diff --git a/contrib/drivers/pgsql/pgsql_z_unit_issue_test.go b/contrib/drivers/pgsql/pgsql_z_unit_issue_test.go
index 6fd5817fa..0e706916d 100644
--- a/contrib/drivers/pgsql/pgsql_z_unit_issue_test.go
+++ b/contrib/drivers/pgsql/pgsql_z_unit_issue_test.go
@@ -205,3 +205,178 @@ func Test_Issue4033(t *testing.T) {
 		t.AssertNil(err)
 	})
 }
+
+// https://github.com/gogf/gf/issues/4500
+// Raw() Count ignores Where condition
+func Test_Issue4500(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	// Test 1: Raw SQL with WHERE + external Where condition + Count
+	// This tests that formatCondition correctly uses AND when Raw SQL already has WHERE
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.
+			Raw(fmt.Sprintf("SELECT * FROM %s WHERE id IN (?)", table), g.Slice{1, 5, 7, 8, 9, 10}).
+			WhereLT("id", 8).
+			Count()
+		t.AssertNil(err)
+		// Raw SQL: id IN (1,5,7,8,9,10) = 6 records
+		// Where: id < 8 filters to {1,5,7} = 3 records
+		t.Assert(count, 3)
+	})
+
+	// Test 2: Raw SQL without WHERE + external Where condition + Count
+	// This tests that formatCondition correctly adds WHERE
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.
+			Raw(fmt.Sprintf("SELECT * FROM %s", table)).
+			WhereLT("id", 5).
+			Count()
+		t.AssertNil(err)
+		// Raw SQL: all 10 records
+		// Where: id < 5 = {1,2,3,4} = 4 records
+		t.Assert(count, 4)
+	})
+
+	// Test 3: Raw + Where + ScanAndCount
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Id       int
+			Passport string
+		}
+		var users []User
+		var total int
+		err := db.
+			Raw(fmt.Sprintf("SELECT * FROM %s WHERE id IN (?)", table), g.Slice{1, 5, 7, 8, 9, 10}).
+			WhereLT("id", 8).
+			ScanAndCount(&users, &total, false)
+		t.AssertNil(err)
+		// Both scan result and count should respect Where condition
+		t.Assert(len(users), 3)
+		t.Assert(total, 3)
+	})
+
+	// Test 4: Raw + multiple Where conditions + Count
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.
+			Raw(fmt.Sprintf("SELECT * FROM %s WHERE id > ?", table), 0).
+			WhereLT("id", 5).
+			WhereGTE("id", 2).
+			Count()
+		t.AssertNil(err)
+		// Raw: id > 0 (all 10 records)
+		// Where: id < 5 AND id >= 2 = {2, 3, 4} = 3 records
+		t.Assert(count, 3)
+	})
+
+	// Test 5: Raw SQL with no external Where + Count (baseline test)
+	gtest.C(t, func(t *gtest.T) {
+		count, err := db.
+			Raw(fmt.Sprintf("SELECT * FROM %s WHERE id IN (?)", table), g.Slice{1, 2, 3}).
+			Count()
+		t.AssertNil(err)
+		// Should count 3 records
+		t.Assert(count, 3)
+	})
+
+	// Test 6: Verify All() still works correctly with Raw + Where
+	gtest.C(t, func(t *gtest.T) {
+		all, err := db.
+			Raw(fmt.Sprintf("SELECT * FROM %s WHERE id IN (?)", table), g.Slice{1, 5, 7, 8, 9, 10}).
+			WhereLT("id", 8).
+			All()
+		t.AssertNil(err)
+		t.Assert(len(all), 3)
+	})
+}
+
+// https://github.com/gogf/gf/issues/4595
+// FieldsPrefix silently drops fields when using table alias before LeftJoin.
+func Test_Issue4595(t *testing.T) {
+	var (
+		tableUser       = fmt.Sprintf(`%s_%d`, TablePrefix+"issue4595_user", gtime.TimestampNano())
+		tableUserDetail = fmt.Sprintf(`%s_%d`, TablePrefix+"issue4595_user_detail", gtime.TimestampNano())
+	)
+
+	// Create user table
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+		CREATE TABLE %s (
+			id bigserial PRIMARY KEY,
+			name varchar(100),
+			email varchar(100)
+		);`, tableUser,
+	)); err != nil {
+		gtest.Fatal(err)
+	}
+	defer dropTable(tableUser)
+
+	// Create user_detail table
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+		CREATE TABLE %s (
+			id bigserial PRIMARY KEY,
+			user_id bigint,
+			phone varchar(20),
+			address varchar(200)
+		);`, tableUserDetail,
+	)); err != nil {
+		gtest.Fatal(err)
+	}
+	defer dropTable(tableUserDetail)
+
+	// Insert test data
+	if _, err := db.Exec(ctx, fmt.Sprintf(`
+		INSERT INTO %s (id, name, email) VALUES (1, 'john', 'john@example.com');
+		INSERT INTO %s (id, user_id, phone, address) VALUES (1, 1, '1234567890', '123 Main St');
+	`, tableUser, tableUserDetail)); err != nil {
+		gtest.Fatal(err)
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test case 1: FieldsPrefix called before LeftJoin
+		// Both t1 and t2 fields should be present
+		r, err := db.Model(tableUser).As("t1").
+			FieldsPrefix("t2", "phone", "address").
+			FieldsPrefix("t1", "id", "name", "email").
+			LeftJoin(tableUserDetail, "t2", "t1.id=t2.user_id").
+			All()
+
+		t.AssertNil(err)
+		t.Assert(len(r), 1)
+		t.Assert(r[0]["id"], 1)
+		t.Assert(r[0]["name"], "john")
+		t.Assert(r[0]["email"], "john@example.com")
+		t.Assert(r[0]["phone"], "1234567890")
+		t.Assert(r[0]["address"], "123 Main St")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test case 2: Using Fields() with prefix
+		r, err := db.Model(tableUser).As("t1").
+			Fields("t2.phone", "t2.address", "t1.id", "t1.name", "t1.email").
+			LeftJoin(tableUserDetail, "t2", "t1.id=t2.user_id").
+			All()
+		t.AssertNil(err)
+		t.Assert(len(r), 1)
+		t.Assert(r[0]["id"], 1)
+		t.Assert(r[0]["name"], "john")
+		t.Assert(r[0]["email"], "john@example.com")
+		t.Assert(r[0]["phone"], "1234567890")
+		t.Assert(r[0]["address"], "123 Main St")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test case 3: FieldsPrefix called after LeftJoin
+		r, err := db.Model(tableUser).As("t1").
+			LeftJoin(tableUserDetail, "t2", "t1.id=t2.user_id").
+			FieldsPrefix("t2", "phone", "address").
+			FieldsPrefix("t1", "id", "name", "email").
+			All()
+		t.AssertNil(err)
+		t.Assert(len(r), 1)
+		t.Assert(r[0]["id"], 1)
+		t.Assert(r[0]["name"], "john")
+		t.Assert(r[0]["email"], "john@example.com")
+		t.Assert(r[0]["phone"], "1234567890")
+		t.Assert(r[0]["address"], "123 Main St")
+	})
+}
diff --git a/contrib/drivers/pgsql/pgsql_z_unit_model_test.go b/contrib/drivers/pgsql/pgsql_z_unit_model_test.go
index 3a51ba264..4ca729891 100644
--- a/contrib/drivers/pgsql/pgsql_z_unit_model_test.go
+++ b/contrib/drivers/pgsql/pgsql_z_unit_model_test.go
@@ -334,14 +334,53 @@ func Test_Model_Replace(t *testing.T) {
 	defer dropTable(table)
 
 	gtest.C(t, func(t *gtest.T) {
-		_, err := db.Model(table).Data(g.Map{
+		// Insert initial record
+		result, err := db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "t1",
+			"password":    "pass1",
+			"nickname":    "T1",
+			"create_time": "2018-10-24 10:00:00",
+		}).Insert()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+
+		// Replace with new data
+		result, err = db.Model(table).Data(g.Map{
 			"id":          1,
 			"passport":    "t11",
 			"password":    "25d55ad283aa400af464c76d713c07ad",
 			"nickname":    "T11",
 			"create_time": "2018-10-24 10:00:00",
 		}).Replace()
-		t.Assert(err, "Replace operation is not supported by pgsql driver")
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+
+		// Verify the data was replaced
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one["passport"].String(), "t11")
+		t.Assert(one["password"].String(), "25d55ad283aa400af464c76d713c07ad")
+		t.Assert(one["nickname"].String(), "T11")
+
+		// Replace with new ID (insert new record)
+		result, err = db.Model(table).Data(g.Map{
+			"id":          2,
+			"passport":    "t22",
+			"password":    "pass22",
+			"nickname":    "T22",
+			"create_time": "2018-10-24 11:00:00",
+		}).Replace()
+		t.AssertNil(err)
+		n, _ = result.RowsAffected()
+		t.Assert(n, 1)
+
+		// Verify new record was inserted
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, 2)
 	})
 }
 
@@ -692,3 +731,134 @@ func Test_ConvertSliceString(t *testing.T) {
 		t.Assert(len(user2.FavoriteMovie), 0)
 	})
 }
+
+func Test_ConvertSliceFloat64(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	type Args struct {
+		NumericValues []float64 `orm:"numeric_values"`
+		DecimalValues []float64 `orm:"decimal_values"`
+	}
+	type User struct {
+		Id         int         `orm:"id"`
+		Passport   string      `orm:"passport"`
+		Password   string      `json:"password"`
+		NickName   string      `json:"nickname"`
+		CreateTime *gtime.Time `json:"create_time"`
+		Args
+	}
+
+	tests := []struct {
+		name string
+		args Args
+	}{
+		{
+			name: "nil",
+			args: Args{
+				NumericValues: nil,
+				DecimalValues: nil,
+			},
+		},
+		{
+			name: "not nil",
+			args: Args{
+				NumericValues: []float64{1.1, 2.2, 3.3},
+				DecimalValues: []float64{1.1, 2.2, 3.3},
+			},
+		},
+		{
+			name: "not empty",
+			args: Args{
+				NumericValues: []float64{},
+				DecimalValues: []float64{},
+			},
+		},
+	}
+	now := gtime.New(CreateTime)
+	for i, tt := range tests {
+		gtest.C(t, func(t *gtest.T) {
+			user := User{
+				Id:         i + 1,
+				Passport:   "",
+				Password:   "",
+				NickName:   "",
+				CreateTime: now,
+				Args:       tt.args,
+			}
+
+			_, err := db.Model(table).OmitNilData().Insert(user)
+			t.AssertNil(err)
+			var got Args
+			err = db.Model(table).Where("id", user.Id).Limit(1).Scan(&got)
+			t.AssertNil(err)
+			t.AssertEQ(tt.args, got)
+		})
+	}
+}
+
+func Test_Model_InsertIgnore(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		user := db.Model(table)
+		result, err := user.Data(g.Map{
+			"id":          1,
+			"uid":         1,
+			"passport":    "t1",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_1",
+			"create_time": gtime.Now().String(),
+		}).Insert()
+		t.AssertNil(err)
+		n, _ := result.RowsAffected()
+		t.Assert(n, 1)
+
+		result, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"uid":         1,
+			"passport":    "t1",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_1",
+			"create_time": gtime.Now().String(),
+		}).Insert()
+		t.AssertNE(err, nil)
+
+		result, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"uid":         1,
+			"passport":    "t2",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_2",
+			"create_time": gtime.Now().String(),
+		}).InsertIgnore()
+		t.AssertNil(err)
+
+		n, _ = result.RowsAffected()
+		t.Assert(n, 0)
+
+		value, err := db.Model(table).Fields("passport").WherePri(1).Value()
+		t.AssertNil(err)
+		t.Assert(value.String(), "t1")
+
+		count, err := db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, 1)
+
+		// pgsql support ignore without primary key
+		result, err = db.Model(table).Data(g.Map{
+			// "id":          1,
+			"uid":         1,
+			"passport":    "t2",
+			"password":    "25d55ad283aa400af464c76d713c07ad",
+			"nickname":    "name_2",
+			"create_time": gtime.Now().String(),
+		}).InsertIgnore()
+		t.AssertNil(err)
+
+		count, err = db.Model(table).Count()
+		t.AssertNil(err)
+		t.Assert(count, 1)
+	})
+}
diff --git a/contrib/drivers/pgsql/pgsql_z_unit_open_test.go b/contrib/drivers/pgsql/pgsql_z_unit_open_test.go
new file mode 100644
index 000000000..66b7313d9
--- /dev/null
+++ b/contrib/drivers/pgsql/pgsql_z_unit_open_test.go
@@ -0,0 +1,179 @@
+// 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 pgsql_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/test/gtest"
+
+	"github.com/gogf/gf/contrib/drivers/pgsql/v2"
+)
+
+// Test_Open tests the Open method with various configurations
+func Test_Open_WithNamespace(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := pgsql.Driver{}
+		config := &gdb.ConfigNode{
+			User:      "postgres",
+			Pass:      "12345678",
+			Host:      "127.0.0.1",
+			Port:      "5432",
+			Name:      "test",
+			Namespace: "public",
+		}
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		t.AssertNE(db, nil)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
+
+// Test_Open_WithTimezone tests Open with timezone configuration
+func Test_Open_WithTimezone(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := pgsql.Driver{}
+		config := &gdb.ConfigNode{
+			User:     "postgres",
+			Pass:     "12345678",
+			Host:     "127.0.0.1",
+			Port:     "5432",
+			Name:     "test",
+			Timezone: "Asia/Shanghai",
+		}
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		t.AssertNE(db, nil)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
+
+// Test_Open_WithExtra tests Open with extra configuration
+func Test_Open_WithExtra(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := pgsql.Driver{}
+		config := &gdb.ConfigNode{
+			User:  "postgres",
+			Pass:  "12345678",
+			Host:  "127.0.0.1",
+			Port:  "5432",
+			Name:  "test",
+			Extra: "connect_timeout=10",
+		}
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		t.AssertNE(db, nil)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
+
+// Test_Open_WithInvalidExtra tests Open with invalid extra configuration
+func Test_Open_WithInvalidExtra(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := pgsql.Driver{}
+		config := &gdb.ConfigNode{
+			User: "postgres",
+			Pass: "12345678",
+			Host: "127.0.0.1",
+			Port: "5432",
+			Name: "test",
+			// Invalid extra format with invalid URL encoding that will cause parse error
+			Extra: "%Q=%Q&b",
+		}
+		_, err := driver.Open(config)
+		t.AssertNE(err, nil)
+	})
+}
+
+// Test_Open_WithFullConfig tests Open with all configuration options
+func Test_Open_WithFullConfig(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := pgsql.Driver{}
+		config := &gdb.ConfigNode{
+			User:      "postgres",
+			Pass:      "12345678",
+			Host:      "127.0.0.1",
+			Port:      "5432",
+			Name:      "test",
+			Namespace: "public",
+			Timezone:  "UTC",
+			Extra:     "connect_timeout=10",
+		}
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		t.AssertNE(db, nil)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
+
+// Test_Open_WithoutPort tests Open without port
+func Test_Open_WithoutPort(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := pgsql.Driver{}
+		config := &gdb.ConfigNode{
+			User: "postgres",
+			Pass: "12345678",
+			Host: "127.0.0.1",
+			Name: "test",
+		}
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		t.AssertNE(db, nil)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
+
+// Test_Open_WithoutName tests Open without database name
+func Test_Open_WithoutName(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := pgsql.Driver{}
+		config := &gdb.ConfigNode{
+			User: "postgres",
+			Pass: "12345678",
+			Host: "127.0.0.1",
+			Port: "5432",
+		}
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		t.AssertNE(db, nil)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
+
+// Test_Open_InvalidHost tests Open with invalid host
+func Test_Open_InvalidHost(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		driver := pgsql.Driver{}
+		config := &gdb.ConfigNode{
+			User: "postgres",
+			Pass: "12345678",
+			Host: "invalid_host_that_does_not_exist",
+			Port: "5432",
+			Name: "test",
+		}
+		// Note: sql.Open doesn't actually connect, so no error here
+		// The error would occur when actually using the connection
+		db, err := driver.Open(config)
+		t.AssertNil(err)
+		if db != nil {
+			db.Close()
+		}
+	})
+}
diff --git a/contrib/drivers/pgsql/pgsql_z_unit_upsert_test.go b/contrib/drivers/pgsql/pgsql_z_unit_upsert_test.go
new file mode 100644
index 000000000..edefab632
--- /dev/null
+++ b/contrib/drivers/pgsql/pgsql_z_unit_upsert_test.go
@@ -0,0 +1,267 @@
+// 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 pgsql_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+// Test_FormatUpsert_WithOnDuplicateStr tests FormatUpsert with OnDuplicateStr
+func Test_FormatUpsert_WithOnDuplicateStr(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial data
+		_, err := db.Model(table).Data(g.Map{
+			"passport":    "user1",
+			"password":    "pwd",
+			"nickname":    "nick1",
+			"create_time": CreateTime,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Test Save with OnConflict (upsert)
+		_, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "user1",
+			"password":    "newpwd",
+			"nickname":    "newnick",
+			"create_time": CreateTime,
+		}).OnConflict("id").Save()
+		t.AssertNil(err)
+
+		// Verify the update
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one["password"].String(), "newpwd")
+		t.Assert(one["nickname"].String(), "newnick")
+	})
+}
+
+// Test_FormatUpsert_WithOnDuplicateMap tests FormatUpsert with OnDuplicateMap
+func Test_FormatUpsert_WithOnDuplicateMap(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial data
+		_, err := db.Model(table).Data(g.Map{
+			"passport":    "user2",
+			"password":    "pwd",
+			"nickname":    "nick2",
+			"create_time": CreateTime,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Test OnDuplicate with map - values should be column names to use EXCLUDED.column
+		_, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "user2",
+			"password":    "newpwd2",
+			"nickname":    "newnick2",
+			"create_time": CreateTime,
+		}).OnConflict("id").OnDuplicate(g.Map{
+			"password": "password",
+			"nickname": "nickname",
+		}).Save()
+		t.AssertNil(err)
+
+		// Verify - values should be from the inserted data
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one["password"].String(), "newpwd2")
+		t.Assert(one["nickname"].String(), "newnick2")
+	})
+}
+
+// Test_FormatUpsert_WithCounter tests FormatUpsert with Counter type on numeric column.
+// Note: In PostgreSQL, Counter uses EXCLUDED.column which references the NEW value being inserted,
+// not the current table value. This differs from MySQL's ON DUPLICATE KEY UPDATE behavior.
+func Test_FormatUpsert_WithCounter(t *testing.T) {
+	// Create a special table with numeric id for counter test
+	tableName := "t_counter_test"
+	dropTable(tableName)
+	_, err := db.Exec(ctx, `
+		CREATE TABLE `+tableName+` (
+			id bigserial PRIMARY KEY,
+			counter_value int NOT NULL DEFAULT 0,
+			name varchar(45)
+		)
+	`)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer dropTable(tableName)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial data
+		_, err := db.Model(tableName).Data(g.Map{
+			"counter_value": 10,
+			"name":          "counter_test",
+		}).Insert()
+		t.AssertNil(err)
+
+		// Get initial ID
+		one, err := db.Model(tableName).Where("name", "counter_test").One()
+		t.AssertNil(err)
+		initialId := one["id"].Int64()
+
+		// Test OnDuplicate with Counter
+		// In PostgreSQL: counter_value = EXCLUDED.counter_value + 5
+		// EXCLUDED.counter_value is the value we're trying to insert (20)
+		// So result = 20 + 5 = 25
+		_, err = db.Model(tableName).Data(g.Map{
+			"id":            initialId,
+			"counter_value": 20, // This is the EXCLUDED value
+			"name":          "counter_test",
+		}).OnConflict("id").OnDuplicate(g.Map{
+			"counter_value": &gdb.Counter{
+				Field: "counter_value",
+				Value: 5,
+			},
+		}).Save()
+		t.AssertNil(err)
+
+		// Verify: EXCLUDED.counter_value(20) + 5 = 25
+		one, err = db.Model(tableName).Where("id", initialId).One()
+		t.AssertNil(err)
+		t.Assert(one["counter_value"].Int(), 25)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test Counter with negative value (decrement)
+		one, err := db.Model(tableName).Where("name", "counter_test").One()
+		t.AssertNil(err)
+		initialId := one["id"].Int64()
+
+		// In PostgreSQL: counter_value = EXCLUDED.counter_value - 3
+		// EXCLUDED.counter_value is 100, so result = 100 - 3 = 97
+		_, err = db.Model(tableName).Data(g.Map{
+			"id":            initialId,
+			"counter_value": 100, // This is the EXCLUDED value
+			"name":          "counter_test",
+		}).OnConflict("id").OnDuplicate(g.Map{
+			"counter_value": &gdb.Counter{
+				Field: "counter_value",
+				Value: -3,
+			},
+		}).Save()
+		t.AssertNil(err)
+
+		// Verify: EXCLUDED.counter_value(100) - 3 = 97
+		one, err = db.Model(tableName).Where("id", initialId).One()
+		t.AssertNil(err)
+		t.Assert(one["counter_value"].Int(), 97)
+	})
+}
+
+// Test_FormatUpsert_WithRaw tests FormatUpsert with Raw type
+func Test_FormatUpsert_WithRaw(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial data
+		_, err := db.Model(table).Data(g.Map{
+			"passport":    "raw_user",
+			"password":    "pwd",
+			"nickname":    "nick",
+			"create_time": CreateTime,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Get initial ID
+		one, err := db.Model(table).Where("passport", "raw_user").One()
+		t.AssertNil(err)
+		initialId := one["id"].Int64()
+
+		// Test OnDuplicate with Raw SQL
+		_, err = db.Model(table).Data(g.Map{
+			"id":          initialId,
+			"passport":    "raw_user",
+			"password":    "pwd",
+			"nickname":    "nick",
+			"create_time": CreateTime,
+		}).OnConflict("id").OnDuplicate(g.Map{
+			"password": gdb.Raw("'raw_password'"),
+		}).Save()
+		t.AssertNil(err)
+
+		// Verify
+		one, err = db.Model(table).Where("id", initialId).One()
+		t.AssertNil(err)
+		t.Assert(one["password"].String(), "raw_password")
+	})
+}
+
+// Test_FormatUpsert_NoOnConflict tests FormatUpsert without OnConflict (should fail)
+func Test_FormatUpsert_NoOnConflict(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial data
+		_, err := db.Model(table).Data(g.Map{
+			"passport":    "no_conflict_user",
+			"password":    "pwd",
+			"nickname":    "nick",
+			"create_time": CreateTime,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Try Save without OnConflict and without primary key in data - should fail
+		// because driver cannot auto-detect conflict columns when primary key is missing
+		_, err = db.Model(table).Data(g.Map{
+			// "id":          1,
+			"passport":    "no_conflict_user",
+			"password":    "newpwd",
+			"nickname":    "newnick",
+			"create_time": CreateTime,
+		}).Save()
+		t.AssertNE(err, nil)
+	})
+}
+
+// Test_FormatUpsert_MultipleConflictKeys tests FormatUpsert with multiple conflict keys
+func Test_FormatUpsert_MultipleConflictKeys(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		// Insert initial data
+		_, err := db.Model(table).Data(g.Map{
+			"passport":    "multi_key_user",
+			"password":    "pwd",
+			"nickname":    "nick",
+			"create_time": CreateTime,
+		}).Insert()
+		t.AssertNil(err)
+
+		// Test with multiple conflict keys using only "id" which has a unique constraint
+		// Note: Using multiple keys requires a composite unique constraint to exist
+		_, err = db.Model(table).Data(g.Map{
+			"id":          1,
+			"passport":    "multi_key_user",
+			"password":    "newpwd",
+			"nickname":    "newnick",
+			"create_time": CreateTime,
+		}).OnConflict("id").Save()
+		t.AssertNil(err)
+
+		// Verify the update
+		one, err := db.Model(table).Where("id", 1).One()
+		t.AssertNil(err)
+		t.Assert(one["password"].String(), "newpwd")
+		t.Assert(one["nickname"].String(), "newnick")
+	})
+}
diff --git a/contrib/drivers/sqlite/go.mod b/contrib/drivers/sqlite/go.mod
index c565556cc..a30cd83b1 100644
--- a/contrib/drivers/sqlite/go.mod
+++ b/contrib/drivers/sqlite/go.mod
@@ -4,14 +4,14 @@ go 1.23.0
 
 require (
 	github.com/glebarez/go-sqlite v1.21.2
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -20,22 +20,22 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	modernc.org/libc v1.22.5 // indirect
 	modernc.org/mathutil v1.5.0 // indirect
diff --git a/contrib/drivers/sqlite/go.sum b/contrib/drivers/sqlite/go.sum
index 377b0e485..2982163d9 100644
--- a/contrib/drivers/sqlite/go.sum
+++ b/contrib/drivers/sqlite/go.sum
@@ -6,8 +6,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -35,8 +35,9 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -45,39 +46,41 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/contrib/drivers/sqlite/sqlite_z_unit_model_test.go b/contrib/drivers/sqlite/sqlite_z_unit_model_test.go
index 03e8465c7..a6ec678f4 100644
--- a/contrib/drivers/sqlite/sqlite_z_unit_model_test.go
+++ b/contrib/drivers/sqlite/sqlite_z_unit_model_test.go
@@ -3482,7 +3482,12 @@ func Test_Model_Raw(t *testing.T) {
 			Limit(2).
 			Count()
 		t.AssertNil(err)
-		t.Assert(count, int64(6))
+		// After fix for issue #4500, Where conditions are correctly applied to Raw SQL Count.
+		// Raw SQL matches: id in (1, 5, 7, 8, 9, 10)
+		// WhereLT("id", 8): id < 8 -> (1, 5, 7)
+		// WhereIn("id", {1-7}): id in (1, 2, 3, 4, 5, 6, 7) -> (1, 5, 7)
+		// Result: 3 records match all conditions
+		t.Assert(count, int64(3))
 	})
 }
 
diff --git a/contrib/drivers/sqlitecgo/go.mod b/contrib/drivers/sqlitecgo/go.mod
index 40c55e592..c95dfc713 100644
--- a/contrib/drivers/sqlitecgo/go.mod
+++ b/contrib/drivers/sqlitecgo/go.mod
@@ -3,14 +3,14 @@ module github.com/gogf/gf/contrib/drivers/sqlitecgo/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 	github.com/mattn/go-sqlite3 v1.14.17
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -19,21 +19,21 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/drivers/sqlitecgo/go.sum b/contrib/drivers/sqlitecgo/go.sum
index 4d74cd45e..09bc3df19 100644
--- a/contrib/drivers/sqlitecgo/go.sum
+++ b/contrib/drivers/sqlitecgo/go.sum
@@ -4,8 +4,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -29,8 +29,9 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -41,36 +42,38 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/contrib/drivers/sqlitecgo/sqlite_format_upsert.go b/contrib/drivers/sqlitecgo/sqlitecgo_format_upsert.go
similarity index 100%
rename from contrib/drivers/sqlitecgo/sqlite_format_upsert.go
rename to contrib/drivers/sqlitecgo/sqlitecgo_format_upsert.go
diff --git a/contrib/drivers/sqlitecgo/sqlitecgo_z_unit_model_test.go b/contrib/drivers/sqlitecgo/sqlitecgo_z_unit_model_test.go
index 3ad793df2..7eed117d5 100644
--- a/contrib/drivers/sqlitecgo/sqlitecgo_z_unit_model_test.go
+++ b/contrib/drivers/sqlitecgo/sqlitecgo_z_unit_model_test.go
@@ -3480,7 +3480,12 @@ func Test_Model_Raw(t *testing.T) {
 			Limit(2).
 			Count()
 		t.AssertNil(err)
-		t.Assert(count, int64(6))
+		// After fix for issue #4500, Where conditions are correctly applied to Raw SQL Count.
+		// Raw SQL matches: id in (1, 5, 7, 8, 9, 10)
+		// WhereLT("id", 8): id < 8 -> (1, 5, 7)
+		// WhereIn("id", {1-7}): id in (1, 2, 3, 4, 5, 6, 7) -> (1, 5, 7)
+		// Result: 3 records match all conditions
+		t.Assert(count, int64(3))
 	})
 }
 
diff --git a/contrib/drivers/tidb/go.mod b/contrib/drivers/tidb/go.mod
new file mode 100644
index 000000000..d99277e80
--- /dev/null
+++ b/contrib/drivers/tidb/go.mod
@@ -0,0 +1,44 @@
+module github.com/gogf/gf/contrib/drivers/tidb/v2
+
+go 1.23.0
+
+require (
+	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.8
+	github.com/gogf/gf/v2 v2.9.8
+)
+
+require (
+	github.com/BurntSushi/toml v1.5.0 // indirect
+	github.com/clbanning/mxj/v2 v2.7.0 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
+	github.com/fatih/color v1.18.0 // indirect
+	github.com/fsnotify/fsnotify v1.9.0 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-sql-driver/mysql v1.7.1 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/gorilla/websocket v1.5.3 // indirect
+	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
+	github.com/magiconair/properties v1.8.10 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/olekukonko/errors v1.1.0 // indirect
+	github.com/olekukonko/ll v0.0.9 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/sys v0.35.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
+
+replace (
+	github.com/gogf/gf/contrib/drivers/mysql/v2 => ../mysql
+	github.com/gogf/gf/v2 => ../../../
+)
diff --git a/contrib/drivers/tidb/go.sum b/contrib/drivers/tidb/go.sum
new file mode 100644
index 000000000..f96db96f2
--- /dev/null
+++ b/contrib/drivers/tidb/go.sum
@@ -0,0 +1,81 @@
+github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
+github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
+github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyME=
+github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
+github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
+github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
+github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtgzltlQbOBae4=
+github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
+github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
+github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
+github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
+github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/contrib/drivers/tidb/tidb.go b/contrib/drivers/tidb/tidb.go
new file mode 100644
index 000000000..126668d4b
--- /dev/null
+++ b/contrib/drivers/tidb/tidb.go
@@ -0,0 +1,61 @@
+// 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 tidb implements gdb.Driver, which supports operations for database TiDB.
+package tidb
+
+import (
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+
+	"github.com/gogf/gf/contrib/drivers/mysql/v2"
+)
+
+// Driver is the driver for TiDB database.
+//
+// TiDB is an open-source NewSQL database that supports Hybrid Transactional and Analytical Processing (HTAP).
+// This driver uses the MySQL protocol to communicate with TiDB database, as TiDB is designed to be highly
+// compatible with the MySQL protocol.
+//
+// Although TiDB is compatible with MySQL protocol, it is packaged as a separate driver component
+// rather than reusing the mysql adapter directly. This design allows for future extensibility,
+// such as implementing TiDB-specific features like distributed transactions or optimizations.
+type Driver struct {
+	*mysql.Driver
+}
+
+func init() {
+	var (
+		err         error
+		driverObj   = New()
+		driverNames = g.SliceStr{"tidb"}
+	)
+	for _, driverName := range driverNames {
+		if err = gdb.Register(driverName, driverObj); err != nil {
+			panic(err)
+		}
+	}
+}
+
+// New creates and returns a driver that implements gdb.Driver, which supports operations for TiDB.
+func New() gdb.Driver {
+	mysqlDriver := mysql.New().(*mysql.Driver)
+	return &Driver{
+		Driver: mysqlDriver,
+	}
+}
+
+// New creates and returns a database object for TiDB.
+// It implements the interface of gdb.Driver for extra database driver installation.
+func (d *Driver) New(core *gdb.Core, node *gdb.ConfigNode) (gdb.DB, error) {
+	mysqlDB, err := d.Driver.New(core, node)
+	if err != nil {
+		return nil, err
+	}
+	return &Driver{
+		Driver: mysqlDB.(*mysql.Driver),
+	}, nil
+}
diff --git a/contrib/metric/otelmetric/go.mod b/contrib/metric/otelmetric/go.mod
index e2be75687..cac8ccb97 100644
--- a/contrib/metric/otelmetric/go.mod
+++ b/contrib/metric/otelmetric/go.mod
@@ -3,14 +3,14 @@ module github.com/gogf/gf/contrib/metric/otelmetric/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
-	github.com/prometheus/client_golang v1.23.0
-	go.opentelemetry.io/contrib/instrumentation/runtime v0.62.0
-	go.opentelemetry.io/otel v1.37.0
-	go.opentelemetry.io/otel/exporters/prometheus v0.46.0
-	go.opentelemetry.io/otel/metric v1.37.0
-	go.opentelemetry.io/otel/sdk v1.37.0
-	go.opentelemetry.io/otel/sdk/metric v1.37.0
+	github.com/gogf/gf/v2 v2.9.8
+	github.com/prometheus/client_golang v1.23.2
+	go.opentelemetry.io/contrib/instrumentation/runtime v0.63.0
+	go.opentelemetry.io/otel v1.38.0
+	go.opentelemetry.io/otel/exporters/prometheus v0.60.0
+	go.opentelemetry.io/otel/metric v1.38.0
+	go.opentelemetry.io/otel/sdk v1.38.0
+	go.opentelemetry.io/otel/sdk/metric v1.38.0
 )
 
 require (
@@ -18,28 +18,31 @@ require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
+	github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
 	github.com/prometheus/client_model v0.6.2 // indirect
-	github.com/prometheus/common v0.65.0 // indirect
+	github.com/prometheus/common v0.66.1 // indirect
+	github.com/prometheus/otlptranslator v0.0.2 // indirect
 	github.com/prometheus/procfs v0.17.0 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	go.yaml.in/yaml/v2 v2.4.2 // indirect
 	golang.org/x/net v0.43.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
 	golang.org/x/text v0.28.0 // indirect
diff --git a/contrib/metric/otelmetric/go.sum b/contrib/metric/otelmetric/go.sum
index d6fe5b4a0..26661129c 100644
--- a/contrib/metric/otelmetric/go.sum
+++ b/contrib/metric/otelmetric/go.sum
@@ -8,8 +8,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -25,6 +25,8 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc h1:GN2Lv3MGO7AS6PrRoT6yV5+wkrOpcszoIsO4+4ds248=
+github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc/go.mod h1:+JKpmjMGhpgPL+rXZ5nsZieVzvarn86asRlBg4uNGnk=
 github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtgzltlQbOBae4=
 github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
 github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
@@ -37,8 +39,9 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -49,45 +52,49 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/prometheus/client_golang v1.23.0 h1:ust4zpdl9r4trLY/gSjlm07PuiBq2ynaXXlptpfy8Uc=
-github.com/prometheus/client_golang v1.23.0/go.mod h1:i/o0R9ByOnHX0McrTMTyhYvKE4haaf2mW08I+jGAjEE=
+github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
+github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
 github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
 github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
-github.com/prometheus/common v0.65.0 h1:QDwzd+G1twt//Kwj/Ww6E9FQq1iVMmODnILtW1t2VzE=
-github.com/prometheus/common v0.65.0/go.mod h1:0gZns+BLRQ3V6NdaerOhMbwwRbNh9hkGINtQAsP5GS8=
+github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs=
+github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=
+github.com/prometheus/otlptranslator v0.0.2 h1:+1CdeLVrRQ6Psmhnobldo0kTp96Rj80DRXRd5OSnMEQ=
+github.com/prometheus/otlptranslator v0.0.2/go.mod h1:P8AwMgdD7XEr6QRUJ2QWLpiAZTgTE2UYgjlu3svompI=
 github.com/prometheus/procfs v0.17.0 h1:FuLQ+05u4ZI+SS/w9+BWEM2TXiHKsUQ9TADiRH7DuK0=
 github.com/prometheus/procfs v0.17.0/go.mod h1:oPQLaDAMRbA+u8H5Pbfq+dl3VDAvHxMUOVhe0wYB2zw=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/contrib/instrumentation/runtime v0.62.0 h1:ZIt0ya9/y4WyRIzfLC8hQRRsWg0J9M9GyaGtIMiElZI=
-go.opentelemetry.io/contrib/instrumentation/runtime v0.62.0/go.mod h1:F1aJ9VuiKWOlWwKdTYDUp1aoS0HzQxg38/VLxKmhm5U=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/exporters/prometheus v0.46.0 h1:I8WIFXR351FoLJYuloU4EgXbtNX2URfU/85pUPheIEQ=
-go.opentelemetry.io/otel/exporters/prometheus v0.46.0/go.mod h1:ztwVUHe5DTR/1v7PeuGRnU5Bbd4QKYwApWmuutKsJSs=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc=
-go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/contrib/instrumentation/runtime v0.63.0 h1:PeBoRj6af6xMI7qCupwFvTbbnd49V7n5YpG6pg8iDYQ=
+go.opentelemetry.io/contrib/instrumentation/runtime v0.63.0/go.mod h1:ingqBCtMCe8I4vpz/UVzCW6sxoqgZB37nao91mLQ3Bw=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/exporters/prometheus v0.60.0 h1:cGtQxGvZbnrWdC2GyjZi0PDKVSLWP/Jocix3QWfXtbo=
+go.opentelemetry.io/otel/exporters/prometheus v0.60.0/go.mod h1:hkd1EekxNo69PTV4OWFGZcKQiIqg0RfuWExcPKFvepk=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI=
+go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU=
 golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
 golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
diff --git a/contrib/metric/otelmetric/otelmetric_z_unit_http_test.go b/contrib/metric/otelmetric/otelmetric_z_unit_http_test.go
index 325a9a8ab..fd65ee1fa 100644
--- a/contrib/metric/otelmetric/otelmetric_z_unit_http_test.go
+++ b/contrib/metric/otelmetric/otelmetric_z_unit_http_test.go
@@ -86,9 +86,9 @@ func Test_HTTP_Server(t *testing.T) {
 			fmt.Sprintf(`server_port="%d"`, s.GetListenedPort()),
 			expectContent,
 		)
-		//fmt.Println(metricsContent)
+		// fmt.Println(metricsContent)
 		for _, line := range gstr.SplitAndTrim(expectContent, "\n") {
-			//fmt.Println(line)
+			// fmt.Println(line)
 			t.Assert(gstr.Contains(metricsContent, line), true)
 		}
 	})
diff --git a/contrib/metric/otelmetric/testdata/http.prometheus.metrics.txt b/contrib/metric/otelmetric/testdata/http.prometheus.metrics.txt
index 60d51c0d5..db4c828de 100644
--- a/contrib/metric/otelmetric/testdata/http.prometheus.metrics.txt
+++ b/contrib/metric/otelmetric/testdata/http.prometheus.metrics.txt
@@ -1,141 +1,141 @@
 
 # HELP http_client_connection_duration Measures the connection establish duration of client requests.
 # TYPE http_client_connection_duration histogram
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="1"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="5"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="10"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="25"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="50"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="75"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="100"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="250"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="500"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="750"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="1000"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="2500"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="5000"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="7500"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="10000"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="30000"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="60000"}
-http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="+Inf"}
-http_client_connection_duration_sum{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730"}
-http_client_connection_duration_count{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730"} 9
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="1"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="5"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="10"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="25"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="50"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="75"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="100"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="250"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="500"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="750"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="1000"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="2500"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="5000"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="7500"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="10000"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="30000"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="60000"}
+http_client_connection_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="+Inf"}
+http_client_connection_duration_sum{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730"}
+http_client_connection_duration_count{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730"} 9
 # HELP http_client_request_active Number of active client requests.
 # TYPE http_client_request_active gauge
-http_client_request_active{http_request_method="DELETE",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_client_request_active{http_request_method="GET",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
-http_client_request_active{http_request_method="POST",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_client_request_active{http_request_method="PUT",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_client_request_active{http_request_method="DELETE",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_client_request_active{http_request_method="GET",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
+http_client_request_active{http_request_method="POST",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_client_request_active{http_request_method="PUT",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
 # HELP http_client_request_body_size Outgoing request bytes total.
 # TYPE http_client_request_body_size counter
-http_client_request_body_size{http_request_method="POST",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 7
-http_client_request_body_size{http_request_method="PUT",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 7
+http_client_request_body_size{http_request_method="POST",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 7
+http_client_request_body_size{http_request_method="PUT",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 7
 # HELP http_client_request_duration Measures the duration of client requests.
 # TYPE http_client_request_duration histogram
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="1"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="5"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="10"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="25"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="50"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="75"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="100"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="250"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="500"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="750"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="1000"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="2500"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="5000"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="7500"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="10000"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="30000"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="60000"}
-http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="+Inf"}
-http_client_request_duration_sum{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730"}
-http_client_request_duration_count{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730"} 8
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="1"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="5"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="10"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="25"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="50"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="75"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="100"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="250"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="500"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="750"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="1000"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="2500"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="5000"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="7500"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="10000"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="30000"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="60000"}
+http_client_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="+Inf"}
+http_client_request_duration_sum{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730"}
+http_client_request_duration_count{otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730"} 8
 # HELP http_client_request_duration_total Total execution duration of request.
 # TYPE http_client_request_duration_total counter
-http_client_request_duration_total{http_request_method="DELETE",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
-http_client_request_duration_total{http_request_method="GET",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
-http_client_request_duration_total{http_request_method="POST",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
-http_client_request_duration_total{http_request_method="PUT",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
+http_client_request_duration_total{http_request_method="DELETE",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
+http_client_request_duration_total{http_request_method="GET",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
+http_client_request_duration_total{http_request_method="POST",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
+http_client_request_duration_total{http_request_method="PUT",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
 # HELP http_client_request_total Total processed request number.
 # TYPE http_client_request_total counter
-http_client_request_total{http_request_method="DELETE",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 2
-http_client_request_total{http_request_method="GET",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 2
-http_client_request_total{http_request_method="POST",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 2
-http_client_request_total{http_request_method="PUT",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 2
+http_client_request_total{http_request_method="DELETE",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 2
+http_client_request_total{http_request_method="GET",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 2
+http_client_request_total{http_request_method="POST",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 2
+http_client_request_total{http_request_method="PUT",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/gclient.Client",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 2
 # HELP http_server_request_active Number of active server requests.
 # TYPE http_server_request_active gauge
-http_server_request_active{http_request_method="DELETE",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_server_request_active{http_request_method="DELETE",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_server_request_active{http_request_method="GET",http_route="/metrics",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
-http_server_request_active{http_request_method="GET",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_server_request_active{http_request_method="GET",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_server_request_active{http_request_method="POST",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_server_request_active{http_request_method="POST",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_server_request_active{http_request_method="PUT",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_server_request_active{http_request_method="PUT",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_active{http_request_method="DELETE",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_active{http_request_method="DELETE",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_active{http_request_method="GET",http_route="/metrics",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
+http_server_request_active{http_request_method="GET",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_active{http_request_method="GET",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_active{http_request_method="POST",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_active{http_request_method="POST",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_active{http_request_method="PUT",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_active{http_request_method="PUT",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
 # HELP http_server_request_body_size Incoming request bytes total.
 # TYPE http_server_request_body_size counter
-http_server_request_body_size{http_request_method="DELETE",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_server_request_body_size{http_request_method="DELETE",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_server_request_body_size{http_request_method="GET",http_route="/metrics",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_server_request_body_size{http_request_method="GET",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_server_request_body_size{http_request_method="GET",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
-http_server_request_body_size{http_request_method="POST",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 4
-http_server_request_body_size{http_request_method="POST",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 3
-http_server_request_body_size{http_request_method="PUT",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 4
-http_server_request_body_size{http_request_method="PUT",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 3
+http_server_request_body_size{http_request_method="DELETE",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_body_size{http_request_method="DELETE",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_body_size{http_request_method="GET",http_route="/metrics",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_body_size{http_request_method="GET",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_body_size{http_request_method="GET",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 0
+http_server_request_body_size{http_request_method="POST",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 4
+http_server_request_body_size{http_request_method="POST",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 3
+http_server_request_body_size{http_request_method="PUT",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 4
+http_server_request_body_size{http_request_method="PUT",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 3
 # HELP http_server_request_duration Measures the duration of inbound request.
 # TYPE http_server_request_duration histogram
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="1"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="5"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="10"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="25"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="50"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="75"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="100"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="250"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="500"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="750"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="1000"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="2500"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="5000"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="7500"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="10000"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="30000"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="60000"}
-http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="+Inf"}
-http_server_request_duration_sum{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730"}
-http_server_request_duration_count{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="1"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="5"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="10"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="25"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="50"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="75"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="100"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="250"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="500"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="750"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="1000"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="2500"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="5000"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="7500"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="10000"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="30000"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="60000"}
+http_server_request_duration_bucket{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",le="+Inf"}
+http_server_request_duration_sum{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730"}
+http_server_request_duration_count{otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730"}
 # HELP http_server_request_duration_total Total execution duration of request.
 # TYPE http_server_request_duration_total counter
-http_server_request_duration_total{error_code="0",http_request_method="DELETE",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
-http_server_request_duration_total{error_code="0",http_request_method="DELETE",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
-http_server_request_duration_total{error_code="0",http_request_method="GET",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
-http_server_request_duration_total{error_code="0",http_request_method="GET",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
-http_server_request_duration_total{error_code="0",http_request_method="POST",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
-http_server_request_duration_total{error_code="0",http_request_method="POST",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
-http_server_request_duration_total{error_code="0",http_request_method="PUT",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
-http_server_request_duration_total{error_code="0",http_request_method="PUT",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
+http_server_request_duration_total{error_code="0",http_request_method="DELETE",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
+http_server_request_duration_total{error_code="0",http_request_method="DELETE",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
+http_server_request_duration_total{error_code="0",http_request_method="GET",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
+http_server_request_duration_total{error_code="0",http_request_method="GET",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
+http_server_request_duration_total{error_code="0",http_request_method="POST",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
+http_server_request_duration_total{error_code="0",http_request_method="POST",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
+http_server_request_duration_total{error_code="0",http_request_method="PUT",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
+http_server_request_duration_total{error_code="0",http_request_method="PUT",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"}
 # HELP http_server_request_total Total processed request number.
 # TYPE http_server_request_total counter
-http_server_request_total{error_code="0",http_request_method="DELETE",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
-http_server_request_total{error_code="0",http_request_method="DELETE",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
-http_server_request_total{error_code="0",http_request_method="GET",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
-http_server_request_total{error_code="0",http_request_method="GET",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
-http_server_request_total{error_code="0",http_request_method="POST",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
-http_server_request_total{error_code="0",http_request_method="POST",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
-http_server_request_total{error_code="0",http_request_method="PUT",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
-http_server_request_total{error_code="0",http_request_method="PUT",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
+http_server_request_total{error_code="0",http_request_method="DELETE",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
+http_server_request_total{error_code="0",http_request_method="DELETE",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
+http_server_request_total{error_code="0",http_request_method="GET",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
+http_server_request_total{error_code="0",http_request_method="GET",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
+http_server_request_total{error_code="0",http_request_method="POST",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
+http_server_request_total{error_code="0",http_request_method="POST",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
+http_server_request_total{error_code="0",http_request_method="PUT",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
+http_server_request_total{error_code="0",http_request_method="PUT",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 1
 # HELP http_server_response_body_size Response bytes total.
 # TYPE http_server_response_body_size counter
-http_server_response_body_size{error_code="0",http_request_method="DELETE",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 5
-http_server_response_body_size{error_code="0",http_request_method="DELETE",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 4
-http_server_response_body_size{error_code="0",http_request_method="GET",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 5
-http_server_response_body_size{error_code="0",http_request_method="GET",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 4
-http_server_response_body_size{error_code="0",http_request_method="POST",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 5
-http_server_response_body_size{error_code="0",http_request_method="POST",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 4
-http_server_response_body_size{error_code="0",http_request_method="PUT",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 5
-http_server_response_body_size{error_code="0",http_request_method="PUT",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 4
+http_server_response_body_size{error_code="0",http_request_method="DELETE",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 5
+http_server_response_body_size{error_code="0",http_request_method="DELETE",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 4
+http_server_response_body_size{error_code="0",http_request_method="GET",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 5
+http_server_response_body_size{error_code="0",http_request_method="GET",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 4
+http_server_response_body_size{error_code="0",http_request_method="POST",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 5
+http_server_response_body_size{error_code="0",http_request_method="POST",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 4
+http_server_response_body_size{error_code="0",http_request_method="PUT",http_response_status_code="200",http_route="/order/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 5
+http_server_response_body_size{error_code="0",http_request_method="PUT",http_response_status_code="200",http_route="/user/:id",network_protocol_version="1.1",otel_scope_name="github.com/gogf/gf/v2/net/ghttp.Server",otel_scope_schema_url="",otel_scope_version="v2.6.4",server_address="127.0.0.1",server_port="62730",url_schema="http"} 4
diff --git a/contrib/nosql/redis/go.mod b/contrib/nosql/redis/go.mod
index f45516ce9..86136d113 100644
--- a/contrib/nosql/redis/go.mod
+++ b/contrib/nosql/redis/go.mod
@@ -3,10 +3,10 @@ module github.com/gogf/gf/contrib/nosql/redis/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 	github.com/redis/go-redis/v9 v9.12.1
-	go.opentelemetry.io/otel v1.37.0
-	go.opentelemetry.io/otel/trace v1.37.0
+	go.opentelemetry.io/otel v1.38.0
+	go.opentelemetry.io/otel/trace v1.38.0
 )
 
 require (
@@ -14,7 +14,7 @@ require (
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -23,19 +23,19 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/nosql/redis/go.sum b/contrib/nosql/redis/go.sum
index 454242f8d..17f1862db 100644
--- a/contrib/nosql/redis/go.sum
+++ b/contrib/nosql/redis/go.sum
@@ -12,8 +12,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -37,8 +37,9 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -47,38 +48,40 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/redis/go-redis/v9 v9.12.1 h1:k5iquqv27aBtnTm2tIkROUDp8JBXhXZIVu1InSgvovg=
 github.com/redis/go-redis/v9 v9.12.1/go.mod h1:huWgSWd8mW6+m0VPhJjSSQ+d6Nh1VICQ6Q5lHuCH/Iw=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/contrib/registry/consul/go.mod b/contrib/registry/consul/go.mod
index 65307cec6..54dc594cd 100644
--- a/contrib/registry/consul/go.mod
+++ b/contrib/registry/consul/go.mod
@@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/registry/consul/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 	github.com/hashicorp/consul/api v1.26.1
 )
 
@@ -11,7 +11,7 @@ require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/armon/go-metrics v0.4.1 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -26,18 +26,18 @@ require (
 	github.com/hashicorp/golang-lru v0.5.4 // indirect
 	github.com/hashicorp/serf v0.10.1 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
 	golang.org/x/exp v0.0.0-20230817173708-d852ddb80c63 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/registry/consul/go.sum b/contrib/registry/consul/go.sum
index 7d019b92d..562a731e9 100644
--- a/contrib/registry/consul/go.sum
+++ b/contrib/registry/consul/go.sum
@@ -24,8 +24,8 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
 github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
@@ -124,13 +124,14 @@ github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVc
 github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -154,8 +155,8 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0MwY=
 github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
@@ -179,10 +180,10 @@ github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8b
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 h1:nn5Wsu0esKSJiIVhscUtVbo7ada43DJhG55ua/hjS5I=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
@@ -196,19 +197,21 @@ github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXf
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
@@ -223,8 +226,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -249,6 +252,7 @@ golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
@@ -257,8 +261,8 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 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.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/contrib/registry/etcd/go.mod b/contrib/registry/etcd/go.mod
index c71220a79..19c03a35e 100644
--- 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.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 	go.etcd.io/etcd/client/v3 v3.5.17
 	google.golang.org/grpc v1.59.0
 )
@@ -13,7 +13,7 @@ require (
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
 	github.com/coreos/go-semver v0.3.0 // indirect
 	github.com/coreos/go-systemd/v22 v22.3.2 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -24,30 +24,30 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.etcd.io/etcd/api/v3 v3.5.17 // indirect
 	go.etcd.io/etcd/client/pkg/v3 v3.5.17 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
 	go.uber.org/atomic v1.7.0 // indirect
 	go.uber.org/multierr v1.6.0 // indirect
-	go.uber.org/zap v1.21.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.uber.org/zap v1.17.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	google.golang.org/genproto v0.0.0-20230822172742-b8732ec3820d // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20230822172742-b8732ec3820d // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d // indirect
-	google.golang.org/protobuf v1.34.2 // indirect
+	google.golang.org/protobuf v1.33.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/registry/etcd/go.sum b/contrib/registry/etcd/go.sum
index 5c3624741..b7e4998dc 100644
--- a/contrib/registry/etcd/go.sum
+++ b/contrib/registry/etcd/go.sum
@@ -1,7 +1,5 @@
 github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
 github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
-github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
-github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
 github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyME=
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/coreos/go-semver v0.3.0 h1:wkHLiw0WNATZnSG7epLsujiMCgPAc9xhjJ4tgnAxmfM=
@@ -11,8 +9,8 @@ github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSV
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -37,17 +35,15 @@ github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtg
 github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -56,25 +52,23 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 go.etcd.io/etcd/api/v3 v3.5.17 h1:cQB8eb8bxwuxOilBpMJAEo8fAONyrdXTHUNcMd8yT1w=
 go.etcd.io/etcd/api/v3 v3.5.17/go.mod h1:d1hvkRuXkts6PmaYk2Vrgqbv7H4ADfAKhyJqHNLJCB4=
 go.etcd.io/etcd/client/pkg/v3 v3.5.17 h1:XxnDXAWq2pnxqx76ljWwiQ9jylbpC4rvkAeRVOUKKVw=
@@ -83,62 +77,53 @@ go.etcd.io/etcd/client/v3 v3.5.17 h1:o48sINNeWz5+pjy/Z0+HKpj/xSnBkuVhVvXkjEXbqZY
 go.etcd.io/etcd/client/v3 v3.5.17/go.mod h1:j2d4eXTHWkT2ClBgnnEPm/Wuu7jsqku41v9DZ3OtjQo=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
-go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4=
 go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
-go.uber.org/zap v1.21.0 h1:WefMeulhovoZ2sYXz7st6K0sLj7bBhpiFaud4r4zST8=
-go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw=
+go.uber.org/zap v1.17.0 h1:MTjgFu6ZLKvY6Pvaqk97GlxNBuMpV4Hy/3P6tRGlI2U=
+go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-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.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 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=
@@ -151,10 +136,9 @@ google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d h1:
 google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d/go.mod h1:+Bk1OCOj40wS2hwAMA+aCW9ypzm63QTBBHp6lQ3p+9M=
 google.golang.org/grpc v1.59.0 h1:Z5Iec2pjwb+LEOqzpB2MR12/eKFhDPhuqW91O+4bwUk=
 google.golang.org/grpc v1.59.0/go.mod h1:aUPDwccQo6OTjy7Hct4AfBPD1GptF4fyUjIkQ9YtF98=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/contrib/registry/file/go.mod b/contrib/registry/file/go.mod
index 0076c980c..e30d05b7f 100644
--- a/contrib/registry/file/go.mod
+++ b/contrib/registry/file/go.mod
@@ -2,12 +2,12 @@ module github.com/gogf/gf/contrib/registry/file/v2
 
 go 1.23.0
 
-require github.com/gogf/gf/v2 v2.9.3
+require github.com/gogf/gf/v2 v2.9.8
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -16,21 +16,21 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/registry/file/go.sum b/contrib/registry/file/go.sum
index e58d3957d..0718fa9fe 100644
--- a/contrib/registry/file/go.sum
+++ b/contrib/registry/file/go.sum
@@ -4,8 +4,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -29,8 +29,9 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -39,36 +40,38 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/contrib/registry/nacos/README.MD b/contrib/registry/nacos/README.MD
index 6c76a77d1..51ec11143 100644
--- a/contrib/registry/nacos/README.MD
+++ b/contrib/registry/nacos/README.MD
@@ -1,24 +1,25 @@
 # GoFrame Nacos Registry
 
-
 Use `nacos` as service registration and discovery management.
 
-
 ## Installation
+
 ```
 go get -u -v github.com/gogf/gf/contrib/registry/nacos/v2
 ```
+
 suggested using `go.mod`:
+
 ```
 require github.com/gogf/gf/contrib/registry/nacos/v2 latest
 ```
 
-
 ## Example
 
 ### Reference example
 
 [server](../../../example/registry/nacos/http/server/main.go)
+
 ```go
 package main
 
@@ -44,6 +45,7 @@ func main() {
 ```
 
 [client](../../../example/registry/nacos/http/client/main.go)
+
 ```go
 package main
 
@@ -78,4 +80,3 @@ func main() {
 ## License
 
 `GoFrame Nacos` is licensed under the [MIT License](../../../LICENSE), 100% free and open-source, forever.
-
diff --git a/contrib/registry/nacos/go.mod b/contrib/registry/nacos/go.mod
index b252cddfe..81afa3eba 100644
--- a/contrib/registry/nacos/go.mod
+++ b/contrib/registry/nacos/go.mod
@@ -3,23 +3,39 @@ module github.com/gogf/gf/contrib/registry/nacos/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.2
-	github.com/nacos-group/nacos-sdk-go/v2 v2.2.7
+	github.com/gogf/gf/v2 v2.9.8
+	github.com/nacos-group/nacos-sdk-go/v2 v2.3.5
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
-	github.com/alibabacloud-go/debug v0.0.0-20190504072949-9472017b5c68 // indirect
-	github.com/alibabacloud-go/tea v1.1.17 // indirect
+	github.com/alibabacloud-go/alibabacloud-gateway-pop v0.0.6 // indirect
+	github.com/alibabacloud-go/alibabacloud-gateway-spi v0.0.5 // indirect
+	github.com/alibabacloud-go/darabonba-array v0.1.0 // indirect
+	github.com/alibabacloud-go/darabonba-encode-util v0.0.2 // indirect
+	github.com/alibabacloud-go/darabonba-map v0.0.2 // indirect
+	github.com/alibabacloud-go/darabonba-openapi/v2 v2.0.10 // indirect
+	github.com/alibabacloud-go/darabonba-signature-util v0.0.7 // indirect
+	github.com/alibabacloud-go/darabonba-string v1.0.2 // indirect
+	github.com/alibabacloud-go/debug v1.0.1 // indirect
+	github.com/alibabacloud-go/endpoint-util v1.1.0 // indirect
+	github.com/alibabacloud-go/kms-20160120/v3 v3.2.3 // indirect
+	github.com/alibabacloud-go/openapi-util v0.1.0 // indirect
+	github.com/alibabacloud-go/tea v1.2.2 // indirect
 	github.com/alibabacloud-go/tea-utils v1.4.4 // indirect
+	github.com/alibabacloud-go/tea-utils/v2 v2.0.7 // indirect
+	github.com/alibabacloud-go/tea-xml v1.1.3 // indirect
 	github.com/aliyun/alibaba-cloud-sdk-go v1.61.1800 // indirect
-	github.com/aliyun/alibabacloud-dkms-gcs-go-sdk v0.2.2 // indirect
-	github.com/aliyun/alibabacloud-dkms-transfer-go-sdk v0.1.7 // indirect
+	github.com/aliyun/alibabacloud-dkms-gcs-go-sdk v0.5.1 // indirect
+	github.com/aliyun/alibabacloud-dkms-transfer-go-sdk v0.1.8 // indirect
+	github.com/aliyun/aliyun-secretsmanager-client-go v1.1.5 // indirect
+	github.com/aliyun/credentials-go v1.4.3 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/buger/jsonparser v1.1.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/deckarep/golang-set v1.7.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -32,39 +48,41 @@ require (
 	github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/orcaman/concurrent-map v0.0.0-20210501183033-44dafcb38ecc // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/prometheus/client_golang v1.19.1 // indirect
-	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.55.0 // indirect
-	github.com/prometheus/procfs v0.15.1 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/prometheus/client_golang v1.12.2 // indirect
+	github.com/prometheus/client_model v0.2.0 // indirect
+	github.com/prometheus/common v0.32.1 // indirect
+	github.com/prometheus/procfs v0.7.3 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
+	github.com/tjfoc/gmsm v1.4.1 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
 	go.uber.org/atomic v1.7.0 // indirect
 	go.uber.org/multierr v1.6.0 // indirect
 	go.uber.org/zap v1.21.0 // indirect
-	golang.org/x/crypto v0.41.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
-	golang.org/x/sync v0.16.0 // indirect
+	golang.org/x/crypto v0.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/sync v0.14.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	golang.org/x/time v0.1.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d // indirect
-	google.golang.org/grpc v1.59.0 // indirect
-	google.golang.org/protobuf v1.34.2 // indirect
-	gopkg.in/ini.v1 v1.66.2 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 // indirect
+	google.golang.org/grpc v1.67.3 // indirect
+	google.golang.org/protobuf v1.36.5 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/contrib/registry/nacos/go.sum b/contrib/registry/nacos/go.sum
index 620cad6a5..b34fac2f6 100644
--- a/contrib/registry/nacos/go.sum
+++ b/contrib/registry/nacos/go.sum
@@ -1,65 +1,245 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
+cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
+cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
+cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
+cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
+cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
+cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
+cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
+cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
+cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
+cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
+cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
+cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
+cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
+cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
 github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
-github.com/alibabacloud-go/debug v0.0.0-20190504072949-9472017b5c68 h1:NqugFkGxx1TXSh/pBcU00Y6bljgDPaFdh5MUSeJ7e50=
+github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
+github.com/alibabacloud-go/alibabacloud-gateway-pop v0.0.6 h1:eIf+iGJxdU4U9ypaUfbtOWCsZSbTb8AUHvyPrxu6mAA=
+github.com/alibabacloud-go/alibabacloud-gateway-pop v0.0.6/go.mod h1:4EUIoxs/do24zMOGGqYVWgw0s9NtiylnJglOeEB5UJo=
+github.com/alibabacloud-go/alibabacloud-gateway-spi v0.0.4/go.mod h1:sCavSAvdzOjul4cEqeVtvlSaSScfNsTQ+46HwlTL1hc=
+github.com/alibabacloud-go/alibabacloud-gateway-spi v0.0.5 h1:zE8vH9C7JiZLNJJQ5OwjU9mSi4T9ef9u3BURT6LCLC8=
+github.com/alibabacloud-go/alibabacloud-gateway-spi v0.0.5/go.mod h1:tWnyE9AjF8J8qqLk645oUmVUnFybApTQWklQmi5tY6g=
+github.com/alibabacloud-go/darabonba-array v0.1.0 h1:vR8s7b1fWAQIjEjWnuF0JiKsCvclSRTfDzZHTYqfufY=
+github.com/alibabacloud-go/darabonba-array v0.1.0/go.mod h1:BLKxr0brnggqOJPqT09DFJ8g3fsDshapUD3C3aOEFaI=
+github.com/alibabacloud-go/darabonba-encode-util v0.0.2 h1:1uJGrbsGEVqWcWxrS9MyC2NG0Ax+GpOM5gtupki31XE=
+github.com/alibabacloud-go/darabonba-encode-util v0.0.2/go.mod h1:JiW9higWHYXm7F4PKuMgEUETNZasrDM6vqVr/Can7H8=
+github.com/alibabacloud-go/darabonba-map v0.0.2 h1:qvPnGB4+dJbJIxOOfawxzF3hzMnIpjmafa0qOTp6udc=
+github.com/alibabacloud-go/darabonba-map v0.0.2/go.mod h1:28AJaX8FOE/ym8OUFWga+MtEzBunJwQGceGQlvaPGPc=
+github.com/alibabacloud-go/darabonba-openapi/v2 v2.0.9/go.mod h1:bb+Io8Sn2RuM3/Rpme6ll86jMyFSrD1bxeV/+v61KeU=
+github.com/alibabacloud-go/darabonba-openapi/v2 v2.0.10 h1:GEYkMApgpKEVDn6z12DcH1EGYpDYRB8JxsazM4Rywak=
+github.com/alibabacloud-go/darabonba-openapi/v2 v2.0.10/go.mod h1:26a14FGhZVELuz2cc2AolvW4RHmIO3/HRwsdHhaIPDE=
+github.com/alibabacloud-go/darabonba-signature-util v0.0.7 h1:UzCnKvsjPFzApvODDNEYqBHMFt1w98wC7FOo0InLyxg=
+github.com/alibabacloud-go/darabonba-signature-util v0.0.7/go.mod h1:oUzCYV2fcCH797xKdL6BDH8ADIHlzrtKVjeRtunBNTQ=
+github.com/alibabacloud-go/darabonba-string v1.0.2 h1:E714wms5ibdzCqGeYJ9JCFywE5nDyvIXIIQbZVFkkqo=
+github.com/alibabacloud-go/darabonba-string v1.0.2/go.mod h1:93cTfV3vuPhhEwGGpKKqhVW4jLe7tDpo3LUM0i0g6mA=
 github.com/alibabacloud-go/debug v0.0.0-20190504072949-9472017b5c68/go.mod h1:6pb/Qy8c+lqua8cFpEy7g39NRRqOWc3rOwAy8m5Y2BY=
+github.com/alibabacloud-go/debug v1.0.0/go.mod h1:8gfgZCCAC3+SCzjWtY053FrOcd4/qlH6IHTI4QyICOc=
+github.com/alibabacloud-go/debug v1.0.1 h1:MsW9SmUtbb1Fnt3ieC6NNZi6aEwrXfDksD4QA6GSbPg=
+github.com/alibabacloud-go/debug v1.0.1/go.mod h1:8gfgZCCAC3+SCzjWtY053FrOcd4/qlH6IHTI4QyICOc=
+github.com/alibabacloud-go/endpoint-util v1.1.0 h1:r/4D3VSw888XGaeNpP994zDUaxdgTSHBbVfZlzf6b5Q=
+github.com/alibabacloud-go/endpoint-util v1.1.0/go.mod h1:O5FuCALmCKs2Ff7JFJMudHs0I5EBgecXXxZRyswlEjE=
+github.com/alibabacloud-go/kms-20160120/v3 v3.2.3 h1:vamGcYQFwXVqR6RWcrVTTqlIXZVsYjaA7pZbx+Xw6zw=
+github.com/alibabacloud-go/kms-20160120/v3 v3.2.3/go.mod h1:3rIyughsFDLie1ut9gQJXkWkMg/NfXBCk+OtXnPu3lw=
+github.com/alibabacloud-go/openapi-util v0.1.0 h1:0z75cIULkDrdEhkLWgi9tnLe+KhAFE/r5Pb3312/eAY=
+github.com/alibabacloud-go/openapi-util v0.1.0/go.mod h1:sQuElr4ywwFRlCCberQwKRFhRzIyG4QTP/P4y1CJ6Ws=
 github.com/alibabacloud-go/tea v1.1.0/go.mod h1:IkGyUSX4Ba1V+k4pCtJUc6jDpZLFph9QMy2VUPTwukg=
-github.com/alibabacloud-go/tea v1.1.17 h1:05R5DnaJXe9sCNIe8KUgWHC/z6w/VZIwczgUwzRnul8=
+github.com/alibabacloud-go/tea v1.1.7/go.mod h1:/tmnEaQMyb4Ky1/5D+SE1BAsa5zj/KeGOFfwYm3N/p4=
+github.com/alibabacloud-go/tea v1.1.8/go.mod h1:/tmnEaQMyb4Ky1/5D+SE1BAsa5zj/KeGOFfwYm3N/p4=
+github.com/alibabacloud-go/tea v1.1.11/go.mod h1:/tmnEaQMyb4Ky1/5D+SE1BAsa5zj/KeGOFfwYm3N/p4=
 github.com/alibabacloud-go/tea v1.1.17/go.mod h1:nXxjm6CIFkBhwW4FQkNrolwbfon8Svy6cujmKFUq98A=
+github.com/alibabacloud-go/tea v1.1.20/go.mod h1:nXxjm6CIFkBhwW4FQkNrolwbfon8Svy6cujmKFUq98A=
+github.com/alibabacloud-go/tea v1.2.1/go.mod h1:qbzof29bM/IFhLMtJPrgTGK3eauV5J2wSyEUo4OEmnA=
+github.com/alibabacloud-go/tea v1.2.2 h1:aTsR6Rl3ANWPfqeQugPglfurloyBJY85eFy7Gc1+8oU=
+github.com/alibabacloud-go/tea v1.2.2/go.mod h1:CF3vOzEMAG+bR4WOql8gc2G9H3EkH3ZLAQdpmpXMgwk=
+github.com/alibabacloud-go/tea-utils v1.3.1/go.mod h1:EI/o33aBfj3hETm4RLiAxF/ThQdSngxrpF8rKUDJjPE=
 github.com/alibabacloud-go/tea-utils v1.4.4 h1:lxCDvNCdTo9FaXKKq45+4vGETQUKNOW/qKTcX9Sk53o=
 github.com/alibabacloud-go/tea-utils v1.4.4/go.mod h1:KNcT0oXlZZxOXINnZBs6YvgOd5aYp9U67G+E3R8fcQw=
+github.com/alibabacloud-go/tea-utils/v2 v2.0.3/go.mod h1:sj1PbjPodAVTqGTA3olprfeeqqmwD0A5OQz94o9EuXQ=
+github.com/alibabacloud-go/tea-utils/v2 v2.0.5/go.mod h1:dL6vbUT35E4F4bFTHL845eUloqaerYBYPsdWR2/jhe4=
+github.com/alibabacloud-go/tea-utils/v2 v2.0.6/go.mod h1:qxn986l+q33J5VkialKMqT/TTs3E+U9MJpd001iWQ9I=
+github.com/alibabacloud-go/tea-utils/v2 v2.0.7 h1:WDx5qW3Xa5ZgJ1c8NfqJkF6w+AU5wB8835UdhPr6Ax0=
+github.com/alibabacloud-go/tea-utils/v2 v2.0.7/go.mod h1:qxn986l+q33J5VkialKMqT/TTs3E+U9MJpd001iWQ9I=
+github.com/alibabacloud-go/tea-xml v1.1.3 h1:7LYnm+JbOq2B+T/B0fHC4Ies4/FofC4zHzYtqw7dgt0=
+github.com/alibabacloud-go/tea-xml v1.1.3/go.mod h1:Rq08vgCcCAjHyRi/M7xlHKUykZCEtyBy9+DPF6GgEu8=
 github.com/aliyun/alibaba-cloud-sdk-go v1.61.1800 h1:ie/8RxBOfKZWcrbYSJi2Z8uX8TcOlSMwPlEJh83OeOw=
 github.com/aliyun/alibaba-cloud-sdk-go v1.61.1800/go.mod h1:RcDobYh8k5VP6TNybz9m++gL3ijVI5wueVr0EM10VsU=
-github.com/aliyun/alibabacloud-dkms-gcs-go-sdk v0.2.2 h1:rWkH6D2XlXb/Y+tNAQROxBzp3a0p92ni+pXcaHBe/WI=
-github.com/aliyun/alibabacloud-dkms-gcs-go-sdk v0.2.2/go.mod h1:GDtq+Kw+v0fO+j5BrrWiUHbBq7L+hfpzpPfXKOZMFE0=
-github.com/aliyun/alibabacloud-dkms-transfer-go-sdk v0.1.7 h1:olLiPI2iM8Hqq6vKnSxpM3awCrm9/BeOgHpzQkOYnI4=
-github.com/aliyun/alibabacloud-dkms-transfer-go-sdk v0.1.7/go.mod h1:oDg1j4kFxnhgftaiLJABkGeSvuEvSF5Lo6UmRAMruX4=
+github.com/aliyun/alibabacloud-dkms-gcs-go-sdk v0.5.1 h1:nJYyoFP+aqGKgPs9JeZgS1rWQ4NndNR0Zfhh161ZltU=
+github.com/aliyun/alibabacloud-dkms-gcs-go-sdk v0.5.1/go.mod h1:WzGOmFFTlUzXM03CJnHWMQ85UN6QGpOXZocCjwkiyOg=
+github.com/aliyun/alibabacloud-dkms-transfer-go-sdk v0.1.8 h1:QeUdR7JF7iNCvO/81EhxEr3wDwxk4YBoYZOq6E0AjHI=
+github.com/aliyun/alibabacloud-dkms-transfer-go-sdk v0.1.8/go.mod h1:xP0KIZry6i7oGPF24vhAPr1Q8vLZRcMcxtft5xDKwCU=
+github.com/aliyun/aliyun-secretsmanager-client-go v1.1.5 h1:8S0mtD101RDYa0LXwdoqgN0RxdMmmJYjq8g2mk7/lQ4=
+github.com/aliyun/aliyun-secretsmanager-client-go v1.1.5/go.mod h1:M19fxYz3gpm0ETnoKweYyYtqrtnVtrpKFpwsghbw+cQ=
+github.com/aliyun/credentials-go v1.1.2/go.mod h1:ozcZaMR5kLM7pwtCMEpVmQ242suV6qTJya2bDq4X1Tw=
+github.com/aliyun/credentials-go v1.3.1/go.mod h1:8jKYhQuDawt8x2+fusqa1Y6mPxemTsBEN04dgcAcYz0=
+github.com/aliyun/credentials-go v1.3.6/go.mod h1:1LxUuX7L5YrZUWzBrRyk0SwSdH4OmPrib8NVePL3fxM=
+github.com/aliyun/credentials-go v1.3.10/go.mod h1:Jm6d+xIgwJVLVWT561vy67ZRP4lPTQxMbEYRuT2Ti1U=
+github.com/aliyun/credentials-go v1.4.3 h1:N3iHyvHRMyOwY1+0qBLSf3hb5JFiOujVSVuEpgeGttY=
+github.com/aliyun/credentials-go v1.4.3/go.mod h1:Jm6d+xIgwJVLVWT561vy67ZRP4lPTQxMbEYRuT2Ti1U=
 github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
 github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
 github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/clbanning/mxj/v2 v2.5.5/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyME=
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/deckarep/golang-set v1.7.1 h1:SCQV0S6gTtp6itiFrTqI+pfmJ4LN85S1YzhDf9rTHJQ=
+github.com/deckarep/golang-set v1.7.1/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
 github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
 github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/goji/httpauth v0.0.0-20160601135302-2da839ab0f4d/go.mod h1:nnjvkQ9ptGaCkuDUx6wNykzzlUixGxvkme+H/lnzb+A=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
 github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
 github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gopherjs/gopherjs v0.0.0-20200217142428-fce0ec30dd00/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtgzltlQbOBae4=
 github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af h1:pmfjZENx5imkbgOkpRUYLnmbU7UEFbjtDA2hxJ1ichM=
 github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
 github.com/json-iterator/go v1.1.5/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
@@ -69,12 +249,15 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -82,51 +265,95 @@ github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lN
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
-github.com/nacos-group/nacos-sdk-go/v2 v2.2.7 h1:wCC1f3/VzIR1WD30YKeJGZAOchYCK/35mLC8qWt6Q6o=
-github.com/nacos-group/nacos-sdk-go/v2 v2.2.7/go.mod h1:VYlyDPlQchPC31PmfBustu81vsOkdpCuO5k0dRdQcFc=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/nacos-group/nacos-sdk-go/v2 v2.3.5 h1:Hux7C4N4rWhwBF5Zm4yyYskrs9VTgrRTA8DZjoEhQTs=
+github.com/nacos-group/nacos-sdk-go/v2 v2.3.5/go.mod h1:ygUBdt7eGeYBt6Lz2HO3wx7crKXk25Mp80568emGMWU=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/orcaman/concurrent-map v0.0.0-20210501183033-44dafcb38ecc h1:Ak86L+yDSOzKFa7WM5bf5itSOo1e3Xh8bm5YCMUXIjQ=
+github.com/orcaman/concurrent-map v0.0.0-20210501183033-44dafcb38ecc/go.mod h1:Lu3tH6HLW3feq74c2GC+jIMS/K2CFcDWnWD9XkenwhI=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 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/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
-github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
-github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
-github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
-github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=
-github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8=
-github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
-github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
+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=
+github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
+github.com/prometheus/client_golang v1.12.2 h1:51L9cDoUHVrXx4zWYlcLQIZ+d+VXHgqnYKkIuq4g/34=
+github.com/prometheus/client_golang v1.12.2/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
+github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
+github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
+github.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4=
+github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU=
+github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/assertions v1.1.0/go.mod h1:tcbTF8ujkAEcZ8TElKY+i30BzYlVhC/LOxJk7iOWnoo=
+github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/tjfoc/gmsm v1.3.2/go.mod h1:HaUcFuY0auTiaHB9MHFGCPx5IaLhTUd2atbCFBQXn9w=
+github.com/tjfoc/gmsm v1.4.1 h1:aMe1GlZb+0bLjn+cKTPEvvn9oUEBlJitaZiiBwsbgho=
+github.com/tjfoc/gmsm v1.4.1/go.mod h1:j4INPkHWMrhJb38G+J6W4Tw0AbuN8Thu3PbdVYhVcTE=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.30/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
@@ -136,70 +363,366 @@ go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4=
 go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
 go.uber.org/zap v1.21.0 h1:WefMeulhovoZ2sYXz7st6K0sLj7bBhpiFaud4r4zST8=
 go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191219195013-becbf705a915/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
-golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20201012173705-84dcc777aaee/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I=
+golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
+golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
+golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
+golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20201010224723-4f7140c49acb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.11.0/go.mod h1:2L/ixqYpgIVXmeoSA/4Lu7BzTG4KIyPIryS4IsOd1oQ=
+golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
+golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
-golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
+golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200509044756-6aff5f38e54f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.9.0/go.mod h1:M6DEAAIenWoTxdKrOltXcmDY3rSplQUkrvaDU5FcQyo=
+golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
+golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
+golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
+golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.1.0 h1:xYY+Bajn2a7VBmTM5GikTmnK8ZuX8YgnQCqZpbBNtmA=
 golang.org/x/time v0.1.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200509030707-2212a7e161a5/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
 golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d h1:uvYuEyMHKNt+lT4K3bN6fGswmK8qSvcreM3BwjDh+y4=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d/go.mod h1:+Bk1OCOj40wS2hwAMA+aCW9ypzm63QTBBHp6lQ3p+9M=
-google.golang.org/grpc v1.59.0 h1:Z5Iec2pjwb+LEOqzpB2MR12/eKFhDPhuqW91O+4bwUk=
-google.golang.org/grpc v1.59.0/go.mod h1:aUPDwccQo6OTjy7Hct4AfBPD1GptF4fyUjIkQ9YtF98=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
+google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
+google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 h1:e7S5W7MGGLaSu8j3YjdezkZ+m1/Nm0uRVRMEMGk26Xs=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.67.3 h1:OgPcDAFKHnH8X3O4WcO4XUc8GRDeKsKReqbQtiCj7N8=
+google.golang.org/grpc v1.67.3/go.mod h1:YGaHCc6Oap+FzBJTZLBzkGSYt/cvGPFTPxkn7QfSU8s=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=
+google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/ini.v1 v1.66.2 h1:XfR1dOYubytKy4Shzc2LHrrGhU0lDCfDGG1yLPmpgsI=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/ini.v1 v1.56.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/ini.v1 v1.66.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
+gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8=
 gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
diff --git a/contrib/registry/nacos/nacos.go b/contrib/registry/nacos/nacos.go
index 799db2a5d..bd5ecb6f5 100644
--- a/contrib/registry/nacos/nacos.go
+++ b/contrib/registry/nacos/nacos.go
@@ -34,9 +34,11 @@ var (
 
 // Registry is nacos registry.
 type Registry struct {
-	client      naming_client.INamingClient
-	clusterName string
-	groupName   string
+	client          naming_client.INamingClient
+	clusterName     string
+	groupName       string
+	defaultEndpoint string
+	defaultMetadata map[string]string
 }
 
 // Config is the configuration object for nacos client.
@@ -80,7 +82,7 @@ func New(address string, opts ...constant.ClientOption) (reg *Registry) {
 	return
 }
 
-// New creates and returns registry with Config.
+// NewWithConfig creates and returns registry with Config.
 func NewWithConfig(ctx context.Context, config Config) (reg *Registry, err error) {
 	// Data validation.
 	err = g.Validator().Data(config).Run(ctx)
@@ -101,9 +103,10 @@ func NewWithConfig(ctx context.Context, config Config) (reg *Registry, err error
 // NewWithClient new the instance with INamingClient
 func NewWithClient(client naming_client.INamingClient) *Registry {
 	r := &Registry{
-		client:      client,
-		clusterName: "DEFAULT",
-		groupName:   "DEFAULT_GROUP",
+		client:          client,
+		clusterName:     "DEFAULT",
+		groupName:       "DEFAULT_GROUP",
+		defaultMetadata: make(map[string]string),
 	}
 	return r
 }
@@ -119,3 +122,17 @@ func (reg *Registry) SetGroupName(groupName string) *Registry {
 	reg.groupName = groupName
 	return reg
 }
+
+// SetDefaultEndpoint sets the default endpoint for service registration.
+// It overrides the service endpoints when registering if it's not empty.
+func (reg *Registry) SetDefaultEndpoint(endpoint string) *Registry {
+	reg.defaultEndpoint = endpoint
+	return reg
+}
+
+// SetDefaultMetadata sets the default metadata for service registration.
+// It will be merged with service's original metadata when registering.
+func (reg *Registry) SetDefaultMetadata(metadata map[string]string) *Registry {
+	reg.defaultMetadata = metadata
+	return reg
+}
diff --git a/contrib/registry/nacos/nacos_discovery.go b/contrib/registry/nacos/nacos_discovery.go
index d9d1eecd9..5f16ced24 100644
--- a/contrib/registry/nacos/nacos_discovery.go
+++ b/contrib/registry/nacos/nacos_discovery.go
@@ -19,7 +19,7 @@ import (
 )
 
 // Search searches and returns services with specified condition.
-func (reg *Registry) Search(ctx context.Context, in gsvc.SearchInput) (result []gsvc.Service, err error) {
+func (reg *Registry) Search(_ context.Context, in gsvc.SearchInput) (result []gsvc.Service, err error) {
 	if in.Prefix == "" && in.Name != "" {
 		in.Prefix = gsvc.NewServiceWithName(in.Name).GetPrefix()
 	}
diff --git a/contrib/registry/nacos/nacos_register.go b/contrib/registry/nacos/nacos_register.go
index 0b94c97ce..1b36c8c7b 100644
--- a/contrib/registry/nacos/nacos_register.go
+++ b/contrib/registry/nacos/nacos_register.go
@@ -17,19 +17,31 @@ import (
 
 // Register registers `service` to Registry.
 // Note that it returns a new Service if it changes the input Service with custom one.
-func (reg *Registry) Register(ctx context.Context, service gsvc.Service) (registered gsvc.Service, err error) {
+func (reg *Registry) Register(_ context.Context, service gsvc.Service) (registered gsvc.Service, err error) {
 	metadata := map[string]string{}
 	endpoints := service.GetEndpoints()
+
+	// Apply default endpoint override if configured
+	if reg.defaultEndpoint != "" {
+		endpoints = gsvc.Endpoints{gsvc.NewEndpoint(reg.defaultEndpoint)}
+	}
+
 	p := vo.BatchRegisterInstanceParam{
 		ServiceName: service.GetName(),
 		GroupName:   reg.groupName,
 		Instances:   make([]vo.RegisterInstanceParam, 0, len(endpoints)),
 	}
 
+	// Copy service metadata
 	for k, v := range service.GetMetadata() {
 		metadata[k] = gconv.String(v)
 	}
 
+	// Apply default metadata if configured
+	for k, v := range reg.defaultMetadata {
+		metadata[k] = v
+	}
+
 	for _, endpoint := range endpoints {
 		p.Instances = append(p.Instances, vo.RegisterInstanceParam{
 			Ip:          endpoint.Host(),
@@ -55,7 +67,7 @@ func (reg *Registry) Register(ctx context.Context, service gsvc.Service) (regist
 }
 
 // Deregister off-lines and removes `service` from the Registry.
-func (reg *Registry) Deregister(ctx context.Context, service gsvc.Service) (err error) {
+func (reg *Registry) Deregister(_ context.Context, service gsvc.Service) (err error) {
 	c := reg.client
 
 	for _, endpoint := range service.GetEndpoints() {
diff --git a/contrib/registry/polaris/go.mod b/contrib/registry/polaris/go.mod
index a89802073..2d1936bef 100644
--- a/contrib/registry/polaris/go.mod
+++ b/contrib/registry/polaris/go.mod
@@ -3,60 +3,60 @@ module github.com/gogf/gf/contrib/registry/polaris/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 	github.com/polarismesh/polaris-go v1.6.1
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cespare/xxhash/v2 v2.1.2 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/dlclark/regexp2 v1.11.2 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/dlclark/regexp2 v1.7.0 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/golang/protobuf v1.5.4 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
-	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/errwrap v1.0.0 // indirect
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/natefinch/lumberjack v2.0.0+incompatible // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/polarismesh/specification v1.5.5-alpha.1 // indirect
-	github.com/prometheus/client_golang v1.19.1 // indirect
-	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.55.0 // indirect
-	github.com/prometheus/procfs v0.15.1 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/prometheus/client_golang v1.12.2 // indirect
+	github.com/prometheus/client_model v0.2.0 // indirect
+	github.com/prometheus/common v0.32.1 // indirect
+	github.com/prometheus/procfs v0.7.3 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
 	go.uber.org/atomic v1.7.0 // indirect
 	go.uber.org/multierr v1.6.0 // indirect
 	go.uber.org/zap v1.21.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d // indirect
-	google.golang.org/grpc v1.59.0 // indirect
-	google.golang.org/protobuf v1.34.2 // indirect
+	golang.org/x/text v0.25.0 // indirect
+	google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a // indirect
+	google.golang.org/grpc v1.51.0 // indirect
+	google.golang.org/protobuf v1.28.1 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/contrib/registry/polaris/go.sum b/contrib/registry/polaris/go.sum
index 1be90b589..f87d16b3f 100644
--- a/contrib/registry/polaris/go.sum
+++ b/contrib/registry/polaris/go.sum
@@ -188,9 +188,8 @@ github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6r
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
 github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
@@ -209,11 +208,10 @@ github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWH
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dlclark/regexp2 v1.7.0 h1:7lJfhqlPssTb1WQx4yvTHN0uElPEv52sbaECrAQxjAo=
 github.com/dlclark/regexp2 v1.7.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
-github.com/dlclark/regexp2 v1.11.2 h1:/u628IuisSTwri5/UKloiIsH8+qF2Pu7xEQX+yIKg68=
-github.com/dlclark/regexp2 v1.11.2/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
@@ -274,9 +272,8 @@ github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
-github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/gonum/blas v0.0.0-20181208220705-f22b278b28ac/go.mod h1:P32wAyui1PQ58Oce/KYkOqQv8cVw1zAapXOl+dRFGbc=
 github.com/gonum/floats v0.0.0-20181209220543-c233463c7e82/go.mod h1:PxC8OnwL11+aosOB5+iEPoV3picfs8tUpkVd0pDo+Kg=
@@ -344,9 +341,8 @@ github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/ad
 github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtgzltlQbOBae4=
 github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
 github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
+github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
-github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
-github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
 github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
 github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
@@ -377,12 +373,14 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
@@ -392,8 +390,6 @@ github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lN
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/natefinch/lumberjack v2.0.0+incompatible h1:4QJd3OLAMgj7ph+yZTuX13Ld4UpgHp07nNdFX7mqFfM=
@@ -402,8 +398,8 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -418,35 +414,30 @@ github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXP
 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=
 github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
+github.com/prometheus/client_golang v1.12.2 h1:51L9cDoUHVrXx4zWYlcLQIZ+d+VXHgqnYKkIuq4g/34=
 github.com/prometheus/client_golang v1.12.2/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
-github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
-github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
 github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
-github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
 github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
+github.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4=
 github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
-github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=
-github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU=
 github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
-github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
-github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
@@ -468,8 +459,8 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -485,14 +476,16 @@ go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
 go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
 go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
@@ -595,8 +588,8 @@ golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
 golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -704,6 +697,7 @@ golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
@@ -721,8 +715,8 @@ golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -936,9 +930,8 @@ google.golang.org/genproto v0.0.0-20220919141832-68c03719ef51/go.mod h1:0Nb8Qy+S
 google.golang.org/genproto v0.0.0-20220920201722-2b89144ce006/go.mod h1:ht8XFiar2npT/g4vkk7O0WYS1sHOHbdujxbEp7CJWbw=
 google.golang.org/genproto v0.0.0-20220926165614-551eb538f295/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI=
 google.golang.org/genproto v0.0.0-20220926220553-6981cbe3cfce/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI=
+google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a h1:GH6UPn3ixhWcKDhpnEC55S75cerLPdpp3hrhfKYjZgw=
 google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d h1:uvYuEyMHKNt+lT4K3bN6fGswmK8qSvcreM3BwjDh+y4=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d/go.mod h1:+Bk1OCOj40wS2hwAMA+aCW9ypzm63QTBBHp6lQ3p+9M=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
@@ -973,9 +966,8 @@ google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACu
 google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
 google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
 google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
+google.golang.org/grpc v1.51.0 h1:E1eGv1FTqoLIdnBCZufiSHgKjlqG6fKFf6pPWtMTh8U=
 google.golang.org/grpc v1.51.0/go.mod h1:wgNDFcnuBGmxLKI/qn4T+m5BtEBYXJPvibbUPsAIPww=
-google.golang.org/grpc v1.59.0 h1:Z5Iec2pjwb+LEOqzpB2MR12/eKFhDPhuqW91O+4bwUk=
-google.golang.org/grpc v1.59.0/go.mod h1:aUPDwccQo6OTjy7Hct4AfBPD1GptF4fyUjIkQ9YtF98=
 google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
@@ -991,9 +983,8 @@ google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp0
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
 google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/contrib/registry/zookeeper/go.mod b/contrib/registry/zookeeper/go.mod
index 4843ad5f0..ec609970a 100644
--- a/contrib/registry/zookeeper/go.mod
+++ b/contrib/registry/zookeeper/go.mod
@@ -4,14 +4,14 @@ go 1.23.0
 
 require (
 	github.com/go-zookeeper/zk v1.0.3
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.8
 	golang.org/x/sync v0.16.0
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -20,21 +20,21 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/registry/zookeeper/go.sum b/contrib/registry/zookeeper/go.sum
index fbb09cd60..1c8d1a24b 100644
--- a/contrib/registry/zookeeper/go.sum
+++ b/contrib/registry/zookeeper/go.sum
@@ -4,8 +4,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -31,8 +31,9 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -41,38 +42,40 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
 golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/contrib/registry/zookeeper/zookeeper.go b/contrib/registry/zookeeper/zookeeper.go
index be4b59c8c..67f78bb38 100644
--- a/contrib/registry/zookeeper/zookeeper.go
+++ b/contrib/registry/zookeeper/zookeeper.go
@@ -17,7 +17,7 @@ import (
 	"github.com/gogf/gf/v2/net/gsvc"
 )
 
-var _ gsvc.Registry = &Registry{}
+var _ gsvc.Registry = (*Registry)(nil)
 
 // Content for custom service Marshal/Unmarshal.
 type Content struct {
diff --git a/contrib/rpc/grpcx/go.mod b/contrib/rpc/grpcx/go.mod
index 1385108a0..93df1b77d 100644
--- a/contrib/rpc/grpcx/go.mod
+++ b/contrib/rpc/grpcx/go.mod
@@ -3,10 +3,10 @@ module github.com/gogf/gf/contrib/rpc/grpcx/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/contrib/registry/file/v2 v2.9.3
-	github.com/gogf/gf/v2 v2.9.3
-	go.opentelemetry.io/otel v1.37.0
-	go.opentelemetry.io/otel/trace v1.37.0
+	github.com/gogf/gf/contrib/registry/file/v2 v2.9.8
+	github.com/gogf/gf/v2 v2.9.8
+	go.opentelemetry.io/otel v1.38.0
+	go.opentelemetry.io/otel/trace v1.38.0
 	google.golang.org/grpc v1.64.1
 	google.golang.org/protobuf v1.34.2
 )
@@ -14,7 +14,7 @@ require (
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -23,19 +23,19 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/contrib/rpc/grpcx/go.sum b/contrib/rpc/grpcx/go.sum
index f1925e19a..904d28af6 100644
--- a/contrib/rpc/grpcx/go.sum
+++ b/contrib/rpc/grpcx/go.sum
@@ -4,8 +4,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -29,8 +29,9 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -39,36 +40,38 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237 h1:NnYq6UN9ReLM9/Y01KWNOWyI5xQ9kbIms5GGJVwS/Yc=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237/go.mod h1:WtryC6hu0hhx87FDGxWCDptyssuo68sk10vYjF+T9fY=
 google.golang.org/grpc v1.64.1 h1:LKtvyfbX3UGVPFcGqJ9ItpVWW6oN/2XqTxfAnwRRXiA=
diff --git a/contrib/sdk/httpclient/go.mod b/contrib/sdk/httpclient/go.mod
index e7a6a1dca..87276699f 100644
--- a/contrib/sdk/httpclient/go.mod
+++ b/contrib/sdk/httpclient/go.mod
@@ -2,12 +2,12 @@ module github.com/gogf/gf/contrib/sdk/httpclient/v2
 
 go 1.23.0
 
-require github.com/gogf/gf/v2 v2.9.3
+require github.com/gogf/gf/v2 v2.9.8
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -16,21 +16,21 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/contrib/sdk/httpclient/go.sum b/contrib/sdk/httpclient/go.sum
index e58d3957d..0718fa9fe 100644
--- a/contrib/sdk/httpclient/go.sum
+++ b/contrib/sdk/httpclient/go.sum
@@ -4,8 +4,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -29,8 +29,9 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -39,36 +40,38 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/contrib/trace/otlpgrpc/go.mod b/contrib/trace/otlpgrpc/go.mod
index b9e076b0d..ff176b4bf 100644
--- a/contrib/trace/otlpgrpc/go.mod
+++ b/contrib/trace/otlpgrpc/go.mod
@@ -3,19 +3,19 @@ module github.com/gogf/gf/contrib/trace/otlpgrpc/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
-	go.opentelemetry.io/otel v1.37.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.37.0
-	go.opentelemetry.io/otel/sdk v1.37.0
+	github.com/gogf/gf/v2 v2.9.8
+	go.opentelemetry.io/otel v1.38.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0
+	go.opentelemetry.io/otel/sdk v1.38.0
 	google.golang.org/grpc v1.75.0
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
-	github.com/cenkalti/backoff/v5 v5.0.2 // indirect
+	github.com/cenkalti/backoff/v5 v5.0.3 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -23,24 +23,24 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.1 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
 	go.opentelemetry.io/proto/otlp v1.7.1 // indirect
 	golang.org/x/net v0.43.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
 	golang.org/x/text v0.28.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20250818200422-3122310a409c // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250811230008-5f3141c8851a // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5 // indirect
 	google.golang.org/protobuf v1.36.8 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/contrib/trace/otlpgrpc/go.sum b/contrib/trace/otlpgrpc/go.sum
index 57edf0932..89ba34b7e 100644
--- a/contrib/trace/otlpgrpc/go.sum
+++ b/contrib/trace/otlpgrpc/go.sum
@@ -1,13 +1,13 @@
 github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
 github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
-github.com/cenkalti/backoff/v5 v5.0.2 h1:rIfFVxEf1QsI7E1ZHfp/B4DF/6QBAUhmgkxc0H7Zss8=
-github.com/cenkalti/backoff/v5 v5.0.2/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
+github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM=
+github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
 github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyME=
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -27,16 +27,17 @@ github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aN
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtgzltlQbOBae4=
 github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.1 h1:X5VWvz21y3gzm9Nw/kaUeku/1+uBhcekkmy4IkffJww=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.1/go.mod h1:Zanoh4+gvIgluNqcfMVTJueD4wSS5hT7zTt4Mrutd90=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2 h1:8Tjv8EJ+pM1xP8mK6egEbD1OgnVTyacbefKhmbLhIhU=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2/go.mod h1:pkJQ2tZHJ0aFOVEEot6oZmaVEZcRme73eIFmhiVuRWs=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -45,39 +46,39 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0 h1:Ahq7pZmv87yiyn3jeFz/LekZmPLLdKejuO3NcK9MssM=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0/go.mod h1:MJTqhM0im3mRLw1i8uGHnCvUEeS7VwRyxlLC78PA18M=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.37.0 h1:EtFWSnwW9hGObjkIdmlnWSydO+Qs8OwzfzXLUPg4xOc=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.37.0/go.mod h1:QjUEoiGCPkvFZ/MjK6ZZfNOS6mfVEVKYE99dFhuN2LI=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc=
-go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 h1:GqRJVj7UmLjCVyVJ3ZFLdPRmhDUp2zFmQe3RHIOsw24=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0/go.mod h1:ri3aaHSmCTVYu2AWv44YMauwAQc0aqI9gHKIcSbI1pU=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0 h1:lwI4Dc5leUqENgGuQImwLo4WnuXFPetmPpkLi2IrX54=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0/go.mod h1:Kz/oCE7z5wuyhPxsXDuaPteSWqjSBD5YaSdbxZYGbGk=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.opentelemetry.io/proto/otlp v1.7.1 h1:gTOMpGDb0WTBOP8JaO72iL3auEZhVmAQg4ipjOVAtj4=
 go.opentelemetry.io/proto/otlp v1.7.1/go.mod h1:b2rVh6rfI/s2pHWNlB7ILJcRALpcNDzKhACevjI+ZnE=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
 golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
@@ -85,10 +86,10 @@ golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
 golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
 gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
 gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
-google.golang.org/genproto/googleapis/api v0.0.0-20250818200422-3122310a409c h1:AtEkQdl5b6zsybXcbz00j1LwNodDuH6hVifIaNqk7NQ=
-google.golang.org/genproto/googleapis/api v0.0.0-20250818200422-3122310a409c/go.mod h1:ea2MjsO70ssTfCjiwHgI0ZFqcw45Ksuk2ckf9G468GA=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250811230008-5f3141c8851a h1:tPE/Kp+x9dMSwUm/uM0JKK0IfdiJkwAbSMSeZBXXJXc=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250811230008-5f3141c8851a/go.mod h1:gw1tLEfykwDz2ET4a12jcXt4couGAm7IwsVaTy0Sflo=
+google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5 h1:BIRfGDEjiHRrk0QKZe3Xv2ieMhtgRGeLcZQ0mIVn4EY=
+google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5/go.mod h1:j3QtIyytwqGr1JUDtYXwtMXWPKsEa5LtzIFN1Wn5WvE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5 h1:eaY8u2EuxbRv7c3NiGK0/NedzVsCcV6hDuU5qPX5EGE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5/go.mod h1:M4/wBTSeyLxupu3W3tJtOgB14jILAS/XWPSSa3TAlJc=
 google.golang.org/grpc v1.75.0 h1:+TW+dqTd2Biwe6KKfhE5JpiYIBWq865PhKGSXiivqt4=
 google.golang.org/grpc v1.75.0/go.mod h1:JtPAzKiq4v1xcAB2hydNlWI2RnF85XXcV0mhKXr2ecQ=
 google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
diff --git a/contrib/trace/otlphttp/go.mod b/contrib/trace/otlphttp/go.mod
index c80200196..814957e2f 100644
--- a/contrib/trace/otlphttp/go.mod
+++ b/contrib/trace/otlphttp/go.mod
@@ -3,18 +3,18 @@ module github.com/gogf/gf/contrib/trace/otlphttp/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/v2 v2.9.3
-	go.opentelemetry.io/otel v1.37.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.37.0
-	go.opentelemetry.io/otel/sdk v1.37.0
+	github.com/gogf/gf/v2 v2.9.8
+	go.opentelemetry.io/otel v1.38.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0
+	go.opentelemetry.io/otel/sdk v1.38.0
 )
 
 require (
 	github.com/BurntSushi/toml v1.5.0 // indirect
-	github.com/cenkalti/backoff/v5 v5.0.2 // indirect
+	github.com/cenkalti/backoff/v5 v5.0.3 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -22,25 +22,25 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.1 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
 	go.opentelemetry.io/proto/otlp v1.7.1 // indirect
 	golang.org/x/net v0.43.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
 	golang.org/x/text v0.28.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20250728155136-f173205681a0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250728155136-f173205681a0 // indirect
-	google.golang.org/grpc v1.74.2 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5 // indirect
+	google.golang.org/grpc v1.75.0 // indirect
 	google.golang.org/protobuf v1.36.8 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/contrib/trace/otlphttp/go.sum b/contrib/trace/otlphttp/go.sum
index 7c0717f94..aff2ce0b3 100644
--- a/contrib/trace/otlphttp/go.sum
+++ b/contrib/trace/otlphttp/go.sum
@@ -1,13 +1,13 @@
 github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
 github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
-github.com/cenkalti/backoff/v5 v5.0.2 h1:rIfFVxEf1QsI7E1ZHfp/B4DF/6QBAUhmgkxc0H7Zss8=
-github.com/cenkalti/backoff/v5 v5.0.2/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
+github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM=
+github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
 github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyME=
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -27,16 +27,17 @@ github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aN
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtgzltlQbOBae4=
 github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.1 h1:X5VWvz21y3gzm9Nw/kaUeku/1+uBhcekkmy4IkffJww=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.1/go.mod h1:Zanoh4+gvIgluNqcfMVTJueD4wSS5hT7zTt4Mrutd90=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2 h1:8Tjv8EJ+pM1xP8mK6egEbD1OgnVTyacbefKhmbLhIhU=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2/go.mod h1:pkJQ2tZHJ0aFOVEEot6oZmaVEZcRme73eIFmhiVuRWs=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -45,50 +46,52 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0 h1:Ahq7pZmv87yiyn3jeFz/LekZmPLLdKejuO3NcK9MssM=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0/go.mod h1:MJTqhM0im3mRLw1i8uGHnCvUEeS7VwRyxlLC78PA18M=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.37.0 h1:bDMKF3RUSxshZ5OjOTi8rsHGaPKsAt76FaqgvIUySLc=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.37.0/go.mod h1:dDT67G/IkA46Mr2l9Uj7HsQVwsjASyV9SjGofsiUZDA=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/sdk/metric v1.36.0 h1:r0ntwwGosWGaa0CrSt8cuNuTcccMXERFwHX4dThiPis=
-go.opentelemetry.io/otel/sdk/metric v1.36.0/go.mod h1:qTNOhFDfKRwX0yXOqJYegL5WRaW376QbB7P4Pb0qva4=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 h1:GqRJVj7UmLjCVyVJ3ZFLdPRmhDUp2zFmQe3RHIOsw24=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0/go.mod h1:ri3aaHSmCTVYu2AWv44YMauwAQc0aqI9gHKIcSbI1pU=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0 h1:aTL7F04bJHUlztTsNGJ2l+6he8c+y/b//eR0jjjemT4=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0/go.mod h1:kldtb7jDTeol0l3ewcmd8SDvx3EmIE7lyvqbasU3QC4=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.opentelemetry.io/proto/otlp v1.7.1 h1:gTOMpGDb0WTBOP8JaO72iL3auEZhVmAQg4ipjOVAtj4=
 go.opentelemetry.io/proto/otlp v1.7.1/go.mod h1:b2rVh6rfI/s2pHWNlB7ILJcRALpcNDzKhACevjI+ZnE=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
 golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
 golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
-google.golang.org/genproto/googleapis/api v0.0.0-20250728155136-f173205681a0 h1:0UOBWO4dC+e51ui0NFKSPbkHHiQ4TmrEfEZMLDyRmY8=
-google.golang.org/genproto/googleapis/api v0.0.0-20250728155136-f173205681a0/go.mod h1:8ytArBbtOy2xfht+y2fqKd5DRDJRUQhqbyEnQ4bDChs=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250728155136-f173205681a0 h1:MAKi5q709QWfnkkpNQ0M12hYJ1+e8qYVDyowc4U1XZM=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250728155136-f173205681a0/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
-google.golang.org/grpc v1.74.2 h1:WoosgB65DlWVC9FqI82dGsZhWFNBSLjQ84bjROOpMu4=
-google.golang.org/grpc v1.74.2/go.mod h1:CtQ+BGjaAIXHs/5YS3i473GqwBBa1zGQNevxdeBEXrM=
+gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
+gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
+google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5 h1:BIRfGDEjiHRrk0QKZe3Xv2ieMhtgRGeLcZQ0mIVn4EY=
+google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5/go.mod h1:j3QtIyytwqGr1JUDtYXwtMXWPKsEa5LtzIFN1Wn5WvE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5 h1:eaY8u2EuxbRv7c3NiGK0/NedzVsCcV6hDuU5qPX5EGE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5/go.mod h1:M4/wBTSeyLxupu3W3tJtOgB14jILAS/XWPSSa3TAlJc=
+google.golang.org/grpc v1.75.0 h1:+TW+dqTd2Biwe6KKfhE5JpiYIBWq865PhKGSXiivqt4=
+google.golang.org/grpc v1.75.0/go.mod h1:JtPAzKiq4v1xcAB2hydNlWI2RnF85XXcV0mhKXr2ecQ=
 google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
 google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/crypto/grsa/README.md b/crypto/grsa/README.md
new file mode 100644
index 000000000..1cdfd3e4a
--- /dev/null
+++ b/crypto/grsa/README.md
@@ -0,0 +1,264 @@
+# GoFrame RSA Package
+
+Package `grsa` provides useful API for RSA encryption/decryption algorithms within the GoFrame framework.
+
+## Features
+
+- Generating RSA key pairs in PKCS#1 and PKCS#8 formats
+- Encrypting and decrypting data with various key formats
+- Handling Base64 encoded keys
+- Detecting private key types
+- Plaintext size validation
+- **OAEP padding support (recommended for new applications)**
+
+## Security Considerations
+
+This package provides two padding schemes for RSA encryption:
+
+### 1. PKCS#1 v1.5 (Legacy)
+
+Used by `Encrypt*`, `DecryptPKCS1*`, `DecryptPKCS8*` functions.
+
+⚠️ **Security Warning**: PKCS#1 v1.5 padding is considered less secure and vulnerable to padding oracle attacks. It is provided for backward compatibility with existing systems.
+
+### 2. OAEP (Recommended)
+
+Used by `EncryptOAEP*`, `DecryptOAEP*` functions.
+
+✅ **Recommended**: OAEP (Optimal Asymmetric Encryption Padding) provides better security guarantees and should be used for all new applications.
+
+## Quick Start
+
+### Basic Encryption/Decryption (OAEP - Recommended)
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/v2/crypto/grsa"
+)
+
+func main() {
+    // Generate a default RSA key pair (2048 bits)
+    privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+    if err != nil {
+        panic(err)
+    }
+
+    // Data to encrypt
+    plainText := []byte("Hello, World!")
+
+    // Encrypt with public key using OAEP (recommended)
+    cipherText, err := grsa.EncryptOAEP(plainText, publicKey)
+    if err != nil {
+        panic(err)
+    }
+
+    // Decrypt with private key using OAEP
+    decryptedText, err := grsa.DecryptOAEP(cipherText, privateKey)
+    if err != nil {
+        panic(err)
+    }
+
+    fmt.Println(string(decryptedText)) // Output: Hello, World!
+}
+```
+
+### Legacy Encryption/Decryption (PKCS#1 v1.5)
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/v2/crypto/grsa"
+)
+
+func main() {
+    // Generate a default RSA key pair (2048 bits)
+    privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+    if err != nil {
+        panic(err)
+    }
+
+    // Data to encrypt
+    plainText := []byte("Hello, World!")
+
+    // Encrypt with public key (PKCS#1 v1.5 - legacy)
+    cipherText, err := grsa.Encrypt(plainText, publicKey)
+    if err != nil {
+        panic(err)
+    }
+
+    // Decrypt with private key
+    decryptedText, err := grsa.Decrypt(cipherText, privateKey)
+    if err != nil {
+        panic(err)
+    }
+
+    fmt.Println(string(decryptedText)) // Output: Hello, World!
+}
+```
+
+### Working with Base64 Encoded Keys
+
+```go
+package main
+
+import (
+    "encoding/base64"
+    "fmt"
+    "github.com/gogf/gf/v2/crypto/grsa"
+)
+
+func main() {
+    // Generate a key pair
+    privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+    if err != nil {
+        panic(err)
+    }
+
+    // Encode keys to Base64
+    privateKeyBase64 := base64.StdEncoding.EncodeToString(privateKey)
+    publicKeyBase64 := base64.StdEncoding.EncodeToString(publicKey)
+
+    // Data to encrypt
+    plainText := []byte("Hello, Base64 World!")
+
+    // Encrypt with Base64 encoded public key using OAEP (recommended)
+    cipherTextBase64, err := grsa.EncryptOAEPBase64(plainText, publicKeyBase64)
+    if err != nil {
+        panic(err)
+    }
+
+    // Decrypt with Base64 encoded private key using OAEP
+    decryptedText, err := grsa.DecryptOAEPBase64(cipherTextBase64, privateKeyBase64)
+    if err != nil {
+        panic(err)
+    }
+
+    fmt.Println(string(decryptedText)) // Output: Hello, Base64 World!
+}
+```
+
+## Functions
+
+### Key Generation
+
+- `GenerateKeyPair(bits int)`: Generates a new RSA key pair with the given bits in PKCS#1 format
+- `GenerateKeyPairPKCS8(bits int)`: Generates a new RSA key pair with the given bits in PKCS#8 format
+- `GenerateDefaultKeyPair()`: Generates a new RSA key pair with default bits (2048) in PKCS#1 format
+
+### OAEP Encryption/Decryption (Recommended)
+
+- `EncryptOAEP(plainText, publicKey []byte)`: Encrypts data with public key using OAEP padding (SHA-256)
+- `DecryptOAEP(cipherText, privateKey []byte)`: Decrypts data with private key using OAEP padding (SHA-256)
+- `EncryptOAEPBase64(plainText []byte, publicKeyBase64 string)`: Encrypts data with OAEP and returns base64-encoded result
+- `DecryptOAEPBase64(cipherTextBase64, privateKeyBase64 string)`: Decrypts base64-encoded OAEP data
+- `EncryptOAEPWithHash(plainText, publicKey, label []byte, hash hash.Hash)`: Encrypts with custom hash function
+- `DecryptOAEPWithHash(cipherText, privateKey, label []byte, hash hash.Hash)`: Decrypts with custom hash function
+
+### General Encryption/Decryption (Legacy - PKCS#1 v1.5)
+
+- `Encrypt(plainText, publicKey []byte)`: Encrypts data with public key (auto-detect format)
+- `Decrypt(cipherText, privateKey []byte)`: Decrypts data with private key (auto-detect format)
+- `EncryptBase64(plainText []byte, publicKeyBase64 string)`: Encrypts data with base64-encoded public key and returns base64-encoded result
+- `DecryptBase64(cipherTextBase64, privateKeyBase64 string)`: Decrypts base64-encoded data with base64-encoded private key
+
+### PKCS#1 Specific Functions (Legacy)
+
+- `EncryptPKCS1(plainText, publicKey []byte)`: Encrypts data with PKCS#1 format public key
+- `DecryptPKCS1(cipherText, privateKey []byte)`: Decrypts data with PKCS#1 format private key
+- `EncryptPKCS1Base64(plainText []byte, publicKeyBase64 string)`: Encrypts data with PKCS#1 public key and returns base64-encoded result
+- `DecryptPKCS1Base64(cipherTextBase64, privateKeyBase64 string)`: Decrypts base64-encoded data with PKCS#1 private key
+
+### PKIX Specific Functions (Legacy)
+
+PKIX (X.509) is the standard format for public keys, used with PKCS#8 private keys.
+
+- `EncryptPKIX(plainText, publicKey []byte)`: Encrypts data with PKIX format public key
+- `EncryptPKIXBase64(plainText []byte, publicKeyBase64 string)`: Encrypts data with PKIX public key and returns base64-encoded result
+- `DecryptPKCS8(cipherText, privateKey []byte)`: Decrypts data with PKCS#8 format private key
+- `DecryptPKCS8Base64(cipherTextBase64, privateKeyBase64 string)`: Decrypts base64-encoded data with PKCS#8 private key
+
+### Deprecated Functions
+
+The following functions are deprecated and will be removed in future versions:
+
+- `EncryptPKCS8(plainText, publicKey []byte)`: Use `EncryptPKIX` instead
+- `EncryptPKCS8Base64(plainText []byte, publicKeyBase64 string)`: Use `EncryptPKIXBase64` instead
+
+### Utility Functions
+
+- `GetPrivateKeyType(privateKey []byte)`: Detects the type of private key (PKCS#1 or PKCS#8)
+- `GetPrivateKeyTypeBase64(privateKeyBase64 string)`: Detects the type of base64 encoded private key
+- `ExtractPKCS1PublicKey(privateKey []byte)`: Extracts PKCS#1 public key from PKCS#1 private key
+
+## Key Formats
+
+The package supports two popular RSA key formats:
+
+1. **PKCS#1**: Traditional RSA key format
+   - Private key PEM header: `-----BEGIN RSA PRIVATE KEY-----`
+   - Public key PEM header: `-----BEGIN RSA PUBLIC KEY-----`
+
+2. **PKCS#8/PKIX**: More modern and flexible key format
+   - Private key PEM header: `-----BEGIN PRIVATE KEY-----`
+   - Public key PEM header: `-----BEGIN PUBLIC KEY-----`
+
+Both formats are supported for encryption and decryption operations, with auto-detection capabilities for general functions.
+
+### Technical Background: PKCS#8 vs PKIX
+
+**PKCS#8** is a standard for **private keys** only, not public keys. Public keys use the **PKIX (X.509 SubjectPublicKeyInfo)** format.
+
+| Format | Private Key PEM Header | Public Key PEM Header |
+|--------|------------------------|----------------------|
+| PKCS#1 | `RSA PRIVATE KEY` | `RSA PUBLIC KEY` |
+| PKCS#8/PKIX | `PRIVATE KEY` | `PUBLIC KEY` |
+
+When we refer to a "PKCS#8 key pair", it actually means:
+- **Private key**: PKCS#8 format (RFC 5208)
+- **Public key**: PKIX/SubjectPublicKeyInfo format (RFC 5280, X.509)
+
+This is why the Go standard library provides `x509.MarshalPKCS8PrivateKey` for private keys but `x509.MarshalPKIXPublicKey` for public keys — there is no `MarshalPKCS8PublicKey` function.
+
+The deprecated `EncryptPKCS8` function was a misnomer because encryption uses public keys, and public keys are in PKIX format, not PKCS#8. The correct function name is `EncryptPKIX`.
+
+## Plaintext Size Limit
+
+RSA encryption has a size limit based on key size and padding scheme.
+
+### PKCS#1 v1.5 Padding (Legacy)
+
+- **Max plaintext size = key_size_in_bytes - 11**
+- For a 2048-bit key: max 245 bytes
+- For a 4096-bit key: max 501 bytes
+
+### OAEP Padding with SHA-256 (Recommended)
+
+- **Max plaintext size = key_size_in_bytes - 2 × hash_size - 2**
+- For a 2048-bit key with SHA-256: max 190 bytes
+- For a 4096-bit key with SHA-256: max 446 bytes
+
+If you need to encrypt larger data, consider using hybrid encryption (RSA + AES).
+
+## Error Handling
+
+All functions return descriptive errors that can be handled using the GoFrame error package (`gerror`). Errors typically include:
+
+- Invalid key format
+- Failed key parsing
+- Plaintext too long
+- Encryption/decryption failures
+
+Always check for errors in production code to ensure robust handling of edge cases.
+
+## Testing
+
+Run the package tests with:
+
+```bash
+go test -v
+```
diff --git a/crypto/grsa/grsa.go b/crypto/grsa/grsa.go
new file mode 100644
index 000000000..51988aa20
--- /dev/null
+++ b/crypto/grsa/grsa.go
@@ -0,0 +1,571 @@
+// 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 grsa provides useful API for RSA encryption/decryption algorithms.
+//
+// This package includes functionality for:
+// - Generating RSA key pairs in PKCS#1 and PKCS#8 formats
+// - Encrypting and decrypting data with various key formats
+// - Handling Base64 encoded keys
+// - Detecting private key types
+//
+// # Security Considerations
+//
+// This package provides two padding schemes for RSA encryption:
+//
+// 1. PKCS#1 v1.5 (legacy): Used by Encrypt*, DecryptPKCS1*, DecryptPKCS8* functions.
+// This padding scheme is considered less secure and vulnerable to padding oracle attacks.
+// It is provided for backward compatibility with existing systems.
+//
+// 2. OAEP (recommended): Used by EncryptOAEP*, DecryptOAEP* functions.
+// OAEP (Optimal Asymmetric Encryption Padding) is the recommended padding scheme
+// for new applications as it provides better security guarantees.
+//
+// For new implementations, prefer using OAEP functions (EncryptOAEP, DecryptOAEP, etc.).
+package grsa
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/sha256"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/pem"
+	"hash"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+)
+
+const (
+	// DefaultRSAKeyBits is the default bit size for RSA key generation
+	DefaultRSAKeyBits = 2048
+
+	// KeyTypePKCS1 represents PKCS#1 format private key
+	KeyTypePKCS1 = "PKCS#1"
+	// KeyTypePKCS8 represents PKCS#8 format private key
+	KeyTypePKCS8 = "PKCS#8"
+
+	// PEM block types
+	pemTypeRSAPrivateKey = "RSA PRIVATE KEY" // PKCS#1 private key
+	pemTypePrivateKey    = "PRIVATE KEY"     // PKCS#8 private key
+	pemTypeRSAPublicKey  = "RSA PUBLIC KEY"  // PKCS#1 public key
+	pemTypePublicKey     = "PUBLIC KEY"      // PKIX public key
+)
+
+// Encrypt encrypts data with public key using PKCS#1 v1.5 padding (auto-detect format).
+// The publicKey can be either PKCS#1 or PKCS#8 (PKIX) format.
+//
+// Note: RSA encryption has a size limit based on key size.
+// For PKCS#1 v1.5 padding, max plaintext size = key_size_in_bytes - 11.
+// For example, a 2048-bit key can encrypt at most 245 bytes.
+//
+// Security Warning: PKCS#1 v1.5 padding is vulnerable to padding oracle attacks.
+// For new applications, consider using EncryptOAEP instead.
+func Encrypt(plainText, publicKey []byte) ([]byte, error) {
+	block, _ := pem.Decode(publicKey)
+	if block == nil {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "invalid public key")
+	}
+
+	// Try PKCS#8 (PKIX) first
+	pub, err := x509.ParsePKIXPublicKey(block.Bytes)
+	if err != nil {
+		// Try PKCS#1
+		pub, err = x509.ParsePKCS1PublicKey(block.Bytes)
+		if err != nil {
+			return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to parse public key")
+		}
+	}
+
+	rsaPub, ok := pub.(*rsa.PublicKey)
+	if !ok {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "not an RSA public key")
+	}
+
+	// Validate plaintext size for PKCS#1 v1.5 padding
+	maxSize := rsaPub.Size() - 11
+	if len(plainText) > maxSize {
+		return nil, gerror.NewCodef(gcode.CodeInvalidParameter,
+			"plaintext too long: max %d bytes for this key, got %d bytes", maxSize, len(plainText))
+	}
+
+	return rsa.EncryptPKCS1v15(rand.Reader, rsaPub, plainText)
+}
+
+// Decrypt decrypts data with private key using PKCS#1 v1.5 padding (auto-detect format).
+// The privateKey can be either PKCS#1 or PKCS#8 format.
+//
+// Security Warning: PKCS#1 v1.5 padding is vulnerable to padding oracle attacks.
+// For new applications, consider using DecryptOAEP instead.
+func Decrypt(cipherText, privateKey []byte) ([]byte, error) {
+	block, _ := pem.Decode(privateKey)
+	if block == nil {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "invalid private key")
+	}
+
+	// Try PKCS#8 first
+	priv, err := x509.ParsePKCS8PrivateKey(block.Bytes)
+	if err != nil {
+		// Try PKCS#1
+		priv, err = x509.ParsePKCS1PrivateKey(block.Bytes)
+		if err != nil {
+			return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to parse private key")
+		}
+	}
+
+	rsaPriv, ok := priv.(*rsa.PrivateKey)
+	if !ok {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "not an RSA private key")
+	}
+
+	return rsa.DecryptPKCS1v15(rand.Reader, rsaPriv, cipherText)
+}
+
+// EncryptBase64 encrypts data with base64-encoded public key (auto-detect format)
+// and returns base64-encoded result.
+func EncryptBase64(plainText []byte, publicKeyBase64 string) (string, error) {
+	publicKey, err := base64.StdEncoding.DecodeString(publicKeyBase64)
+	if err != nil {
+		return "", gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode public key")
+	}
+
+	encrypted, err := Encrypt(plainText, publicKey)
+	if err != nil {
+		return "", err
+	}
+
+	return base64.StdEncoding.EncodeToString(encrypted), nil
+}
+
+// DecryptBase64 decrypts base64-encoded data with base64-encoded private key (auto-detect format).
+func DecryptBase64(cipherTextBase64, privateKeyBase64 string) ([]byte, error) {
+	privateKey, err := base64.StdEncoding.DecodeString(privateKeyBase64)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode private key")
+	}
+
+	cipherText, err := base64.StdEncoding.DecodeString(cipherTextBase64)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode cipher text")
+	}
+
+	return Decrypt(cipherText, privateKey)
+}
+
+// EncryptPKIX encrypts data with public key in PKIX (X.509) format.
+// PKIX is the standard format for public keys, often referred to as "PKCS#8 public key".
+//
+// Note: RSA encryption has a size limit based on key size.
+// For PKCS#1 v1.5 padding, max plaintext size = key_size_in_bytes - 11.
+func EncryptPKIX(plainText, publicKey []byte) ([]byte, error) {
+	block, _ := pem.Decode(publicKey)
+	if block == nil {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "invalid public key")
+	}
+
+	pub, err := x509.ParsePKIXPublicKey(block.Bytes)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to parse PKIX public key")
+	}
+
+	rsaPub, ok := pub.(*rsa.PublicKey)
+	if !ok {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "not an RSA public key")
+	}
+
+	// Validate plaintext size for PKCS#1 v1.5 padding
+	maxSize := rsaPub.Size() - 11
+	if len(plainText) > maxSize {
+		return nil, gerror.NewCodef(gcode.CodeInvalidParameter,
+			"plaintext too long: max %d bytes for this key, got %d bytes", maxSize, len(plainText))
+	}
+
+	return rsa.EncryptPKCS1v15(rand.Reader, rsaPub, plainText)
+}
+
+// EncryptPKCS8 is an alias for EncryptPKIX for backward compatibility.
+//
+// Deprecated: Use EncryptPKIX instead. Public keys use PKIX format, not PKCS#8.
+func EncryptPKCS8(plainText, publicKey []byte) ([]byte, error) {
+	return EncryptPKIX(plainText, publicKey)
+}
+
+// EncryptPKCS1 encrypts data with public key in PKCS#1 format.
+//
+// Note: RSA encryption has a size limit based on key size.
+// For PKCS#1 v1.5 padding, max plaintext size = key_size_in_bytes - 11.
+func EncryptPKCS1(plainText, publicKey []byte) ([]byte, error) {
+	block, _ := pem.Decode(publicKey)
+	if block == nil {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "invalid public key")
+	}
+
+	pub, err := x509.ParsePKCS1PublicKey(block.Bytes)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to parse PKCS#1 public key")
+	}
+
+	// Validate plaintext size for PKCS#1 v1.5 padding
+	maxSize := pub.Size() - 11
+	if len(plainText) > maxSize {
+		return nil, gerror.NewCodef(gcode.CodeInvalidParameter,
+			"plaintext too long: max %d bytes for this key, got %d bytes", maxSize, len(plainText))
+	}
+
+	return rsa.EncryptPKCS1v15(rand.Reader, pub, plainText)
+}
+
+// DecryptPKCS8 decrypts data with private key by PKCS#8 format.
+func DecryptPKCS8(cipherText, privateKey []byte) ([]byte, error) {
+	block, _ := pem.Decode(privateKey)
+	if block == nil {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "invalid private key")
+	}
+
+	priv, err := x509.ParsePKCS8PrivateKey(block.Bytes)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to parse PKCS#8 private key")
+	}
+
+	rsaPriv, ok := priv.(*rsa.PrivateKey)
+	if !ok {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "not an RSA private key")
+	}
+
+	return rsa.DecryptPKCS1v15(rand.Reader, rsaPriv, cipherText)
+}
+
+// DecryptPKCS1 decrypts data with private key by PKCS#1 format.
+func DecryptPKCS1(cipherText, privateKey []byte) ([]byte, error) {
+	block, _ := pem.Decode(privateKey)
+	if block == nil {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "invalid private key")
+	}
+
+	priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to parse private key")
+	}
+
+	return rsa.DecryptPKCS1v15(rand.Reader, priv, cipherText)
+}
+
+// EncryptPKIXBase64 encrypts data with PKIX public key and returns base64-encoded result.
+func EncryptPKIXBase64(plainText []byte, publicKeyBase64 string) (string, error) {
+	publicKey, err := base64.StdEncoding.DecodeString(publicKeyBase64)
+	if err != nil {
+		return "", gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode public key")
+	}
+
+	encrypted, err := EncryptPKIX(plainText, publicKey)
+	if err != nil {
+		return "", err
+	}
+
+	return base64.StdEncoding.EncodeToString(encrypted), nil
+}
+
+// EncryptPKCS8Base64 is an alias for EncryptPKIXBase64 for backward compatibility.
+//
+// Deprecated: Use EncryptPKIXBase64 instead.
+func EncryptPKCS8Base64(plainText []byte, publicKeyBase64 string) (string, error) {
+	return EncryptPKIXBase64(plainText, publicKeyBase64)
+}
+
+// EncryptPKCS1Base64 encrypts data with PKCS#1 public key and returns base64-encoded result.
+func EncryptPKCS1Base64(plainText []byte, publicKeyBase64 string) (string, error) {
+	publicKey, err := base64.StdEncoding.DecodeString(publicKeyBase64)
+	if err != nil {
+		return "", gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode public key")
+	}
+
+	encrypted, err := EncryptPKCS1(plainText, publicKey)
+	if err != nil {
+		return "", err
+	}
+
+	return base64.StdEncoding.EncodeToString(encrypted), nil
+}
+
+// DecryptPKCS8Base64 decrypts data with private key by PKCS#8 format and decode base64 input.
+func DecryptPKCS8Base64(cipherTextBase64, privateKeyBase64 string) ([]byte, error) {
+	privateKey, err := base64.StdEncoding.DecodeString(privateKeyBase64)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode private key")
+	}
+
+	cipherText, err := base64.StdEncoding.DecodeString(cipherTextBase64)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode cipher text")
+	}
+
+	return DecryptPKCS8(cipherText, privateKey)
+}
+
+// DecryptPKCS1Base64 decrypts base64-encoded data with PKCS#1 private key.
+func DecryptPKCS1Base64(cipherTextBase64, privateKeyBase64 string) ([]byte, error) {
+	privateKey, err := base64.StdEncoding.DecodeString(privateKeyBase64)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode private key")
+	}
+
+	cipherText, err := base64.StdEncoding.DecodeString(cipherTextBase64)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode cipher text")
+	}
+
+	return DecryptPKCS1(cipherText, privateKey)
+}
+
+// GetPrivateKeyType detects the type of private key (PKCS#1 or PKCS#8).
+// It attempts to parse the key in both formats to determine the actual type.
+func GetPrivateKeyType(privateKey []byte) (string, error) {
+	block, _ := pem.Decode(privateKey)
+	if block == nil {
+		return "", gerror.NewCode(gcode.CodeInvalidParameter, "invalid private key")
+	}
+
+	// Try PKCS#1 first
+	_, err := x509.ParsePKCS1PrivateKey(block.Bytes)
+	if err == nil {
+		return KeyTypePKCS1, nil
+	}
+
+	// Try PKCS#8
+	priv, err := x509.ParsePKCS8PrivateKey(block.Bytes)
+	if err == nil {
+		if _, ok := priv.(*rsa.PrivateKey); ok {
+			return KeyTypePKCS8, nil
+		}
+		return "", gerror.NewCode(gcode.CodeInvalidParameter, "not an RSA private key")
+	}
+
+	return "", gerror.NewCode(gcode.CodeInvalidParameter, "unknown private key format")
+}
+
+// GetPrivateKeyTypeBase64 detects the type of base64 encoded private key (PKCS#1 or PKCS#8).
+func GetPrivateKeyTypeBase64(privateKeyBase64 string) (string, error) {
+	privateKey, err := base64.StdEncoding.DecodeString(privateKeyBase64)
+	if err != nil {
+		return "", gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode private key")
+	}
+
+	return GetPrivateKeyType(privateKey)
+}
+
+// GenerateKeyPair generates a new RSA key pair with the given bits.
+func GenerateKeyPair(bits int) (privateKey, publicKey []byte, err error) {
+	// Generate private key
+	privKey, err := rsa.GenerateKey(rand.Reader, bits)
+	if err != nil {
+		return nil, nil, gerror.WrapCode(gcode.CodeInternalError, err, "failed to generate rsa key")
+	}
+
+	// Validate private key
+	err = privKey.Validate()
+	if err != nil {
+		return nil, nil, gerror.WrapCode(gcode.CodeInternalError, err, "failed to validate rsa key")
+	}
+
+	// Marshal private key to PKCS#1 format
+	privKeyBytes := x509.MarshalPKCS1PrivateKey(privKey)
+	privateKey = pem.EncodeToMemory(&pem.Block{
+		Type:  pemTypeRSAPrivateKey,
+		Bytes: privKeyBytes,
+	})
+
+	// Generate PKCS#1 public key
+	pubKeyBytes := x509.MarshalPKCS1PublicKey(&privKey.PublicKey)
+	publicKey = pem.EncodeToMemory(&pem.Block{
+		Type:  pemTypeRSAPublicKey,
+		Bytes: pubKeyBytes,
+	})
+
+	return privateKey, publicKey, nil
+}
+
+// GenerateKeyPairPKCS8 generates a new RSA key pair with the given bits in PKCS#8 format.
+func GenerateKeyPairPKCS8(bits int) (privateKey, publicKey []byte, err error) {
+	// Generate private key
+	privKey, err := rsa.GenerateKey(rand.Reader, bits)
+	if err != nil {
+		return nil, nil, gerror.WrapCode(gcode.CodeInternalError, err, "failed to generate rsa key")
+	}
+
+	// Validate private key
+	err = privKey.Validate()
+	if err != nil {
+		return nil, nil, gerror.WrapCode(gcode.CodeInternalError, err, "failed to validate rsa key")
+	}
+
+	// Marshal private key to PKCS#8 format
+	privKeyBytes, err := x509.MarshalPKCS8PrivateKey(privKey)
+	if err != nil {
+		return nil, nil, gerror.WrapCode(gcode.CodeInternalError, err, "failed to marshal private key to PKCS#8")
+	}
+
+	privateKey = pem.EncodeToMemory(&pem.Block{
+		Type:  pemTypePrivateKey,
+		Bytes: privKeyBytes,
+	})
+
+	// Generate public key
+	pubKeyBytes, err := x509.MarshalPKIXPublicKey(&privKey.PublicKey)
+	if err != nil {
+		return nil, nil, gerror.WrapCode(gcode.CodeInternalError, err, "failed to marshal public key")
+	}
+
+	publicKey = pem.EncodeToMemory(&pem.Block{
+		Type:  pemTypePublicKey,
+		Bytes: pubKeyBytes,
+	})
+
+	return privateKey, publicKey, nil
+}
+
+// GenerateDefaultKeyPair generates a new RSA key pair with default bits (2048).
+func GenerateDefaultKeyPair() (privateKey, publicKey []byte, err error) {
+	return GenerateKeyPair(DefaultRSAKeyBits)
+}
+
+// ExtractPKCS1PublicKey extracts PKCS#1 public key from private key.
+func ExtractPKCS1PublicKey(privateKey []byte) ([]byte, error) {
+	block, _ := pem.Decode(privateKey)
+	if block == nil {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "invalid private key")
+	}
+
+	priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to parse private key")
+	}
+
+	pubKeyBytes := x509.MarshalPKCS1PublicKey(&priv.PublicKey)
+	return pem.EncodeToMemory(&pem.Block{
+		Type:  pemTypeRSAPublicKey,
+		Bytes: pubKeyBytes,
+	}), nil
+}
+
+// ============================================================================
+// OAEP Encryption/Decryption Functions (Recommended for new applications)
+// ============================================================================
+
+// EncryptOAEP encrypts data with public key using OAEP padding (auto-detect format).
+// The publicKey can be either PKCS#1 or PKCS#8 (PKIX) format.
+// Uses SHA-256 as the hash function by default.
+//
+// OAEP (Optimal Asymmetric Encryption Padding) is more secure than PKCS#1 v1.5
+// and is recommended for new applications.
+//
+// Note: For OAEP with SHA-256, max plaintext size = key_size_in_bytes - 2*32 - 2.
+// For a 2048-bit key, this is 190 bytes.
+func EncryptOAEP(plainText, publicKey []byte) ([]byte, error) {
+	return EncryptOAEPWithHash(plainText, publicKey, nil, sha256.New())
+}
+
+// EncryptOAEPWithHash encrypts data with public key using OAEP padding with custom hash.
+// The publicKey can be either PKCS#1 or PKCS#8 (PKIX) format.
+// The label parameter can be nil for most use cases.
+// The hash parameter specifies the hash function to use (e.g., sha256.New()).
+func EncryptOAEPWithHash(plainText, publicKey, label []byte, hash hash.Hash) ([]byte, error) {
+	block, _ := pem.Decode(publicKey)
+	if block == nil {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "invalid public key")
+	}
+
+	// Try PKCS#8 (PKIX) first
+	pub, err := x509.ParsePKIXPublicKey(block.Bytes)
+	if err != nil {
+		// Try PKCS#1
+		pub, err = x509.ParsePKCS1PublicKey(block.Bytes)
+		if err != nil {
+			return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to parse public key")
+		}
+	}
+
+	rsaPub, ok := pub.(*rsa.PublicKey)
+	if !ok {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "not an RSA public key")
+	}
+
+	// Validate plaintext size for OAEP padding
+	// maxSize = keySize - 2*hashSize - 2
+	maxSize := rsaPub.Size() - 2*hash.Size() - 2
+	if len(plainText) > maxSize {
+		return nil, gerror.NewCodef(gcode.CodeInvalidParameter,
+			"plaintext too long: max %d bytes for this key with OAEP, got %d bytes", maxSize, len(plainText))
+	}
+
+	return rsa.EncryptOAEP(hash, rand.Reader, rsaPub, plainText, label)
+}
+
+// DecryptOAEP decrypts data with private key using OAEP padding (auto-detect format).
+// The privateKey can be either PKCS#1 or PKCS#8 format.
+// Uses SHA-256 as the hash function by default.
+func DecryptOAEP(cipherText, privateKey []byte) ([]byte, error) {
+	return DecryptOAEPWithHash(cipherText, privateKey, nil, sha256.New())
+}
+
+// DecryptOAEPWithHash decrypts data with private key using OAEP padding with custom hash.
+// The privateKey can be either PKCS#1 or PKCS#8 format.
+// The label parameter must match the label used during encryption (nil if not used).
+// The hash parameter must match the hash function used during encryption.
+func DecryptOAEPWithHash(cipherText, privateKey, label []byte, hash hash.Hash) ([]byte, error) {
+	block, _ := pem.Decode(privateKey)
+	if block == nil {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "invalid private key")
+	}
+
+	// Try PKCS#8 first
+	priv, err := x509.ParsePKCS8PrivateKey(block.Bytes)
+	if err != nil {
+		// Try PKCS#1
+		priv, err = x509.ParsePKCS1PrivateKey(block.Bytes)
+		if err != nil {
+			return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to parse private key")
+		}
+	}
+
+	rsaPriv, ok := priv.(*rsa.PrivateKey)
+	if !ok {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "not an RSA private key")
+	}
+
+	return rsa.DecryptOAEP(hash, rand.Reader, rsaPriv, cipherText, label)
+}
+
+// EncryptOAEPBase64 encrypts data with public key using OAEP padding
+// and returns base64-encoded result.
+func EncryptOAEPBase64(plainText []byte, publicKeyBase64 string) (string, error) {
+	publicKey, err := base64.StdEncoding.DecodeString(publicKeyBase64)
+	if err != nil {
+		return "", gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode public key")
+	}
+
+	encrypted, err := EncryptOAEP(plainText, publicKey)
+	if err != nil {
+		return "", err
+	}
+
+	return base64.StdEncoding.EncodeToString(encrypted), nil
+}
+
+// DecryptOAEPBase64 decrypts base64-encoded data with private key using OAEP padding.
+func DecryptOAEPBase64(cipherTextBase64, privateKeyBase64 string) ([]byte, error) {
+	privateKey, err := base64.StdEncoding.DecodeString(privateKeyBase64)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode private key")
+	}
+
+	cipherText, err := base64.StdEncoding.DecodeString(cipherTextBase64)
+	if err != nil {
+		return nil, gerror.WrapCode(gcode.CodeInvalidParameter, err, "failed to decode cipher text")
+	}
+
+	return DecryptOAEP(cipherText, privateKey)
+}
diff --git a/crypto/grsa/grsa_z_unit_test.go b/crypto/grsa/grsa_z_unit_test.go
new file mode 100644
index 000000000..e8afc315d
--- /dev/null
+++ b/crypto/grsa/grsa_z_unit_test.go
@@ -0,0 +1,1058 @@
+// 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 grsa_test
+
+import (
+	"encoding/base64"
+	"testing"
+
+	"github.com/gogf/gf/v2/crypto/grsa"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func TestEncryptDecrypt(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate a key pair for testing
+		privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+		t.AssertNE(privateKey, nil)
+		t.AssertNE(publicKey, nil)
+
+		// Test data to encrypt
+		plainText := []byte("Hello, World!")
+
+		// Encrypt with public key
+		cipherText, err := grsa.Encrypt(plainText, publicKey)
+		t.AssertNil(err)
+		t.AssertNE(cipherText, nil)
+
+		// Decrypt with private key
+		decryptedText, err := grsa.Decrypt(cipherText, privateKey)
+		t.AssertNil(err)
+		t.Assert(string(decryptedText), string(plainText))
+	})
+}
+
+func TestEncryptDecryptBase64(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate a key pair for testing
+		privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+		t.AssertNE(privateKey, nil)
+		t.AssertNE(publicKey, nil)
+
+		// Encode keys to base64
+		privateKeyBase64 := encodeToBase64(privateKey)
+		publicKeyBase64 := encodeToBase64(publicKey)
+
+		// Test data to encrypt
+		plainText := []byte("Hello, Base64 World!")
+
+		// Encrypt with public key
+		cipherTextBase64, err := grsa.EncryptBase64(plainText, publicKeyBase64)
+		t.AssertNil(err)
+		t.AssertNE(cipherTextBase64, "")
+
+		// Decrypt with private key
+		decryptedText, err := grsa.DecryptBase64(cipherTextBase64, privateKeyBase64)
+		t.AssertNil(err)
+		t.Assert(string(decryptedText), string(plainText))
+	})
+}
+
+func TestGenerateKeyPair(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test generating a 2048-bit RSA key pair
+		privateKey, publicKey, err := grsa.GenerateKeyPair(2048)
+		t.AssertNil(err)
+		t.AssertNE(privateKey, nil)
+		t.AssertNE(publicKey, nil)
+
+		// Check if keys are in correct format
+		privateKeyType, err := grsa.GetPrivateKeyType(privateKey)
+		t.AssertNil(err)
+		t.Assert(privateKeyType, "PKCS#1")
+
+		// Test with 1024-bit key for faster test execution only.
+		// Note: 1024-bit keys are NOT secure for production use.
+		// Always use at least 2048-bit keys in production.
+		privateKey, publicKey, err = grsa.GenerateKeyPair(1024)
+		t.AssertNil(err)
+		t.AssertNE(privateKey, nil)
+		t.AssertNE(publicKey, nil)
+	})
+}
+
+func TestGenerateKeyPairPKCS8(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test generating a 2048-bit RSA key pair in PKCS#8 format
+		privateKey, publicKey, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+		t.AssertNE(privateKey, nil)
+		t.AssertNE(publicKey, nil)
+
+		// Check if keys are in correct format
+		privateKeyType, err := grsa.GetPrivateKeyType(privateKey)
+		t.AssertNil(err)
+		t.Assert(privateKeyType, "PKCS#8")
+
+		// Test with 1024-bit key for faster test execution only.
+		// Note: 1024-bit keys are NOT secure for production use.
+		privateKey, publicKey, err = grsa.GenerateKeyPairPKCS8(1024)
+		t.AssertNil(err)
+		t.AssertNE(privateKey, nil)
+		t.AssertNE(publicKey, nil)
+	})
+}
+
+func TestEncryptAndDecryptPKCS(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate both types of key pairs for testing
+		privateKey1, publicKey1, err := grsa.GenerateKeyPair(2048)
+		t.AssertNil(err)
+
+		privateKey8, publicKey8, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+
+		// Test data to encrypt
+		plainText := []byte("Hello, Mixed Formats!")
+
+		// Test general encrypt/decrypt with PKCS#1 keys
+		cipherText, err := grsa.Encrypt(plainText, publicKey1)
+		t.AssertNil(err)
+		t.AssertNE(cipherText, nil)
+
+		decryptedText, err := grsa.Decrypt(cipherText, privateKey1)
+		t.AssertNil(err)
+		t.Assert(string(decryptedText), string(plainText))
+
+		// Test general encrypt/decrypt with PKCS#8 keys
+		cipherText8, err := grsa.Encrypt(plainText, publicKey8)
+		t.AssertNil(err)
+		t.AssertNE(cipherText8, nil)
+
+		decryptedText8, err := grsa.Decrypt(cipherText8, privateKey8)
+		t.AssertNil(err)
+		t.Assert(string(decryptedText8), string(plainText))
+	})
+}
+
+func TestGetPrivateKeyType(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate both PKCS#1 and PKCS#8 key pairs
+		// Note: 1024-bit keys used here for faster test execution only.
+		// NOT secure for production use.
+		privKey1, _, err := grsa.GenerateKeyPair(1024)
+		t.AssertNil(err)
+
+		privKey8, _, err := grsa.GenerateKeyPairPKCS8(1024)
+		t.AssertNil(err)
+
+		// Check types
+		keyType1, err := grsa.GetPrivateKeyType(privKey1)
+		t.AssertNil(err)
+		t.Assert(keyType1, "PKCS#1")
+
+		keyType8, err := grsa.GetPrivateKeyType(privKey8)
+		t.AssertNil(err)
+		t.Assert(keyType8, "PKCS#8")
+	})
+}
+
+func TestEncryptPKCS1(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate a key pair for testing (PKCS#1 format)
+		privateKey, publicKey, err := grsa.GenerateKeyPair(2048)
+		t.AssertNil(err)
+		t.AssertNE(privateKey, nil)
+		t.AssertNE(publicKey, nil)
+
+		// Test data to encrypt
+		plainText := []byte("Hello, PKCS#1 World!")
+
+		// Encrypt with public key using PKCS#1 format specifically
+		cipherText, err := grsa.EncryptPKCS1(plainText, publicKey)
+		t.AssertNil(err)
+		t.AssertNE(cipherText, nil)
+
+		// Decrypt with private key using PKCS#1 format specifically
+		decryptedText, err := grsa.DecryptPKCS1(cipherText, privateKey)
+		t.AssertNil(err)
+		t.Assert(string(decryptedText), string(plainText))
+	})
+}
+
+func TestEncryptPKCS1Base64(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate a key pair for testing
+		privateKey, publicKey, err := grsa.GenerateKeyPair(2048)
+		t.AssertNil(err)
+		t.AssertNE(privateKey, nil)
+		t.AssertNE(publicKey, nil)
+
+		// Encode keys to base64
+		privateKeyBase64 := encodeToBase64(privateKey)
+		publicKeyBase64 := encodeToBase64(publicKey)
+
+		// Test data to encrypt
+		plainText := []byte("Hello, PKCS#1 Base64 World!")
+
+		// Encrypt with public key using PKCS#1 format specifically
+		cipherTextBase64, err := grsa.EncryptPKCS1Base64(plainText, publicKeyBase64)
+		t.AssertNil(err)
+		t.AssertNE(cipherTextBase64, "")
+
+		// Decrypt with private key using PKCS#1 format specifically
+		decryptedText, err := grsa.DecryptPKCS1Base64(cipherTextBase64, privateKeyBase64)
+		t.AssertNil(err)
+		t.Assert(string(decryptedText), string(plainText))
+	})
+}
+
+// Helper function to encode to base64
+func encodeToBase64(data []byte) string {
+	return base64.StdEncoding.EncodeToString(data)
+}
+
+func TestEncryptWithInvalidPublicKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		plainText := []byte("Hello, World!")
+
+		// Test with invalid public key
+		_, err := grsa.Encrypt(plainText, []byte("invalid key"))
+		t.AssertNE(err, nil)
+
+		// Test with empty public key
+		_, err = grsa.Encrypt(plainText, []byte{})
+		t.AssertNE(err, nil)
+
+		// Test with nil public key
+		_, err = grsa.Encrypt(plainText, nil)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestDecryptWithInvalidPrivateKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate a valid key pair and encrypt some data
+		privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+
+		plainText := []byte("Hello, World!")
+		cipherText, err := grsa.Encrypt(plainText, publicKey)
+		t.AssertNil(err)
+
+		// Test decryption with invalid private key
+		_, err = grsa.Decrypt(cipherText, []byte("invalid key"))
+		t.AssertNE(err, nil)
+
+		// Test decryption with empty private key
+		_, err = grsa.Decrypt(cipherText, []byte{})
+		t.AssertNE(err, nil)
+
+		// Test decryption with wrong private key
+		wrongPrivKey, _, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+		_, err = grsa.Decrypt(cipherText, wrongPrivKey)
+		t.AssertNE(err, nil)
+
+		// Verify correct decryption still works
+		decrypted, err := grsa.Decrypt(cipherText, privateKey)
+		t.AssertNil(err)
+		t.Assert(string(decrypted), string(plainText))
+	})
+}
+
+func TestEncryptWithOversizedPlaintext(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate a 2048-bit key pair
+		_, publicKey, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+
+		// For 2048-bit key with PKCS#1 v1.5 padding, max size is 256 - 11 = 245 bytes
+		// Create plaintext that exceeds this limit
+		oversizedPlainText := make([]byte, 300)
+		for i := range oversizedPlainText {
+			oversizedPlainText[i] = 'A'
+		}
+
+		// Encryption should fail with oversized plaintext
+		_, err = grsa.Encrypt(oversizedPlainText, publicKey)
+		t.AssertNE(err, nil)
+
+		// Verify that valid size plaintext works
+		validPlainText := make([]byte, 200)
+		for i := range validPlainText {
+			validPlainText[i] = 'B'
+		}
+		_, err = grsa.Encrypt(validPlainText, publicKey)
+		t.AssertNil(err)
+	})
+}
+
+func TestDecryptWithCorruptedCiphertext(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+
+		plainText := []byte("Hello, World!")
+		cipherText, err := grsa.Encrypt(plainText, publicKey)
+		t.AssertNil(err)
+
+		// Corrupt the ciphertext
+		corruptedCipherText := make([]byte, len(cipherText))
+		copy(corruptedCipherText, cipherText)
+		corruptedCipherText[0] ^= 0xFF
+		corruptedCipherText[len(corruptedCipherText)-1] ^= 0xFF
+
+		// Decryption should fail with corrupted ciphertext
+		_, err = grsa.Decrypt(corruptedCipherText, privateKey)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestGetPrivateKeyTypeWithInvalidKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test with invalid key
+		_, err := grsa.GetPrivateKeyType([]byte("invalid key"))
+		t.AssertNE(err, nil)
+
+		// Test with empty key
+		_, err = grsa.GetPrivateKeyType([]byte{})
+		t.AssertNE(err, nil)
+
+		// Test with nil key
+		_, err = grsa.GetPrivateKeyType(nil)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestBase64FunctionsWithInvalidInput(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		plainText := []byte("Hello, World!")
+
+		// Test EncryptBase64 with invalid base64 public key
+		_, err := grsa.EncryptBase64(plainText, "not-valid-base64!!!")
+		t.AssertNE(err, nil)
+
+		// Test DecryptBase64 with invalid base64 private key
+		_, err = grsa.DecryptBase64("validbase64==", "not-valid-base64!!!")
+		t.AssertNE(err, nil)
+
+		// Test DecryptBase64 with invalid base64 ciphertext
+		privateKey, _, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+		privateKeyBase64 := encodeToBase64(privateKey)
+		_, err = grsa.DecryptBase64("not-valid-base64!!!", privateKeyBase64)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestDecryptPKCS8WithPKCS1Key(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate PKCS#1 key pair
+		privateKey1, publicKey1, err := grsa.GenerateKeyPair(2048)
+		t.AssertNil(err)
+
+		plainText := []byte("Hello, World!")
+		cipherText, err := grsa.EncryptPKCS1(plainText, publicKey1)
+		t.AssertNil(err)
+
+		// DecryptPKCS8 should fail with PKCS#1 private key (no fallback)
+		_, err = grsa.DecryptPKCS8(cipherText, privateKey1)
+		t.AssertNE(err, nil)
+
+		// DecryptPKCS1 should work
+		decrypted, err := grsa.DecryptPKCS1(cipherText, privateKey1)
+		t.AssertNil(err)
+		t.Assert(string(decrypted), string(plainText))
+	})
+}
+
+func TestEncryptPKIX(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate PKCS#8 key pair (which uses PKIX public key format)
+		privateKey8, publicKey8, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+
+		plainText := []byte("Hello, PKIX World!")
+
+		// Encrypt with PKIX public key
+		cipherText, err := grsa.EncryptPKIX(plainText, publicKey8)
+		t.AssertNil(err)
+		t.AssertNE(cipherText, nil)
+
+		// Decrypt with PKCS#8 private key
+		decrypted, err := grsa.DecryptPKCS8(cipherText, privateKey8)
+		t.AssertNil(err)
+		t.Assert(string(decrypted), string(plainText))
+
+		// Test with invalid public key
+		_, err = grsa.EncryptPKIX(plainText, []byte("invalid key"))
+		t.AssertNE(err, nil)
+
+		// Test with PKCS#1 public key (should fail for EncryptPKIX)
+		_, publicKey1, err := grsa.GenerateKeyPair(2048)
+		t.AssertNil(err)
+		_, err = grsa.EncryptPKIX(plainText, publicKey1)
+		t.AssertNE(err, nil)
+
+		// Test oversized plaintext
+		oversizedPlainText := make([]byte, 300)
+		_, err = grsa.EncryptPKIX(oversizedPlainText, publicKey8)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestEncryptPKCS8Alias(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate PKCS#8 key pair
+		privateKey8, publicKey8, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+
+		plainText := []byte("Hello, PKCS8 Alias!")
+
+		// EncryptPKCS8 is an alias for EncryptPKIX
+		cipherText, err := grsa.EncryptPKCS8(plainText, publicKey8)
+		t.AssertNil(err)
+		t.AssertNE(cipherText, nil)
+
+		// Decrypt should work
+		decrypted, err := grsa.DecryptPKCS8(cipherText, privateKey8)
+		t.AssertNil(err)
+		t.Assert(string(decrypted), string(plainText))
+	})
+}
+
+func TestEncryptPKIXBase64(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate PKCS#8 key pair
+		privateKey8, publicKey8, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+
+		privateKeyBase64 := encodeToBase64(privateKey8)
+		publicKeyBase64 := encodeToBase64(publicKey8)
+
+		plainText := []byte("Hello, PKIX Base64!")
+
+		// Encrypt with PKIX public key
+		cipherTextBase64, err := grsa.EncryptPKIXBase64(plainText, publicKeyBase64)
+		t.AssertNil(err)
+		t.AssertNE(cipherTextBase64, "")
+
+		// Decrypt with PKCS#8 private key
+		decrypted, err := grsa.DecryptPKCS8Base64(cipherTextBase64, privateKeyBase64)
+		t.AssertNil(err)
+		t.Assert(string(decrypted), string(plainText))
+
+		// Test with invalid base64 public key
+		_, err = grsa.EncryptPKIXBase64(plainText, "not-valid-base64!!!")
+		t.AssertNE(err, nil)
+
+		// Test with invalid public key content
+		_, err = grsa.EncryptPKIXBase64(plainText, encodeToBase64([]byte("invalid key")))
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestEncryptPKCS8Base64Alias(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate PKCS#8 key pair
+		privateKey8, publicKey8, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+
+		privateKeyBase64 := encodeToBase64(privateKey8)
+		publicKeyBase64 := encodeToBase64(publicKey8)
+
+		plainText := []byte("Hello, PKCS8 Base64 Alias!")
+
+		// EncryptPKCS8Base64 is an alias for EncryptPKIXBase64
+		cipherTextBase64, err := grsa.EncryptPKCS8Base64(plainText, publicKeyBase64)
+		t.AssertNil(err)
+		t.AssertNE(cipherTextBase64, "")
+
+		// Decrypt should work
+		decrypted, err := grsa.DecryptPKCS8Base64(cipherTextBase64, privateKeyBase64)
+		t.AssertNil(err)
+		t.Assert(string(decrypted), string(plainText))
+	})
+}
+
+func TestDecryptPKCS8Base64(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate PKCS#8 key pair
+		privateKey8, publicKey8, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+
+		privateKeyBase64 := encodeToBase64(privateKey8)
+		publicKeyBase64 := encodeToBase64(publicKey8)
+
+		plainText := []byte("Hello, DecryptPKCS8Base64!")
+
+		// Encrypt
+		cipherTextBase64, err := grsa.EncryptPKIXBase64(plainText, publicKeyBase64)
+		t.AssertNil(err)
+
+		// Decrypt
+		decrypted, err := grsa.DecryptPKCS8Base64(cipherTextBase64, privateKeyBase64)
+		t.AssertNil(err)
+		t.Assert(string(decrypted), string(plainText))
+
+		// Test with invalid base64 private key
+		_, err = grsa.DecryptPKCS8Base64(cipherTextBase64, "not-valid-base64!!!")
+		t.AssertNE(err, nil)
+
+		// Test with invalid base64 ciphertext
+		_, err = grsa.DecryptPKCS8Base64("not-valid-base64!!!", privateKeyBase64)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestGetPrivateKeyTypeBase64(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate both PKCS#1 and PKCS#8 key pairs
+		privKey1, _, err := grsa.GenerateKeyPair(2048)
+		t.AssertNil(err)
+
+		privKey8, _, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+
+		// Check types via base64
+		keyType1, err := grsa.GetPrivateKeyTypeBase64(encodeToBase64(privKey1))
+		t.AssertNil(err)
+		t.Assert(keyType1, "PKCS#1")
+
+		keyType8, err := grsa.GetPrivateKeyTypeBase64(encodeToBase64(privKey8))
+		t.AssertNil(err)
+		t.Assert(keyType8, "PKCS#8")
+
+		// Test with invalid base64
+		_, err = grsa.GetPrivateKeyTypeBase64("not-valid-base64!!!")
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestExtractPKCS1PublicKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate PKCS#1 key pair
+		privateKey, publicKey, err := grsa.GenerateKeyPair(2048)
+		t.AssertNil(err)
+
+		// Extract public key from private key
+		extractedPublicKey, err := grsa.ExtractPKCS1PublicKey(privateKey)
+		t.AssertNil(err)
+		t.AssertNE(extractedPublicKey, nil)
+
+		// The extracted public key should work for encryption
+		plainText := []byte("Hello, Extracted Key!")
+		cipherText, err := grsa.EncryptPKCS1(plainText, extractedPublicKey)
+		t.AssertNil(err)
+
+		// Decrypt with original private key
+		decrypted, err := grsa.DecryptPKCS1(cipherText, privateKey)
+		t.AssertNil(err)
+		t.Assert(string(decrypted), string(plainText))
+
+		// Compare extracted key with original (they should be equivalent)
+		cipherText2, err := grsa.EncryptPKCS1(plainText, publicKey)
+		t.AssertNil(err)
+		decrypted2, err := grsa.DecryptPKCS1(cipherText2, privateKey)
+		t.AssertNil(err)
+		t.Assert(string(decrypted2), string(plainText))
+
+		// Test with invalid private key
+		_, err = grsa.ExtractPKCS1PublicKey([]byte("invalid key"))
+		t.AssertNE(err, nil)
+
+		// Test with PKCS#8 private key (should fail)
+		privateKey8, _, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+		_, err = grsa.ExtractPKCS1PublicKey(privateKey8)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestDecryptPKCS1WithInvalidKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		privateKey, publicKey, err := grsa.GenerateKeyPair(2048)
+		t.AssertNil(err)
+
+		plainText := []byte("Hello, World!")
+		cipherText, err := grsa.EncryptPKCS1(plainText, publicKey)
+		t.AssertNil(err)
+
+		// Test with invalid private key
+		_, err = grsa.DecryptPKCS1(cipherText, []byte("invalid key"))
+		t.AssertNE(err, nil)
+
+		// Test with PKCS#8 private key (should fail for DecryptPKCS1)
+		privateKey8, _, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+		_, err = grsa.DecryptPKCS1(cipherText, privateKey8)
+		t.AssertNE(err, nil)
+
+		// Verify correct decryption works
+		decrypted, err := grsa.DecryptPKCS1(cipherText, privateKey)
+		t.AssertNil(err)
+		t.Assert(string(decrypted), string(plainText))
+	})
+}
+
+func TestDecryptPKCS8WithInvalidKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		privateKey8, publicKey8, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+
+		plainText := []byte("Hello, World!")
+		cipherText, err := grsa.EncryptPKIX(plainText, publicKey8)
+		t.AssertNil(err)
+
+		// Test with invalid private key
+		_, err = grsa.DecryptPKCS8(cipherText, []byte("invalid key"))
+		t.AssertNE(err, nil)
+
+		// Verify correct decryption works
+		decrypted, err := grsa.DecryptPKCS8(cipherText, privateKey8)
+		t.AssertNil(err)
+		t.Assert(string(decrypted), string(plainText))
+	})
+}
+
+func TestEncryptPKCS1WithInvalidKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		plainText := []byte("Hello, World!")
+
+		// Test with invalid public key
+		_, err := grsa.EncryptPKCS1(plainText, []byte("invalid key"))
+		t.AssertNE(err, nil)
+
+		// Test with PKCS#8 public key (should fail for EncryptPKCS1)
+		_, publicKey8, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+		_, err = grsa.EncryptPKCS1(plainText, publicKey8)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestEncryptPKCS1WithOversizedPlaintext(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		_, publicKey, err := grsa.GenerateKeyPair(2048)
+		t.AssertNil(err)
+
+		// Create oversized plaintext
+		oversizedPlainText := make([]byte, 300)
+		_, err = grsa.EncryptPKCS1(oversizedPlainText, publicKey)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestEncryptPKCS1Base64WithInvalidInput(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		plainText := []byte("Hello, World!")
+
+		// Test with invalid base64 public key
+		_, err := grsa.EncryptPKCS1Base64(plainText, "not-valid-base64!!!")
+		t.AssertNE(err, nil)
+
+		// Test with invalid public key content
+		_, err = grsa.EncryptPKCS1Base64(plainText, encodeToBase64([]byte("invalid key")))
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestDecryptPKCS1Base64WithInvalidInput(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		privateKey, publicKey, err := grsa.GenerateKeyPair(2048)
+		t.AssertNil(err)
+
+		privateKeyBase64 := encodeToBase64(privateKey)
+		publicKeyBase64 := encodeToBase64(publicKey)
+
+		plainText := []byte("Hello, World!")
+		cipherTextBase64, err := grsa.EncryptPKCS1Base64(plainText, publicKeyBase64)
+		t.AssertNil(err)
+
+		// Test with invalid base64 private key
+		_, err = grsa.DecryptPKCS1Base64(cipherTextBase64, "not-valid-base64!!!")
+		t.AssertNE(err, nil)
+
+		// Test with invalid base64 ciphertext
+		_, err = grsa.DecryptPKCS1Base64("not-valid-base64!!!", privateKeyBase64)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestEncryptWithNonRSAPublicKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a PEM block that is valid but not an RSA key
+		// This tests the "not an RSA public key" error path
+		// We use a valid PEM structure but with invalid content
+		invalidPEM := []byte(`-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE
+-----END PUBLIC KEY-----`)
+
+		plainText := []byte("Hello, World!")
+		_, err := grsa.Encrypt(plainText, invalidPEM)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestDecryptWithNonRSAPrivateKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a PEM block that is valid but not an RSA key
+		invalidPEM := []byte(`-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQg
+-----END PRIVATE KEY-----`)
+
+		cipherText := []byte("some cipher text")
+		_, err := grsa.Decrypt(cipherText, invalidPEM)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestEncryptBase64WithInvalidPublicKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		plainText := []byte("Hello, World!")
+
+		// Test with valid base64 but invalid key content
+		invalidKeyBase64 := encodeToBase64([]byte("invalid key"))
+		_, err := grsa.EncryptBase64(plainText, invalidKeyBase64)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestGetPrivateKeyTypeWithNonRSAKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a valid PKCS#8 PEM but with non-RSA content (EC key)
+		// This tests the "not an RSA private key" error path in GetPrivateKeyType
+		ecPrivateKeyPEM := []byte(`-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgVcB/UNPczVP6jE4Z
+p7v6qYQXsKQZLJGBJKKnUWuHb6+hRANCAASYn3k2T4VqPt1HVAK5Rc7rMb6lGOzF
+v0MVLfCgPKANNGdBvGPmaSLFIxGMNL0v1C2RRvqqEu/vL3POoaqfMJhw
+-----END PRIVATE KEY-----`)
+
+		_, err := grsa.GetPrivateKeyType(ecPrivateKeyPEM)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestDecryptPKCS8WithNonRSAKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a valid PKCS#8 PEM but with non-RSA content (EC key)
+		ecPrivateKeyPEM := []byte(`-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgVcB/UNPczVP6jE4Z
+p7v6qYQXsKQZLJGBJKKnUWuHb6+hRANCAASYn3k2T4VqPt1HVAK5Rc7rMb6lGOzF
+v0MVLfCgPKANNGdBvGPmaSLFIxGMNL0v1C2RRvqqEu/vL3POoaqfMJhw
+-----END PRIVATE KEY-----`)
+
+		cipherText := []byte("some cipher text")
+		_, err := grsa.DecryptPKCS8(cipherText, ecPrivateKeyPEM)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestEncryptPKIXWithNonRSAKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a valid PKIX PEM but with non-RSA content (EC key)
+		ecPublicKeyPEM := []byte(`-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmJ95Nk+Faj7dR1QCuUXO6zG+pRjs
+xb9DFS3woDygDTRnQbxj5mkixSMRjDS9L9QtkUb6qhLv7y9zzqGqnzCYcA==
+-----END PUBLIC KEY-----`)
+
+		plainText := []byte("Hello, World!")
+		_, err := grsa.EncryptPKIX(plainText, ecPublicKeyPEM)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestEncryptWithNonRSAPKIXKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a valid PKIX PEM but with non-RSA content (EC key)
+		// This tests the "not an RSA public key" error path in Encrypt
+		ecPublicKeyPEM := []byte(`-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmJ95Nk+Faj7dR1QCuUXO6zG+pRjs
+xb9DFS3woDygDTRnQbxj5mkixSMRjDS9L9QtkUb6qhLv7y9zzqGqnzCYcA==
+-----END PUBLIC KEY-----`)
+
+		plainText := []byte("Hello, World!")
+		_, err := grsa.Encrypt(plainText, ecPublicKeyPEM)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestDecryptWithNonRSAPKCS8Key(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a valid PKCS#8 PEM but with non-RSA content (EC key)
+		// This tests the "not an RSA private key" error path in Decrypt
+		ecPrivateKeyPEM := []byte(`-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgVcB/UNPczVP6jE4Z
+p7v6qYQXsKQZLJGBJKKnUWuHb6+hRANCAASYn3k2T4VqPt1HVAK5Rc7rMb6lGOzF
+v0MVLfCgPKANNGdBvGPmaSLFIxGMNL0v1C2RRvqqEu/vL3POoaqfMJhw
+-----END PRIVATE KEY-----`)
+
+		cipherText := []byte("some cipher text")
+		_, err := grsa.Decrypt(cipherText, ecPrivateKeyPEM)
+		t.AssertNE(err, nil)
+	})
+}
+
+// ============================================================================
+// OAEP Encryption/Decryption Tests
+// ============================================================================
+
+func TestEncryptDecryptOAEP(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate a key pair for testing
+		privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+		t.AssertNE(privateKey, nil)
+		t.AssertNE(publicKey, nil)
+
+		// Test data to encrypt
+		plainText := []byte("Hello, OAEP World!")
+
+		// Encrypt with public key using OAEP
+		cipherText, err := grsa.EncryptOAEP(plainText, publicKey)
+		t.AssertNil(err)
+		t.AssertNE(cipherText, nil)
+
+		// Decrypt with private key using OAEP
+		decryptedText, err := grsa.DecryptOAEP(cipherText, privateKey)
+		t.AssertNil(err)
+		t.Assert(string(decryptedText), string(plainText))
+	})
+}
+
+func TestEncryptDecryptOAEPWithPKCS8Keys(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate a PKCS#8 key pair for testing
+		privateKey8, publicKey8, err := grsa.GenerateKeyPairPKCS8(2048)
+		t.AssertNil(err)
+		t.AssertNE(privateKey8, nil)
+		t.AssertNE(publicKey8, nil)
+
+		// Test data to encrypt
+		plainText := []byte("Hello, OAEP PKCS#8 World!")
+
+		// Encrypt with PKIX public key using OAEP
+		cipherText, err := grsa.EncryptOAEP(plainText, publicKey8)
+		t.AssertNil(err)
+		t.AssertNE(cipherText, nil)
+
+		// Decrypt with PKCS#8 private key using OAEP
+		decryptedText, err := grsa.DecryptOAEP(cipherText, privateKey8)
+		t.AssertNil(err)
+		t.Assert(string(decryptedText), string(plainText))
+	})
+}
+
+func TestEncryptDecryptOAEPBase64(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate a key pair for testing
+		privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+
+		// Encode keys to base64
+		privateKeyBase64 := encodeToBase64(privateKey)
+		publicKeyBase64 := encodeToBase64(publicKey)
+
+		// Test data to encrypt
+		plainText := []byte("Hello, OAEP Base64 World!")
+
+		// Encrypt with public key using OAEP
+		cipherTextBase64, err := grsa.EncryptOAEPBase64(plainText, publicKeyBase64)
+		t.AssertNil(err)
+		t.AssertNE(cipherTextBase64, "")
+
+		// Decrypt with private key using OAEP
+		decryptedText, err := grsa.DecryptOAEPBase64(cipherTextBase64, privateKeyBase64)
+		t.AssertNil(err)
+		t.Assert(string(decryptedText), string(plainText))
+	})
+}
+
+func TestEncryptOAEPWithInvalidPublicKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		plainText := []byte("Hello, World!")
+
+		// Test with invalid public key
+		_, err := grsa.EncryptOAEP(plainText, []byte("invalid key"))
+		t.AssertNE(err, nil)
+
+		// Test with empty public key
+		_, err = grsa.EncryptOAEP(plainText, []byte{})
+		t.AssertNE(err, nil)
+
+		// Test with nil public key
+		_, err = grsa.EncryptOAEP(plainText, nil)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestDecryptOAEPWithInvalidPrivateKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate a valid key pair and encrypt some data
+		privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+
+		plainText := []byte("Hello, World!")
+		cipherText, err := grsa.EncryptOAEP(plainText, publicKey)
+		t.AssertNil(err)
+
+		// Test decryption with invalid private key
+		_, err = grsa.DecryptOAEP(cipherText, []byte("invalid key"))
+		t.AssertNE(err, nil)
+
+		// Test decryption with empty private key
+		_, err = grsa.DecryptOAEP(cipherText, []byte{})
+		t.AssertNE(err, nil)
+
+		// Test decryption with wrong private key
+		wrongPrivKey, _, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+		_, err = grsa.DecryptOAEP(cipherText, wrongPrivKey)
+		t.AssertNE(err, nil)
+
+		// Verify correct decryption still works
+		decrypted, err := grsa.DecryptOAEP(cipherText, privateKey)
+		t.AssertNil(err)
+		t.Assert(string(decrypted), string(plainText))
+	})
+}
+
+func TestEncryptOAEPWithOversizedPlaintext(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Generate a 2048-bit key pair
+		_, publicKey, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+
+		// For 2048-bit key with OAEP SHA-256 padding, max size is 256 - 2*32 - 2 = 190 bytes
+		// Create plaintext that exceeds this limit
+		oversizedPlainText := make([]byte, 200)
+		for i := range oversizedPlainText {
+			oversizedPlainText[i] = 'A'
+		}
+
+		// Encryption should fail with oversized plaintext
+		_, err = grsa.EncryptOAEP(oversizedPlainText, publicKey)
+		t.AssertNE(err, nil)
+
+		// Verify that valid size plaintext works
+		validPlainText := make([]byte, 150)
+		for i := range validPlainText {
+			validPlainText[i] = 'B'
+		}
+		_, err = grsa.EncryptOAEP(validPlainText, publicKey)
+		t.AssertNil(err)
+	})
+}
+
+func TestDecryptOAEPWithCorruptedCiphertext(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+
+		plainText := []byte("Hello, World!")
+		cipherText, err := grsa.EncryptOAEP(plainText, publicKey)
+		t.AssertNil(err)
+
+		// Corrupt the ciphertext
+		corruptedCipherText := make([]byte, len(cipherText))
+		copy(corruptedCipherText, cipherText)
+		corruptedCipherText[0] ^= 0xFF
+		corruptedCipherText[len(corruptedCipherText)-1] ^= 0xFF
+
+		// Decryption should fail with corrupted ciphertext
+		_, err = grsa.DecryptOAEP(corruptedCipherText, privateKey)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestEncryptOAEPBase64WithInvalidInput(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		plainText := []byte("Hello, World!")
+
+		// Test with invalid base64 public key
+		_, err := grsa.EncryptOAEPBase64(plainText, "not-valid-base64!!!")
+		t.AssertNE(err, nil)
+
+		// Test with valid base64 but invalid key content
+		invalidKeyBase64 := encodeToBase64([]byte("invalid key"))
+		_, err = grsa.EncryptOAEPBase64(plainText, invalidKeyBase64)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestDecryptOAEPBase64WithInvalidInput(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+
+		privateKeyBase64 := encodeToBase64(privateKey)
+		publicKeyBase64 := encodeToBase64(publicKey)
+
+		plainText := []byte("Hello, World!")
+		cipherTextBase64, err := grsa.EncryptOAEPBase64(plainText, publicKeyBase64)
+		t.AssertNil(err)
+
+		// Test with invalid base64 private key
+		_, err = grsa.DecryptOAEPBase64(cipherTextBase64, "not-valid-base64!!!")
+		t.AssertNE(err, nil)
+
+		// Test with invalid base64 ciphertext
+		_, err = grsa.DecryptOAEPBase64("not-valid-base64!!!", privateKeyBase64)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestEncryptOAEPWithNonRSAPublicKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a valid PKIX PEM but with non-RSA content (EC key)
+		ecPublicKeyPEM := []byte(`-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmJ95Nk+Faj7dR1QCuUXO6zG+pRjs
+xb9DFS3woDygDTRnQbxj5mkixSMRjDS9L9QtkUb6qhLv7y9zzqGqnzCYcA==
+-----END PUBLIC KEY-----`)
+
+		plainText := []byte("Hello, World!")
+		_, err := grsa.EncryptOAEP(plainText, ecPublicKeyPEM)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestDecryptOAEPWithNonRSAPrivateKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a valid PKCS#8 PEM but with non-RSA content (EC key)
+		ecPrivateKeyPEM := []byte(`-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgVcB/UNPczVP6jE4Z
+p7v6qYQXsKQZLJGBJKKnUWuHb6+hRANCAASYn3k2T4VqPt1HVAK5Rc7rMb6lGOzF
+v0MVLfCgPKANNGdBvGPmaSLFIxGMNL0v1C2RRvqqEu/vL3POoaqfMJhw
+-----END PRIVATE KEY-----`)
+
+		cipherText := []byte("some cipher text")
+		_, err := grsa.DecryptOAEP(cipherText, ecPrivateKeyPEM)
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestEncryptOAEPWithHashCustomHash(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// This test verifies that EncryptOAEPWithHash and DecryptOAEPWithHash work correctly
+		// with the default SHA-256 hash (via EncryptOAEP/DecryptOAEP which use sha256.New())
+		privateKey, publicKey, err := grsa.GenerateDefaultKeyPair()
+		t.AssertNil(err)
+
+		plainText := []byte("Hello, Custom Hash World!")
+
+		// Encrypt and decrypt using the default OAEP functions
+		cipherText, err := grsa.EncryptOAEP(plainText, publicKey)
+		t.AssertNil(err)
+
+		decryptedText, err := grsa.DecryptOAEP(cipherText, privateKey)
+		t.AssertNil(err)
+		t.Assert(string(decryptedText), string(plainText))
+	})
+}
diff --git a/crypto/gsha256/gsha256.go b/crypto/gsha256/gsha256.go
new file mode 100644
index 000000000..dbd85bc84
--- /dev/null
+++ b/crypto/gsha256/gsha256.go
@@ -0,0 +1,52 @@
+// 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 gsha256 provides useful API for SHA256 encryption algorithms.
+package gsha256
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"io"
+	"os"
+
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+// Encrypt encrypts any type of variable using SHA256 algorithms.
+// It uses package gconv to convert `v` to its bytes type.
+func Encrypt(v any) string {
+	bs := sha256.Sum256(gconv.Bytes(v))
+	return hex.EncodeToString(bs[:])
+}
+
+// EncryptFile encrypts file content of `path` using SHA256 algorithms.
+func EncryptFile(path string) (encrypt string, err error) {
+	f, err := os.Open(path)
+	if err != nil {
+		err = gerror.Wrapf(err, `os.Open failed for name "%s"`, path)
+		return "", err
+	}
+	defer f.Close()
+	h := sha256.New()
+	_, err = io.Copy(h, f)
+	if err != nil {
+		err = gerror.Wrap(err, `io.Copy failed`)
+		return "", err
+	}
+	return hex.EncodeToString(h.Sum(nil)), nil
+}
+
+// MustEncryptFile encrypts file content of `path` using the SHA256 algorithm.
+// It panics if any error occurs.
+func MustEncryptFile(path string) string {
+	result, err := EncryptFile(path)
+	if err != nil {
+		panic(err)
+	}
+	return result
+}
diff --git a/crypto/gsha256/gsha256_z_unit_test.go b/crypto/gsha256/gsha256_z_unit_test.go
new file mode 100644
index 000000000..bde7d03d8
--- /dev/null
+++ b/crypto/gsha256/gsha256_z_unit_test.go
@@ -0,0 +1,61 @@
+// 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.
+
+// go test *.go -bench=".*"
+
+package gsha256_test
+
+import (
+	"os"
+	"testing"
+
+	"github.com/gogf/gf/v2/crypto/gsha256"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+type user struct {
+	name     string
+	password string
+	age      int
+}
+
+func TestEncrypt(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		result := "b5568f1b35aeb9eb7528336dea6c211a2cdcec1f333d98141b8adf346717907e"
+		s := gsha256.Encrypt("pibigstar")
+		t.AssertEQ(s, result)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		user := &user{
+			name:     "派大星",
+			password: "123456",
+			age:      23,
+		}
+		result := "8e0293ca8e1860ae258a88429d3c14755712059d9562c825557a927718f574f3"
+		encrypt := gsha256.Encrypt(user)
+		t.AssertEQ(encrypt, result)
+	})
+}
+
+func TestEncryptFile(t *testing.T) {
+	path := "test.text"
+	errPath := "err.text"
+	gtest.C(t, func(t *gtest.T) {
+		result := "8fd86e81f66886d4ef7007c2df565f7f61dce2000d8b67ac7163be547c3115ef"
+		file, err := os.Create(path)
+		defer os.Remove(path)
+		defer file.Close()
+		t.AssertNil(err)
+		_, _ = file.Write([]byte("Hello Go Frame"))
+		encryptFile, err := gsha256.EncryptFile(path)
+		t.AssertNil(err)
+		t.AssertEQ(encryptFile, result)
+		// when the file is not exist,encrypt will return empty string
+		errEncrypt, err := gsha256.EncryptFile(errPath)
+		t.AssertNE(err, nil)
+		t.AssertEQ(errEncrypt, "")
+	})
+}
diff --git a/database/gdb/gdb.go b/database/gdb/gdb.go
index c19ce828d..cc99d8e5a 100644
--- a/database/gdb/gdb.go
+++ b/database/gdb/gdb.go
@@ -181,7 +181,7 @@ type DB interface {
 
 	// GetArray executes a query and returns the first column of all rows.
 	// It's useful for queries like SELECT id FROM table.
-	GetArray(ctx context.Context, sql string, args ...any) ([]Value, error)
+	GetArray(ctx context.Context, sql string, args ...any) (Array, error)
 
 	// GetCount executes a COUNT query and returns the result as an integer.
 	// It's a convenience method for counting rows.
@@ -294,6 +294,9 @@ type DB interface {
 	// SetMaxConnLifeTime sets the maximum amount of time a connection may be reused.
 	SetMaxConnLifeTime(d time.Duration)
 
+	// SetMaxIdleConnTime sets the maximum amount of time a connection may be idle before being closed.
+	SetMaxIdleConnTime(d time.Duration)
+
 	// ===========================================================================
 	// Utility methods.
 	// ===========================================================================
@@ -510,24 +513,25 @@ type StatsItem interface {
 
 // Core is the base struct for database management.
 type Core struct {
-	db            DB              // DB interface object.
-	ctx           context.Context // Context for chaining operation only. Do not set a default value in Core initialization.
-	group         string          // Configuration group name.
-	schema        string          // Custom schema for this object.
-	debug         *gtype.Bool     // Enable debug mode for the database, which can be changed in runtime.
-	cache         *gcache.Cache   // Cache manager, SQL result cache only.
-	links         *gmap.Map       // links caches all created links by node.
-	logger        glog.ILogger    // Logger for logging functionality.
-	config        *ConfigNode     // Current config node.
-	localTypeMap  *gmap.StrAnyMap // Local type map for database field type conversion.
-	dynamicConfig dynamicConfig   // Dynamic configurations, which can be changed in runtime.
-	innerMemCache *gcache.Cache   // Internal memory cache for storing temporary data.
+	db            DB                               // DB interface object.
+	ctx           context.Context                  // Context for chaining operation only. Do not set a default value in Core initialization.
+	group         string                           // Configuration group name.
+	schema        string                           // Custom schema for this object.
+	debug         *gtype.Bool                      // Enable debug mode for the database, which can be changed in runtime.
+	cache         *gcache.Cache                    // Cache manager, SQL result cache only.
+	links         *gmap.KVMap[ConfigNode, *sql.DB] // links caches all created links by node.
+	logger        glog.ILogger                     // Logger for logging functionality.
+	config        *ConfigNode                      // Current config node.
+	localTypeMap  *gmap.StrAnyMap                  // Local type map for database field type conversion.
+	dynamicConfig dynamicConfig                    // Dynamic configurations, which can be changed in runtime.
+	innerMemCache *gcache.Cache                    // Internal memory cache for storing temporary data.
 }
 
 type dynamicConfig struct {
 	MaxIdleConnCount int
 	MaxOpenConnCount int
 	MaxConnLifeTime  time.Duration
+	MaxIdleConnTime  time.Duration
 }
 
 // DoCommitInput is the input parameters for function DoCommit.
@@ -673,6 +677,9 @@ type (
 	// Value is the field value type.
 	Value = *gvar.Var
 
+	// Array is the field value array type.
+	Array = gvar.Vars
+
 	// Record is the row record of the table.
 	Record map[string]Value
 
@@ -784,28 +791,39 @@ const (
 type LocalType string
 
 const (
-	LocalTypeUndefined   LocalType = ""
-	LocalTypeString      LocalType = "string"
-	LocalTypeTime        LocalType = "time"
-	LocalTypeDate        LocalType = "date"
-	LocalTypeDatetime    LocalType = "datetime"
-	LocalTypeInt         LocalType = "int"
-	LocalTypeUint        LocalType = "uint"
-	LocalTypeInt64       LocalType = "int64"
-	LocalTypeUint64      LocalType = "uint64"
-	LocalTypeBigInt      LocalType = "bigint"
-	LocalTypeIntSlice    LocalType = "[]int"
-	LocalTypeInt64Slice  LocalType = "[]int64"
-	LocalTypeUint64Slice LocalType = "[]uint64"
-	LocalTypeStringSlice LocalType = "[]string"
-	LocalTypeInt64Bytes  LocalType = "int64-bytes"
-	LocalTypeUint64Bytes LocalType = "uint64-bytes"
-	LocalTypeFloat32     LocalType = "float32"
-	LocalTypeFloat64     LocalType = "float64"
-	LocalTypeBytes       LocalType = "[]byte"
-	LocalTypeBool        LocalType = "bool"
-	LocalTypeJson        LocalType = "json"
-	LocalTypeJsonb       LocalType = "jsonb"
+	LocalTypeUndefined    LocalType = ""
+	LocalTypeString       LocalType = "string"
+	LocalTypeTime         LocalType = "time"
+	LocalTypeDate         LocalType = "date"
+	LocalTypeDatetime     LocalType = "datetime"
+	LocalTypeInt          LocalType = "int"
+	LocalTypeUint         LocalType = "uint"
+	LocalTypeInt32        LocalType = "int32"
+	LocalTypeUint32       LocalType = "uint32"
+	LocalTypeInt64        LocalType = "int64"
+	LocalTypeUint64       LocalType = "uint64"
+	LocalTypeBigInt       LocalType = "bigint"
+	LocalTypeIntSlice     LocalType = "[]int"
+	LocalTypeUintSlice    LocalType = "[]uint"
+	LocalTypeInt32Slice   LocalType = "[]int32"
+	LocalTypeUint32Slice  LocalType = "[]uint32"
+	LocalTypeInt64Slice   LocalType = "[]int64"
+	LocalTypeUint64Slice  LocalType = "[]uint64"
+	LocalTypeStringSlice  LocalType = "[]string"
+	LocalTypeInt64Bytes   LocalType = "int64-bytes"
+	LocalTypeUint64Bytes  LocalType = "uint64-bytes"
+	LocalTypeFloat32      LocalType = "float32"
+	LocalTypeFloat64      LocalType = "float64"
+	LocalTypeFloat32Slice LocalType = "[]float32"
+	LocalTypeFloat64Slice LocalType = "[]float64"
+	LocalTypeBytes        LocalType = "[]byte"
+	LocalTypeBytesSlice   LocalType = "[][]byte"
+	LocalTypeBool         LocalType = "bool"
+	LocalTypeBoolSlice    LocalType = "[]bool"
+	LocalTypeJson         LocalType = "json"
+	LocalTypeJsonb        LocalType = "jsonb"
+	LocalTypeUUID         LocalType = "uuid.UUID"
+	LocalTypeUUIDSlice    LocalType = "[]uuid.UUID"
 )
 
 const (
@@ -849,8 +867,10 @@ const (
 )
 
 var (
+	// checker is the checker function for instances map.
+	checker = func(v DB) bool { return v == nil }
 	// instances is the management map for instances.
-	instances = gmap.NewStrAnyMap(true)
+	instances = gmap.NewKVMapWithChecker[string, DB](checker, true)
 
 	// driverMap manages all custom registered driver.
 	driverMap = map[string]Driver{}
@@ -924,6 +944,9 @@ func NewByGroup(group ...string) (db DB, err error) {
 	)
 }
 
+// linksChecker is the checker function for links map.
+var linksChecker = func(v *sql.DB) bool { return v == nil }
+
 // newDBByConfigNode creates and returns an ORM object with given configuration node and group name.
 //
 // Very Note:
@@ -940,7 +963,7 @@ func newDBByConfigNode(node *ConfigNode, group string) (db DB, err error) {
 		group:         group,
 		debug:         gtype.NewBool(),
 		cache:         gcache.New(),
-		links:         gmap.New(true),
+		links:         gmap.NewKVMapWithChecker[ConfigNode, *sql.DB](linksChecker, true),
 		logger:        glog.New(),
 		config:        node,
 		localTypeMap:  gmap.NewStrAnyMap(true),
@@ -949,6 +972,7 @@ func newDBByConfigNode(node *ConfigNode, group string) (db DB, err error) {
 			MaxIdleConnCount: node.MaxIdleConnCount,
 			MaxOpenConnCount: node.MaxOpenConnCount,
 			MaxConnLifeTime:  node.MaxConnLifeTime,
+			MaxIdleConnTime:  node.MaxIdleConnTime,
 		},
 	}
 	if v, ok := driverMap[node.Type]; ok {
@@ -971,14 +995,14 @@ func Instance(name ...string) (db DB, err error) {
 	if len(name) > 0 && name[0] != "" {
 		group = name[0]
 	}
-	v := instances.GetOrSetFuncLock(group, func() any {
+	v := instances.GetOrSetFuncLock(group, func() DB {
 		db, err = NewByGroup(group)
 		return db
 	})
 	if v != nil {
-		return v.(DB), nil
+		return v, nil
 	}
-	return
+	return nil, err
 }
 
 // getConfigNodeByGroup calculates and returns a configuration node of given group. It
@@ -1106,7 +1130,7 @@ func (c *Core) getSqlDb(master bool, schema ...string) (sqlDb *sql.DB, err error
 
 	// Cache the underlying connection pool object by node.
 	var (
-		instanceCacheFunc = func() any {
+		instanceCacheFunc = func() *sql.DB {
 			if sqlDb, err = c.db.Open(node); err != nil {
 				return nil
 			}
@@ -1128,6 +1152,9 @@ func (c *Core) getSqlDb(master bool, schema ...string) (sqlDb *sql.DB, err error
 			} else {
 				sqlDb.SetConnMaxLifetime(defaultMaxConnLifeTime)
 			}
+			if c.dynamicConfig.MaxIdleConnTime > 0 {
+				sqlDb.SetConnMaxIdleTime(c.dynamicConfig.MaxIdleConnTime)
+			}
 			return sqlDb
 		}
 		// it here uses NODE VALUE not pointer as the cache key, in case of oracle ORA-12516 error.
@@ -1135,7 +1162,7 @@ func (c *Core) getSqlDb(master bool, schema ...string) (sqlDb *sql.DB, err error
 	)
 	if instanceValue != nil && sqlDb == nil {
 		// It reads from instance map.
-		sqlDb = instanceValue.(*sql.DB)
+		sqlDb = instanceValue
 	}
 	if node.Debug {
 		c.db.SetDebug(node.Debug)
diff --git a/database/gdb/gdb_core.go b/database/gdb/gdb_core.go
index 725935265..4b23af05d 100644
--- a/database/gdb/gdb_core.go
+++ b/database/gdb/gdb_core.go
@@ -12,6 +12,7 @@ import (
 	"database/sql"
 	"fmt"
 	"reflect"
+	"sort"
 	"strings"
 
 	"github.com/gogf/gf/v2/container/gmap"
@@ -112,19 +113,17 @@ func (c *Core) Close(ctx context.Context) (err error) {
 	if err = c.cache.Close(ctx); err != nil {
 		return err
 	}
-	c.links.LockFunc(func(m map[any]any) {
+	c.links.LockFunc(func(m map[ConfigNode]*sql.DB) {
 		for k, v := range m {
-			if db, ok := v.(*sql.DB); ok {
-				err = db.Close()
-				if err != nil {
-					err = gerror.WrapCode(gcode.CodeDbOperationError, err, `db.Close failed`)
-				}
-				intlog.Printf(ctx, `close link: %s, err: %v`, k, err)
-				if err != nil {
-					return
-				}
-				delete(m, k)
+			err = v.Close()
+			if err != nil {
+				err = gerror.WrapCode(gcode.CodeDbOperationError, err, `db.Close failed`)
 			}
+			intlog.Printf(ctx, `close link: %s, err: %v`, gconv.String(k), err)
+			if err != nil {
+				return
+			}
+			delete(m, k)
 		}
 	})
 	return
@@ -174,7 +173,7 @@ func (c *Core) GetOne(ctx context.Context, sql string, args ...any) (Record, err
 
 // GetArray queries and returns data values as slice from database.
 // Note that if there are multiple columns in the result, it returns just one column values randomly.
-func (c *Core) GetArray(ctx context.Context, sql string, args ...any) ([]Value, error) {
+func (c *Core) GetArray(ctx context.Context, sql string, args ...any) (Array, error) {
 	all, err := c.db.DoSelect(ctx, nil, sql, args...)
 	if err != nil {
 		return nil, err
@@ -445,26 +444,33 @@ func (c *Core) DoInsert(ctx context.Context, link Link, table string, list List,
 	// Group the list by fields. Different fields to different list.
 	// It here uses ListMap to keep sequence for data inserting.
 	// ============================================================================================
-	var keyListMap = gmap.NewListMap()
+	var (
+		keyListMap    = gmap.NewListMap()
+		tmpKeyListMap = make(map[string]List)
+	)
 	for _, item := range list {
-		var (
-			tmpKeys              = make([]string, 0)
-			tmpKeysInSequenceStr string
-		)
+		mapLen := len(item)
+		if mapLen == 0 {
+			continue
+		}
+		tmpKeys := make([]string, 0, mapLen)
 		for k := range item {
 			tmpKeys = append(tmpKeys, k)
 		}
-		keys, err = c.fieldsToSequence(ctx, table, tmpKeys)
-		if err != nil {
-			return nil, err
+		if mapLen > 1 {
+			sort.Strings(tmpKeys)
 		}
-		tmpKeysInSequenceStr = gstr.Join(keys, ",")
-		if !keyListMap.Contains(tmpKeysInSequenceStr) {
-			keyListMap.Set(tmpKeysInSequenceStr, make(List, 0))
+		keys = tmpKeys // for fieldsToSequence
+
+		tmpKeysInSequenceStr := gstr.Join(tmpKeys, ",")
+		if tmpKeyListMapItem, ok := tmpKeyListMap[tmpKeysInSequenceStr]; ok {
+			tmpKeyListMap[tmpKeysInSequenceStr] = append(tmpKeyListMapItem, item)
+		} else {
+			tmpKeyListMap[tmpKeysInSequenceStr] = List{item}
 		}
-		tmpKeysInSequenceList := keyListMap.Get(tmpKeysInSequenceStr).(List)
-		tmpKeysInSequenceList = append(tmpKeysInSequenceList, item)
-		keyListMap.Set(tmpKeysInSequenceStr, tmpKeysInSequenceList)
+	}
+	for tmpKeysInSequenceStr, itemList := range tmpKeyListMap {
+		keyListMap.Set(tmpKeysInSequenceStr, itemList)
 	}
 	if keyListMap.Size() > 1 {
 		var (
@@ -488,6 +494,15 @@ func (c *Core) DoInsert(ctx context.Context, link Link, table string, list List,
 		return &sqlResult, err
 	}
 
+	keys, err = c.fieldsToSequence(ctx, table, keys)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(keys) == 0 {
+		return nil, gerror.NewCode(gcode.CodeInvalidParameter, "no valid data fields found in table")
+	}
+
 	// Prepare the batch result pointer.
 	var (
 		charL, charR = c.db.GetChars()
@@ -742,11 +757,35 @@ func (c *Core) GetInnerMemCache() *gcache.Cache {
 	return c.innerMemCache
 }
 
+func (c *Core) SetTableFields(ctx context.Context, table string, fields map[string]*TableField, schema ...string) error {
+	if table == "" {
+		return gerror.NewCode(gcode.CodeInvalidParameter, "table name cannot be empty")
+	}
+	charL, charR := c.db.GetChars()
+	table = gstr.Trim(table, charL+charR)
+	if gstr.Contains(table, " ") {
+		return gerror.NewCode(
+			gcode.CodeInvalidParameter,
+			"function TableFields supports only single table operations",
+		)
+	}
+	var (
+		innerMemCache = c.GetInnerMemCache()
+		// prefix:group@schema#table
+		cacheKey = genTableFieldsCacheKey(
+			c.db.GetGroup(),
+			gutil.GetOrDefaultStr(c.db.GetSchema(), schema...),
+			table,
+		)
+	)
+	return innerMemCache.Set(ctx, cacheKey, fields, gcache.DurationNoExpire)
+}
+
 // GetTablesWithCache retrieves and returns the table names of current database with cache.
 func (c *Core) GetTablesWithCache() ([]string, error) {
 	var (
 		ctx           = c.db.GetCtx()
-		cacheKey      = fmt.Sprintf(`Tables:%s`, c.db.GetGroup())
+		cacheKey      = genTableNamesCacheKey(c.db.GetGroup())
 		cacheDuration = gcache.DurationNoExpire
 		innerMemCache = c.GetInnerMemCache()
 	)
diff --git a/database/gdb/gdb_core_config.go b/database/gdb/gdb_core_config.go
index ae9c7c85b..b051594bd 100644
--- a/database/gdb/gdb_core_config.go
+++ b/database/gdb/gdb_core_config.go
@@ -108,6 +108,11 @@ type ConfigNode struct {
 	// Optional field
 	MaxConnLifeTime time.Duration `json:"maxLifeTime"`
 
+	// MaxIdleConnTime specifies the maximum idle time of a connection before being closed
+	// This is Go 1.15+ feature: sql.DB.SetConnMaxIdleTime
+	// Optional field
+	MaxIdleConnTime time.Duration `json:"maxIdleTime"`
+
 	// QueryTimeout specifies the maximum execution time for DQL operations
 	// Optional field
 	QueryTimeout time.Duration `json:"queryTimeout"`
@@ -241,15 +246,47 @@ func AddDefaultConfigNode(node ConfigNode) error {
 }
 
 // AddDefaultConfigGroup adds multiple node configurations to configuration of default group.
+//
+// Deprecated: Use SetDefaultConfigGroup instead.
 func AddDefaultConfigGroup(nodes ConfigGroup) error {
 	return SetConfigGroup(DefaultGroupName, nodes)
 }
 
+// SetDefaultConfigGroup sets multiple node configurations to configuration of default group.
+func SetDefaultConfigGroup(nodes ConfigGroup) error {
+	return SetConfigGroup(DefaultGroupName, nodes)
+}
+
 // GetConfig retrieves and returns the configuration of given group.
+//
+// Deprecated: Use GetConfigGroup instead.
 func GetConfig(group string) ConfigGroup {
+	configGroup, _ := GetConfigGroup(group)
+	return configGroup
+}
+
+// GetConfigGroup retrieves and returns the configuration of given group.
+// It returns an error if the group does not exist, or an empty slice if the group exists but has no nodes.
+func GetConfigGroup(group string) (ConfigGroup, error) {
 	configs.RLock()
 	defer configs.RUnlock()
-	return configs.config[group]
+
+	configGroup, exists := configs.config[group]
+	if !exists {
+		return nil, gerror.NewCodef(
+			gcode.CodeInvalidParameter,
+			`configuration group "%s" not found`,
+			group,
+		)
+	}
+	return configGroup, nil
+}
+
+// GetAllConfig retrieves and returns all configurations.
+func GetAllConfig() Config {
+	configs.RLock()
+	defer configs.RUnlock()
+	return configs.config
 }
 
 // SetDefaultGroup sets the group name for default configuration.
@@ -321,6 +358,16 @@ func (c *Core) SetMaxConnLifeTime(d time.Duration) {
 	c.dynamicConfig.MaxConnLifeTime = d
 }
 
+// SetMaxIdleConnTime sets the maximum amount of time a connection may be idle before being closed.
+//
+// Idle connections may be closed lazily before reuse.
+//
+// If d <= 0, connections are not closed due to a connection's idle time.
+// This is Go 1.15+ feature: sql.DB.SetConnMaxIdleTime.
+func (c *Core) SetMaxIdleConnTime(d time.Duration) {
+	c.dynamicConfig.MaxIdleConnTime = d
+}
+
 // GetConfig returns the current used node configuration.
 func (c *Core) GetConfig() *ConfigNode {
 	var configNode = c.getConfigNodeFromCtx(c.db.GetCtx())
diff --git a/database/gdb/gdb_core_stats.go b/database/gdb/gdb_core_stats.go
index 8b64f14e8..0e89fbfe2 100644
--- a/database/gdb/gdb_core_stats.go
+++ b/database/gdb/gdb_core_stats.go
@@ -30,14 +30,14 @@ func (item *localStatsItem) Stats() sql.DBStats {
 // Stats retrieves and returns the pool stat for all nodes that have been established.
 func (c *Core) Stats(ctx context.Context) []StatsItem {
 	var items = make([]StatsItem, 0)
-	c.links.Iterator(func(k, v any) bool {
-		var (
-			node  = k.(ConfigNode)
-			sqlDB = v.(*sql.DB)
-		)
+	c.links.Iterator(func(k ConfigNode, v *sql.DB) bool {
+		// Create a local copy of k to avoid loop variable address re-use issue
+		// In Go, loop variables are re-used with the same memory address across iterations,
+		// directly using &k would cause all localStatsItem instances to share the same address
+		node := k
 		items = append(items, &localStatsItem{
 			node:  &node,
-			stats: sqlDB.Stats(),
+			stats: v.Stats(),
 		})
 		return true
 	})
diff --git a/database/gdb/gdb_core_underlying.go b/database/gdb/gdb_core_underlying.go
index 7a3623c62..21d8da0e9 100644
--- a/database/gdb/gdb_core_underlying.go
+++ b/database/gdb/gdb_core_underlying.go
@@ -166,6 +166,19 @@ func (c *Core) DoCommit(ctx context.Context, in DoCommitInput) (out DoCommitOutp
 		timestampMilli1      = gtime.TimestampMilli()
 	)
 
+	// Panic recovery to handle panics from underlying database drivers
+	defer func() {
+		if exception := recover(); exception != nil {
+			if err == nil {
+				if v, ok := exception.(error); ok && gerror.HasStack(v) {
+					err = v
+				} else {
+					err = gerror.WrapCodef(gcode.CodeDbOperationError, gerror.NewCodef(gcode.CodeInternalPanic, "%+v", exception), FormatSqlWithArgs(in.Sql, in.Args))
+				}
+			}
+		}
+	}()
+
 	// Trace span start.
 	tr := otel.GetTracerProvider().Tracer(traceInstrumentName, trace.WithInstrumentationVersion(gf.VERSION))
 	ctx, span := tr.Start(ctx, string(in.Type), trace.WithSpanKind(trace.SpanKindClient))
@@ -501,9 +514,7 @@ func (c *Core) OrderRandomFunction() string {
 	return "RAND()"
 }
 
-func (c *Core) columnValueToLocalValue(
-	ctx context.Context, value any, columnType *sql.ColumnType,
-) (any, error) {
+func (c *Core) columnValueToLocalValue(ctx context.Context, value any, columnType *sql.ColumnType) (any, error) {
 	var scanType = columnType.ScanType()
 	if scanType != nil {
 		// Common basic builtin types.
@@ -513,10 +524,7 @@ func (c *Core) columnValueToLocalValue(
 			reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
 			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
 			reflect.Float32, reflect.Float64:
-			return gconv.Convert(
-				gconv.String(value),
-				columnType.ScanType().String(),
-			), nil
+			return gconv.Convert(gconv.String(value), scanType.String()), nil
 		default:
 		}
 	}
diff --git a/database/gdb/gdb_core_utility.go b/database/gdb/gdb_core_utility.go
index 4872f13a1..b97d7431e 100644
--- a/database/gdb/gdb_core_utility.go
+++ b/database/gdb/gdb_core_utility.go
@@ -10,6 +10,7 @@ package gdb
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
@@ -251,3 +252,22 @@ func (c *Core) guessPrimaryTableName(tableStr string) string {
 	}
 	return guessedTableName
 }
+
+// GetPrimaryKeys retrieves and returns the primary key field names of the specified table.
+// This method extracts primary key information from TableFields.
+// The parameter `schema` is optional, if not specified it uses the default schema.
+func (c *Core) GetPrimaryKeys(ctx context.Context, table string, schema ...string) ([]string, error) {
+	tableFields, err := c.db.TableFields(ctx, table, schema...)
+	if err != nil {
+		return nil, err
+	}
+
+	var primaryKeys []string
+	for _, field := range tableFields {
+		if strings.EqualFold(field.Key, "pri") {
+			primaryKeys = append(primaryKeys, field.Name)
+		}
+	}
+
+	return primaryKeys, nil
+}
diff --git a/database/gdb/gdb_driver_wrapper_db.go b/database/gdb/gdb_driver_wrapper_db.go
index 7dbc1d0ce..81c5b729c 100644
--- a/database/gdb/gdb_driver_wrapper_db.go
+++ b/database/gdb/gdb_driver_wrapper_db.go
@@ -109,7 +109,17 @@ func (d *DriverWrapperDB) TableFields(
 // InsertOptionReplace: if there's unique/primary key in the data, it deletes it from table and inserts a new one;
 // InsertOptionSave:    if there's unique/primary key in the data, it updates it or else inserts a new one;
 // InsertOptionIgnore:  if there's unique/primary key in the data, it ignores the inserting;
-func (d *DriverWrapperDB) DoInsert(ctx context.Context, link Link, table string, list List, option DoInsertOption) (result sql.Result, err error) {
+func (d *DriverWrapperDB) DoInsert(
+	ctx context.Context, link Link, table string, list List, option DoInsertOption,
+) (result sql.Result, err error) {
+	if len(list) == 0 {
+		return nil, gerror.NewCodef(
+			gcode.CodeInvalidRequest,
+			`data list is empty for %s operation`,
+			GetInsertOperationByOption(option.InsertOption),
+		)
+	}
+
 	// Convert data type before commit it to underlying db driver.
 	for i, item := range list {
 		list[i], err = d.GetCore().ConvertDataForRecord(ctx, item, table)
diff --git a/database/gdb/gdb_func.go b/database/gdb/gdb_func.go
index ba1418609..437c981f8 100644
--- a/database/gdb/gdb_func.go
+++ b/database/gdb/gdb_func.go
@@ -151,13 +151,26 @@ func isDoStruct(object any) bool {
 // getTableNameFromOrmTag retrieves and returns the table name from struct object.
 func getTableNameFromOrmTag(object any) string {
 	var tableName string
-	// Use the interface value.
-	if r, ok := object.(iTableName); ok {
-		tableName = r.TableName()
+	var actualObj = object
+
+	if rv, ok := object.(reflect.Value); ok {
+		// Check if reflect.Value is valid
+		if rv.IsValid() && rv.CanInterface() {
+			actualObj = rv.Interface()
+		} else {
+			// If reflect.Value is invalid, we cannot proceed with interface checks
+			return ""
+		}
 	}
-	// User meta data tag "orm".
-	if tableName == "" {
-		if ormTag := gmeta.Get(object, OrmTagForStruct); !ormTag.IsEmpty() {
+
+	// Check iTableName interface
+	if actualObj != nil {
+		if r, ok := actualObj.(iTableName); ok {
+			return r.TableName()
+		}
+
+		// User meta data tag "orm".
+		if ormTag := gmeta.Get(actualObj, OrmTagForStruct); !ormTag.IsEmpty() {
 			match, _ := gregex.MatchString(
 				fmt.Sprintf(`%s\s*:\s*([^,]+)`, OrmTagForTable),
 				ormTag.String(),
@@ -166,17 +179,19 @@ func getTableNameFromOrmTag(object any) string {
 				tableName = match[1]
 			}
 		}
-	}
-	// Use the struct name of snake case.
-	if tableName == "" {
-		if t, err := gstructs.StructType(object); err != nil {
-			panic(err)
-		} else {
-			tableName = gstr.CaseSnakeFirstUpper(
-				gstr.StrEx(t.String(), "."),
-			)
+
+		// Use the struct name of snake case.
+		if tableName == "" {
+			if t, err := gstructs.StructType(actualObj); err != nil {
+				panic(err)
+			} else {
+				tableName = gstr.CaseSnakeFirstUpper(
+					gstr.StrEx(t.String(), "."),
+				)
+			}
 		}
 	}
+
 	return tableName
 }
 
@@ -719,6 +734,14 @@ func formatWhereKeyValue(in formatWhereKeyValueInput) (newArgs []any) {
 		reflectValue = reflect.ValueOf(in.Value)
 		reflectKind  = reflectValue.Kind()
 	)
+	// Check if the value implements iString interface (like uuid.UUID).
+	// These types should be treated as single values, not arrays.
+	if reflectKind == reflect.Array {
+		if v, ok := in.Value.(iString); ok {
+			in.Value = v.String()
+			reflectKind = reflect.String
+		}
+	}
 	switch reflectKind {
 	// Slice argument.
 	case reflect.Slice, reflect.Array:
@@ -780,9 +803,7 @@ func formatWhereKeyValue(in formatWhereKeyValueInput) (newArgs []any) {
 
 // handleSliceAndStructArgsForSql is an important function, which handles the sql and all its arguments
 // before committing them to underlying driver.
-func handleSliceAndStructArgsForSql(
-	oldSql string, oldArgs []any,
-) (newSql string, newArgs []any) {
+func handleSliceAndStructArgsForSql(oldSql string, oldArgs []any) (newSql string, newArgs []any) {
 	newSql = oldSql
 	if len(oldArgs) == 0 {
 		return
@@ -800,6 +821,13 @@ func handleSliceAndStructArgsForSql(
 				newArgs = append(newArgs, oldArg)
 				continue
 			}
+			// It does not split types that implement fmt.Stringer interface (like uuid.UUID).
+			// These types should be converted to string instead of being expanded as arrays.
+			// Eg: table.Where("uuid = ?", uuid.UUID{...})
+			if v, ok := oldArg.(iString); ok {
+				newArgs = append(newArgs, v.String())
+				continue
+			}
 			var (
 				valueHolderCount = gstr.Count(newSql, "?")
 				argSliceLength   = argReflectInfo.OriginValue.Len()
@@ -953,6 +981,7 @@ func FormatMultiLineSqlToSingle(sql string) (string, error) {
 	return sql, nil
 }
 
+// genTableFieldsCacheKey generates cache key for table fields.
 func genTableFieldsCacheKey(group, schema, table string) string {
 	return fmt.Sprintf(
 		`%s%s@%s#%s`,
@@ -963,6 +992,7 @@ func genTableFieldsCacheKey(group, schema, table string) string {
 	)
 }
 
+// genSelectCacheKey generates cache key for select.
 func genSelectCacheKey(table, group, schema, name, sql string, args ...any) string {
 	if name == "" {
 		name = fmt.Sprintf(
@@ -975,3 +1005,13 @@ func genSelectCacheKey(table, group, schema, name, sql string, args ...any) stri
 	}
 	return fmt.Sprintf(`%s%s`, cachePrefixSelectCache, name)
 }
+
+// genTableNamesCacheKey generates cache key for table names.
+func genTableNamesCacheKey(group string) string {
+	return fmt.Sprintf(`Tables:%s`, group)
+}
+
+// genSoftTimeFieldNameTypeCacheKey generates cache key for soft time field name and type.
+func genSoftTimeFieldNameTypeCacheKey(schema, table string, candidateFields []string) string {
+	return fmt.Sprintf(`getSoftFieldNameAndType:%s#%s#%s`, schema, table, strings.Join(candidateFields, "_"))
+}
diff --git a/database/gdb/gdb_model.go b/database/gdb/gdb_model.go
index f02ab4c08..39b9fed35 100644
--- a/database/gdb/gdb_model.go
+++ b/database/gdb/gdb_model.go
@@ -17,44 +17,45 @@ import (
 
 // Model is core struct implementing the DAO for ORM.
 type Model struct {
-	db             DB                // Underlying DB interface.
-	tx             TX                // Underlying TX interface.
-	rawSql         string            // rawSql is the raw SQL string which marks a raw SQL based Model not a table based Model.
-	schema         string            // Custom database schema.
-	linkType       int               // Mark for operation on master or slave.
-	tablesInit     string            // Table names when model initialization.
-	tables         string            // Operation table names, which can be more than one table names and aliases, like: "user", "user u", "user u, user_detail ud".
-	fields         []any             // Operation fields, multiple fields joined using char ','.
-	fieldsEx       []any             // Excluded operation fields, it here uses slice instead of string type for quick filtering.
-	withArray      []any             // Arguments for With feature.
-	withAll        bool              // Enable model association operations on all objects that have "with" tag in the struct.
-	extraArgs      []any             // Extra custom arguments for sql, which are prepended to the arguments before sql committed to underlying driver.
-	whereBuilder   *WhereBuilder     // Condition builder for where operation.
-	groupBy        string            // Used for "group by" statement.
-	orderBy        string            // Used for "order by" statement.
-	having         []any             // Used for "having..." statement.
-	start          int               // Used for "select ... start, limit ..." statement.
-	limit          int               // Used for "select ... start, limit ..." statement.
-	option         int               // Option for extra operation features.
-	offset         int               // Offset statement for some databases grammar.
-	partition      string            // Partition table partition name.
-	data           any               // Data for operation, which can be type of map/[]map/struct/*struct/string, etc.
-	batch          int               // Batch number for batch Insert/Replace/Save operations.
-	filter         bool              // Filter data and where key-value pairs according to the fields of the table.
-	distinct       string            // Force the query to only return distinct results.
-	lockInfo       string            // Lock for update or in shared lock.
-	cacheEnabled   bool              // Enable sql result cache feature, which is mainly for indicating cache duration(especially 0) usage.
-	cacheOption    CacheOption       // Cache option for query statement.
-	hookHandler    HookHandler       // Hook functions for model hook feature.
-	unscoped       bool              // Disables soft deleting features when select/delete operations.
-	safe           bool              // If true, it clones and returns a new model object whenever operation done; or else it changes the attribute of current model.
-	onDuplicate    any               // onDuplicate is used for on Upsert clause.
-	onDuplicateEx  any               // onDuplicateEx is used for excluding some columns on Upsert clause.
-	onConflict     any               // onConflict is used for conflict keys on Upsert clause.
-	tableAliasMap  map[string]string // Table alias to true table name, usually used in join statements.
-	softTimeOption SoftTimeOption    // SoftTimeOption is the option to customize soft time feature for Model.
-	shardingConfig ShardingConfig    // ShardingConfig for database/table sharding feature.
-	shardingValue  any               // Sharding value for sharding feature.
+	db              DB                // Underlying DB interface.
+	tx              TX                // Underlying TX interface.
+	rawSql          string            // rawSql is the raw SQL string which marks a raw SQL based Model not a table based Model.
+	schema          string            // Custom database schema.
+	linkType        int               // Mark for operation on master or slave.
+	tablesInit      string            // Table names when model initialization.
+	tables          string            // Operation table names, which can be more than one table names and aliases, like: "user", "user u", "user u, user_detail ud".
+	fields          []any             // Operation fields, multiple fields joined using char ','.
+	fieldsEx        []any             // Excluded operation fields, it here uses slice instead of string type for quick filtering.
+	withArray       []any             // Arguments for With feature.
+	withAll         bool              // Enable model association operations on all objects that have "with" tag in the struct.
+	extraArgs       []any             // Extra custom arguments for sql, which are prepended to the arguments before sql committed to underlying driver.
+	whereBuilder    *WhereBuilder     // Condition builder for where operation.
+	groupBy         string            // Used for "group by" statement.
+	orderBy         string            // Used for "order by" statement.
+	having          []any             // Used for "having..." statement.
+	start           int               // Used for "select ... start, limit ..." statement.
+	limit           int               // Used for "select ... start, limit ..." statement.
+	option          int               // Option for extra operation features.
+	offset          int               // Offset statement for some databases grammar.
+	partition       string            // Partition table partition name.
+	data            any               // Data for operation, which can be type of map/[]map/struct/*struct/string, etc.
+	batch           int               // Batch number for batch Insert/Replace/Save operations.
+	filter          bool              // Filter data and where key-value pairs according to the fields of the table.
+	distinct        string            // Force the query to only return distinct results.
+	lockInfo        string            // Lock for update or in shared lock.
+	cacheEnabled    bool              // Enable sql result cache feature, which is mainly for indicating cache duration(especially 0) usage.
+	cacheOption     CacheOption       // Cache option for query statement.
+	pageCacheOption []CacheOption     // Cache option for paging query statement.
+	hookHandler     HookHandler       // Hook functions for model hook feature.
+	unscoped        bool              // Disables soft deleting features when select/delete operations.
+	safe            bool              // If true, it clones and returns a new model object whenever operation done; or else it changes the attribute of current model.
+	onDuplicate     any               // onDuplicate is used for on Upsert clause.
+	onDuplicateEx   any               // onDuplicateEx is used for excluding some columns on Upsert clause.
+	onConflict      any               // onConflict is used for conflict keys on Upsert clause.
+	tableAliasMap   map[string]string // Table alias to true table name, usually used in join statements.
+	softTimeOption  SoftTimeOption    // SoftTimeOption is the option to customize soft time feature for Model.
+	shardingConfig  ShardingConfig    // ShardingConfig for database/table sharding feature.
+	shardingValue   any               // Sharding value for sharding feature.
 }
 
 // ModelHandler is a function that handles given Model and returns a new Model that is custom modified.
diff --git a/database/gdb/gdb_model_cache.go b/database/gdb/gdb_model_cache.go
index dd7dac7fa..3d5fe229a 100644
--- a/database/gdb/gdb_model_cache.go
+++ b/database/gdb/gdb_model_cache.go
@@ -50,6 +50,18 @@ func (m *Model) Cache(option CacheOption) *Model {
 	return model
 }
 
+// PageCache sets the cache feature for pagination queries. It allows to configure
+// separate cache options for count query and data query in pagination.
+//
+// Note that, the cache feature is disabled if the model is performing select statement
+// on a transaction.
+func (m *Model) PageCache(countOption CacheOption, dataOption CacheOption) *Model {
+	model := m.getModel()
+	model.pageCacheOption = []CacheOption{countOption, dataOption}
+	model.cacheEnabled = true
+	return model
+}
+
 // checkAndRemoveSelectCache checks and removes the cache in insert/update/delete statement if
 // cache feature is enabled.
 func (m *Model) checkAndRemoveSelectCache(ctx context.Context) {
diff --git a/database/gdb/gdb_model_delete.go b/database/gdb/gdb_model_delete.go
index f8811c086..072d4e77c 100644
--- a/database/gdb/gdb_model_delete.go
+++ b/database/gdb/gdb_model_delete.go
@@ -31,9 +31,7 @@ func (m *Model) Delete(where ...any) (result sql.Result, err error) {
 	var (
 		conditionWhere, conditionExtra, conditionArgs = m.formatCondition(ctx, false, false)
 		conditionStr                                  = conditionWhere + conditionExtra
-		fieldNameDelete, fieldTypeDelete              = m.softTimeMaintainer().GetFieldNameAndTypeForDelete(
-			ctx, "", m.tablesInit,
-		)
+		fieldNameDelete, fieldTypeDelete              = m.softTimeMaintainer().GetFieldInfo(ctx, "", m.tablesInit, SoftTimeFieldDelete)
 	)
 	if m.unscoped {
 		fieldNameDelete = ""
@@ -52,7 +50,7 @@ func (m *Model) Delete(where ...any) (result sql.Result, err error) {
 
 	// Soft deleting.
 	if fieldNameDelete != "" {
-		dataHolder, dataValue := m.softTimeMaintainer().GetDataByFieldNameAndTypeForDelete(
+		dataHolder, dataValue := m.softTimeMaintainer().GetDeleteData(
 			ctx, "", fieldNameDelete, fieldTypeDelete,
 		)
 		in := &HookUpdateInput{
diff --git a/database/gdb/gdb_model_fields.go b/database/gdb/gdb_model_fields.go
index 04ad3638e..3b9d5698e 100644
--- a/database/gdb/gdb_model_fields.go
+++ b/database/gdb/gdb_model_fields.go
@@ -45,8 +45,9 @@ func (m *Model) FieldsPrefix(prefixOrAlias string, fieldNamesOrMapStruct ...any)
 	if len(fields) == 0 {
 		return m
 	}
+	prefixOrAlias = m.QuoteWord(prefixOrAlias)
 	for i, field := range fields {
-		fields[i] = prefixOrAlias + "." + gconv.String(field)
+		fields[i] = fmt.Sprintf("%s.%s", prefixOrAlias, m.QuoteWord(gconv.String(field)))
 	}
 	model := m.getModel()
 	return model.appendToFields(fields...)
@@ -81,14 +82,21 @@ func (m *Model) doFieldsEx(table string, fieldNamesOrMapStruct ...any) *Model {
 }
 
 // FieldsExPrefix performs as function FieldsEx but add extra prefix for each field.
+// Note that this function must be used together with FieldsPrefix, otherwise it will be invalid.
 func (m *Model) FieldsExPrefix(prefixOrAlias string, fieldNamesOrMapStruct ...any) *Model {
-	model := m.doFieldsEx(
+	fields := m.filterFieldsFrom(
 		m.getTableNameByPrefixOrAlias(prefixOrAlias),
 		fieldNamesOrMapStruct...,
 	)
-	for i, field := range model.fieldsEx {
-		model.fieldsEx[i] = prefixOrAlias + "." + gconv.String(field)
+	if len(fields) == 0 {
+		return m
 	}
+	prefixOrAlias = m.QuoteWord(prefixOrAlias)
+	for i, field := range fields {
+		fields[i] = fmt.Sprintf("%s.%s", prefixOrAlias, m.QuoteWord(gconv.String(field)))
+	}
+	model := m.getModel()
+	model.fieldsEx = append(model.fieldsEx, fields...)
 	return model
 }
 
@@ -96,7 +104,7 @@ func (m *Model) FieldsExPrefix(prefixOrAlias string, fieldNamesOrMapStruct ...an
 func (m *Model) FieldCount(column string, as ...string) *Model {
 	asStr := ""
 	if len(as) > 0 && as[0] != "" {
-		asStr = fmt.Sprintf(` AS %s`, m.db.GetCore().QuoteWord(as[0]))
+		asStr = fmt.Sprintf(` AS %s`, m.QuoteWord(as[0]))
 	}
 	model := m.getModel()
 	return model.appendToFields(
@@ -108,7 +116,7 @@ func (m *Model) FieldCount(column string, as ...string) *Model {
 func (m *Model) FieldSum(column string, as ...string) *Model {
 	asStr := ""
 	if len(as) > 0 && as[0] != "" {
-		asStr = fmt.Sprintf(` AS %s`, m.db.GetCore().QuoteWord(as[0]))
+		asStr = fmt.Sprintf(` AS %s`, m.QuoteWord(as[0]))
 	}
 	model := m.getModel()
 	return model.appendToFields(
@@ -120,7 +128,7 @@ func (m *Model) FieldSum(column string, as ...string) *Model {
 func (m *Model) FieldMin(column string, as ...string) *Model {
 	asStr := ""
 	if len(as) > 0 && as[0] != "" {
-		asStr = fmt.Sprintf(` AS %s`, m.db.GetCore().QuoteWord(as[0]))
+		asStr = fmt.Sprintf(` AS %s`, m.QuoteWord(as[0]))
 	}
 	model := m.getModel()
 	return model.appendToFields(
@@ -132,7 +140,7 @@ func (m *Model) FieldMin(column string, as ...string) *Model {
 func (m *Model) FieldMax(column string, as ...string) *Model {
 	asStr := ""
 	if len(as) > 0 && as[0] != "" {
-		asStr = fmt.Sprintf(` AS %s`, m.db.GetCore().QuoteWord(as[0]))
+		asStr = fmt.Sprintf(` AS %s`, m.QuoteWord(as[0]))
 	}
 	model := m.getModel()
 	return model.appendToFields(
@@ -144,7 +152,7 @@ func (m *Model) FieldMax(column string, as ...string) *Model {
 func (m *Model) FieldAvg(column string, as ...string) *Model {
 	asStr := ""
 	if len(as) > 0 && as[0] != "" {
-		asStr = fmt.Sprintf(` AS %s`, m.db.GetCore().QuoteWord(as[0]))
+		asStr = fmt.Sprintf(` AS %s`, m.QuoteWord(as[0]))
 	}
 	model := m.getModel()
 	return model.appendToFields(
diff --git a/database/gdb/gdb_model_hook.go b/database/gdb/gdb_model_hook.go
index 509878841..8b23337b4 100644
--- a/database/gdb/gdb_model_hook.go
+++ b/database/gdb/gdb_model_hook.go
@@ -159,6 +159,10 @@ func (h *HookSelectInput) Next(ctx context.Context) (result Result, err error) {
 		if err != nil {
 			return
 		}
+		h.Model.db.GetCore().schema = h.Schema
+		defer func() {
+			h.Model.db.GetCore().schema = h.originalSchemaName.String()
+		}()
 	}
 	return h.Model.db.DoSelect(ctx, h.link, toBeCommittedSql, h.Args...)
 }
@@ -195,6 +199,10 @@ func (h *HookInsertInput) Next(ctx context.Context) (result sql.Result, err erro
 		if err != nil {
 			return
 		}
+		h.Model.db.GetCore().schema = h.Schema
+		defer func() {
+			h.Model.db.GetCore().schema = h.originalSchemaName.String()
+		}()
 	}
 	return h.Model.db.DoInsert(ctx, h.link, h.Table, h.Data, h.Option)
 }
@@ -238,6 +246,10 @@ func (h *HookUpdateInput) Next(ctx context.Context) (result sql.Result, err erro
 		if err != nil {
 			return
 		}
+		h.Model.db.GetCore().schema = h.Schema
+		defer func() {
+			h.Model.db.GetCore().schema = h.originalSchemaName.String()
+		}()
 	}
 	return h.Model.db.DoUpdate(ctx, h.link, h.Table, h.Data, h.Condition, h.Args...)
 }
@@ -281,6 +293,10 @@ func (h *HookDeleteInput) Next(ctx context.Context) (result sql.Result, err erro
 		if err != nil {
 			return
 		}
+		h.Model.db.GetCore().schema = h.Schema
+		defer func() {
+			h.Model.db.GetCore().schema = h.originalSchemaName.String()
+		}()
 	}
 	return h.Model.db.DoDelete(ctx, h.link, h.Table, h.Condition, h.Args...)
 }
diff --git a/database/gdb/gdb_model_insert.go b/database/gdb/gdb_model_insert.go
index a322d75f4..035af1f4f 100644
--- a/database/gdb/gdb_model_insert.go
+++ b/database/gdb/gdb_model_insert.go
@@ -262,9 +262,9 @@ func (m *Model) doInsertWithOption(ctx context.Context, insertOption InsertOptio
 	var (
 		list                             List
 		stm                              = m.softTimeMaintainer()
-		fieldNameCreate, fieldTypeCreate = stm.GetFieldNameAndTypeForCreate(ctx, "", m.tablesInit)
-		fieldNameUpdate, fieldTypeUpdate = stm.GetFieldNameAndTypeForUpdate(ctx, "", m.tablesInit)
-		fieldNameDelete, fieldTypeDelete = stm.GetFieldNameAndTypeForDelete(ctx, "", m.tablesInit)
+		fieldNameCreate, fieldTypeCreate = stm.GetFieldInfo(ctx, "", m.tablesInit, SoftTimeFieldCreate)
+		fieldNameUpdate, fieldTypeUpdate = stm.GetFieldInfo(ctx, "", m.tablesInit, SoftTimeFieldUpdate)
+		fieldNameDelete, fieldTypeDelete = stm.GetFieldInfo(ctx, "", m.tablesInit, SoftTimeFieldDelete)
 	)
 	// m.data was already converted to type List/Map by function Data
 	newData, err := m.filterDataForInsertOrUpdate(m.data)
@@ -295,20 +295,20 @@ func (m *Model) doInsertWithOption(ctx context.Context, insertOption InsertOptio
 	if !m.unscoped && isSoftTimeFeatureEnabled {
 		for k, v := range list {
 			if fieldNameCreate != "" && empty.IsNil(v[fieldNameCreate]) {
-				fieldCreateValue := stm.GetValueByFieldTypeForCreateOrUpdate(ctx, fieldTypeCreate, false)
+				fieldCreateValue := stm.GetFieldValue(ctx, fieldTypeCreate, false)
 				if fieldCreateValue != nil {
 					v[fieldNameCreate] = fieldCreateValue
 				}
 			}
 			if fieldNameUpdate != "" && empty.IsNil(v[fieldNameUpdate]) {
-				fieldUpdateValue := stm.GetValueByFieldTypeForCreateOrUpdate(ctx, fieldTypeUpdate, false)
+				fieldUpdateValue := stm.GetFieldValue(ctx, fieldTypeUpdate, false)
 				if fieldUpdateValue != nil {
 					v[fieldNameUpdate] = fieldUpdateValue
 				}
 			}
 			// for timestamp field that should initialize the delete_at field with value, for example 0.
 			if fieldNameDelete != "" && empty.IsNil(v[fieldNameDelete]) {
-				fieldDeleteValue := stm.GetValueByFieldTypeForCreateOrUpdate(ctx, fieldTypeDelete, true)
+				fieldDeleteValue := stm.GetFieldValue(ctx, fieldTypeDelete, true)
 				if fieldDeleteValue != nil {
 					v[fieldNameDelete] = fieldDeleteValue
 				}
diff --git a/database/gdb/gdb_model_lock.go b/database/gdb/gdb_model_lock.go
index a207a126e..3fb4e1f45 100644
--- a/database/gdb/gdb_model_lock.go
+++ b/database/gdb/gdb_model_lock.go
@@ -6,16 +6,124 @@
 
 package gdb
 
+// Lock clause constants for different databases.
+// These constants provide type-safe and IDE-friendly access to various lock syntaxes.
+const (
+	// Common lock clauses (supported by most databases)
+	LockForUpdate           = "FOR UPDATE"
+	LockForUpdateSkipLocked = "FOR UPDATE SKIP LOCKED"
+
+	// MySQL lock clauses
+	LockInShareMode     = "LOCK IN SHARE MODE" // MySQL legacy syntax
+	LockForShare        = "FOR SHARE"          // MySQL 8.0+ and PostgreSQL
+	LockForUpdateNowait = "FOR UPDATE NOWAIT"  // MySQL 8.0+ and Oracle
+
+	// PostgreSQL specific lock clauses
+	LockForNoKeyUpdate           = "FOR NO KEY UPDATE"
+	LockForKeyShare              = "FOR KEY SHARE"
+	LockForShareNowait           = "FOR SHARE NOWAIT"
+	LockForShareSkipLocked       = "FOR SHARE SKIP LOCKED"
+	LockForNoKeyUpdateNowait     = "FOR NO KEY UPDATE NOWAIT"
+	LockForNoKeyUpdateSkipLocked = "FOR NO KEY UPDATE SKIP LOCKED"
+	LockForKeyShareNowait        = "FOR KEY SHARE NOWAIT"
+	LockForKeyShareSkipLocked    = "FOR KEY SHARE SKIP LOCKED"
+
+	// Oracle specific lock clauses
+	LockForUpdateWait5  = "FOR UPDATE WAIT 5"
+	LockForUpdateWait10 = "FOR UPDATE WAIT 10"
+	LockForUpdateWait30 = "FOR UPDATE WAIT 30"
+
+	// SQL Server lock hints (use with WITH clause)
+	LockWithUpdLock         = "WITH (UPDLOCK)"
+	LockWithHoldLock        = "WITH (HOLDLOCK)"
+	LockWithXLock           = "WITH (XLOCK)"
+	LockWithTabLock         = "WITH (TABLOCK)"
+	LockWithNoLock          = "WITH (NOLOCK)"
+	LockWithUpdLockHoldLock = "WITH (UPDLOCK, HOLDLOCK)"
+)
+
+// Lock sets a custom lock clause for the current operation.
+// This is a generic method that allows you to specify any lock syntax supported by your database.
+// You can use predefined constants or custom strings.
+//
+// Database-specific lock syntax support:
+//
+// PostgreSQL (most comprehensive):
+//   - "FOR UPDATE"                    - Exclusive lock, blocks all access
+//   - "FOR NO KEY UPDATE"            - Weaker exclusive lock, doesn't block FOR KEY SHARE
+//   - "FOR SHARE"                    - Shared lock, allows reads but blocks writes
+//   - "FOR KEY SHARE"                - Weakest lock, only locks key values
+//   - All above can be combined with:
+//   - "NOWAIT"                     - Return immediately if lock cannot be acquired
+//   - "SKIP LOCKED"               - Skip locked rows instead of waiting
+//
+// MySQL:
+//   - "FOR UPDATE"                    - Exclusive lock (all versions)
+//   - "LOCK IN SHARE MODE"           - Shared lock (legacy syntax)
+//   - "FOR SHARE"                    - Shared lock (MySQL 8.0+)
+//   - "FOR UPDATE NOWAIT"            - MySQL 8.0+ only
+//   - "FOR UPDATE SKIP LOCKED"       - MySQL 8.0+ only
+//
+// Oracle:
+//   - "FOR UPDATE"                    - Exclusive lock
+//   - "FOR UPDATE NOWAIT"            - Exclusive lock, no wait
+//   - "FOR UPDATE SKIP LOCKED"       - Exclusive lock, skip locked rows
+//   - "FOR UPDATE WAIT n"            - Exclusive lock, wait n seconds
+//   - "FOR UPDATE OF column_list"    - Lock specific columns
+//
+// SQL Server (uses WITH hints):
+//   - "WITH (UPDLOCK)"               - Update lock
+//   - "WITH (HOLDLOCK)"              - Hold lock until transaction end
+//   - "WITH (XLOCK)"                 - Exclusive lock
+//   - "WITH (TABLOCK)"               - Table lock
+//   - "WITH (NOLOCK)"                - No lock (dirty read)
+//   - "WITH (UPDLOCK, HOLDLOCK)"     - Combined update and hold lock
+//
+// SQLite:
+//   - Limited locking support, database-level locks only
+//   - No row-level lock syntax supported
+//
+// Usage examples:
+//
+//	db.Model("users").Lock("FOR UPDATE NOWAIT").Where("id", 1).One()
+//	db.Model("users").Lock("FOR SHARE SKIP LOCKED").Where("status", "active").All()
+//	db.Model("users").Lock("WITH (UPDLOCK)").Where("id", 1).One() // SQL Server
+//	db.Model("users").Lock("FOR UPDATE OF name, email").Where("id", 1).One() // Oracle
+//	db.Model("users").Lock("FOR UPDATE WAIT 15").Where("id", 1).One() // Oracle custom wait
+//
+// Or use predefined constants for better IDE support:
+//
+//	db.Model("users").Lock(gdb.LockForUpdateNowait).Where("id", 1).One()
+//	db.Model("users").Lock(gdb.LockForShareSkipLocked).Where("status", "active").All()
+func (m *Model) Lock(lockClause string) *Model {
+	model := m.getModel()
+	model.lockInfo = lockClause
+	return model
+}
+
 // LockUpdate sets the lock for update for current operation.
+// This is equivalent to Lock("FOR UPDATE").
 func (m *Model) LockUpdate() *Model {
 	model := m.getModel()
-	model.lockInfo = "FOR UPDATE"
+	model.lockInfo = LockForUpdate
+	return model
+}
+
+// LockUpdateSkipLocked sets the lock for update with skip locked behavior for current operation.
+// It skips the locked rows.
+// This is equivalent to Lock("FOR UPDATE SKIP LOCKED").
+// Note: Supported by PostgreSQL, Oracle, and MySQL 8.0+.
+func (m *Model) LockUpdateSkipLocked() *Model {
+	model := m.getModel()
+	model.lockInfo = LockForUpdateSkipLocked
 	return model
 }
 
 // LockShared sets the lock in share mode for current operation.
+// This is equivalent to Lock("LOCK IN SHARE MODE") for MySQL or Lock("FOR SHARE") for PostgreSQL.
+// Note: For maximum compatibility, this uses MySQL's legacy syntax.
 func (m *Model) LockShared() *Model {
 	model := m.getModel()
-	model.lockInfo = "LOCK IN SHARE MODE"
+	model.lockInfo = LockInShareMode
 	return model
 }
diff --git a/database/gdb/gdb_model_select.go b/database/gdb/gdb_model_select.go
index 27b18d5e4..7d362ac1c 100644
--- a/database/gdb/gdb_model_select.go
+++ b/database/gdb/gdb_model_select.go
@@ -56,6 +56,9 @@ func (m *Model) AllAndCount(useFieldForCount bool) (result Result, totalCount in
 	if !useFieldForCount {
 		countModel.fields = []any{Raw("1")}
 	}
+	if len(m.pageCacheOption) > 0 {
+		countModel = countModel.Cache(m.pageCacheOption[0])
+	}
 
 	// Get the total count of records
 	totalCount, err = countModel.Count()
@@ -68,8 +71,13 @@ func (m *Model) AllAndCount(useFieldForCount bool) (result Result, totalCount in
 		return
 	}
 
+	resultModel := m.Clone()
+	if len(m.pageCacheOption) > 1 {
+		resultModel = resultModel.Cache(m.pageCacheOption[1])
+	}
+
 	// Retrieve all records
-	result, err = m.doGetAll(m.GetCtx(), SelectTypeDefault, false)
+	result, err = resultModel.doGetAll(m.GetCtx(), SelectTypeDefault, false)
 	return
 }
 
@@ -126,7 +134,7 @@ func (m *Model) One(where ...any) (Record, error) {
 // If the optional parameter `fieldsAndWhere` is given, the fieldsAndWhere[0] is the selected fields
 // and fieldsAndWhere[1:] is treated as where condition fields.
 // Also see Model.Fields and Model.Where functions.
-func (m *Model) Array(fieldsAndWhere ...any) ([]Value, error) {
+func (m *Model) Array(fieldsAndWhere ...any) (Array, error) {
 	if len(fieldsAndWhere) > 0 {
 		if len(fieldsAndWhere) > 2 {
 			return m.Fields(gconv.String(fieldsAndWhere[0])).Where(fieldsAndWhere[1], fieldsAndWhere[2:]...).Array()
@@ -337,7 +345,9 @@ func (m *Model) ScanAndCount(pointer any, totalCount *int, useFieldForCount bool
 	if !useFieldForCount {
 		countModel.fields = []any{Raw("1")}
 	}
-
+	if len(m.pageCacheOption) > 0 {
+		countModel = countModel.Cache(m.pageCacheOption[0])
+	}
 	// Get the total count of records
 	*totalCount, err = countModel.Count()
 	if err != nil {
@@ -348,7 +358,11 @@ func (m *Model) ScanAndCount(pointer any, totalCount *int, useFieldForCount bool
 	if *totalCount == 0 {
 		return
 	}
-	err = m.Scan(pointer)
+	scanModel := m.Clone()
+	if len(m.pageCacheOption) > 1 {
+		scanModel = scanModel.Cache(m.pageCacheOption[1])
+	}
+	err = scanModel.Scan(pointer)
 	return
 }
 
@@ -710,8 +724,12 @@ func (m *Model) getFormattedSqlAndArgs(
 		}
 		// Raw SQL Model.
 		if m.rawSql != "" {
-			sqlWithHolder = fmt.Sprintf("SELECT %s FROM (%s) AS T", queryFields, m.rawSql)
-			return sqlWithHolder, nil
+			conditionWhere, conditionExtra, conditionArgs := m.formatCondition(ctx, false, true)
+			sqlWithHolder = fmt.Sprintf(
+				"SELECT %s FROM (%s%s) AS T",
+				queryFields, m.rawSql, conditionWhere+conditionExtra,
+			)
+			return sqlWithHolder, conditionArgs
 		}
 		conditionWhere, conditionExtra, conditionArgs := m.formatCondition(ctx, false, true)
 		sqlWithHolder = fmt.Sprintf("SELECT %s FROM %s%s", queryFields, m.tables, conditionWhere+conditionExtra)
@@ -752,7 +770,7 @@ func (m *Model) getHolderAndArgsAsSubModel(ctx context.Context) (holder string,
 func (m *Model) getAutoPrefix() string {
 	autoPrefix := ""
 	if gstr.Contains(m.tables, " JOIN ") {
-		autoPrefix = m.db.GetCore().QuoteWord(
+		autoPrefix = m.QuoteWord(
 			m.db.GetCore().guessPrimaryTableName(m.tablesInit),
 		)
 	}
@@ -762,7 +780,6 @@ func (m *Model) getAutoPrefix() string {
 func (m *Model) getFieldsAsStr() string {
 	var (
 		fieldsStr string
-		core      = m.db.GetCore()
 	)
 	for _, v := range m.fields {
 		field := gconv.String(v)
@@ -773,7 +790,7 @@ func (m *Model) getFieldsAsStr() string {
 			switch v.(type) {
 			case Raw, *Raw:
 			default:
-				field = core.QuoteString(field)
+				field = m.QuoteWord(field)
 			}
 		}
 		if fieldsStr != "" {
@@ -829,7 +846,7 @@ func (m *Model) getFieldsFiltered() string {
 		if len(newFields) > 0 {
 			newFields += ","
 		}
-		newFields += m.db.GetCore().QuoteWord(k)
+		newFields += m.QuoteWord(k)
 	}
 	return newFields
 }
@@ -848,7 +865,7 @@ func (m *Model) formatCondition(
 	}
 	// WHERE
 	conditionWhere, conditionArgs = m.whereBuilder.Build()
-	softDeletingCondition := m.softTimeMaintainer().GetWhereConditionForDelete(ctx)
+	softDeletingCondition := m.softTimeMaintainer().GetDeleteCondition(ctx)
 	if m.rawSql != "" && conditionWhere != "" {
 		if gstr.ContainsI(m.rawSql, " WHERE ") {
 			conditionWhere = " AND " + conditionWhere
diff --git a/database/gdb/gdb_model_soft_time.go b/database/gdb/gdb_model_soft_time.go
index 3972bf647..4deb39620 100644
--- a/database/gdb/gdb_model_soft_time.go
+++ b/database/gdb/gdb_model_soft_time.go
@@ -43,28 +43,27 @@ type softTimeMaintainer struct {
 	*Model
 }
 
+// SoftTimeFieldType represents different soft time field purposes.
+type SoftTimeFieldType int
+
+const (
+	SoftTimeFieldCreate SoftTimeFieldType = iota
+	SoftTimeFieldUpdate
+	SoftTimeFieldDelete
+)
+
 type iSoftTimeMaintainer interface {
-	GetFieldNameAndTypeForCreate(
-		ctx context.Context, schema string, table string,
-	) (fieldName string, fieldType LocalType)
+	// GetFieldInfo returns field name and type for specified field purpose.
+	GetFieldInfo(ctx context.Context, schema, table string, fieldPurpose SoftTimeFieldType) (fieldName string, localType LocalType)
 
-	GetFieldNameAndTypeForUpdate(
-		ctx context.Context, schema string, table string,
-	) (fieldName string, fieldType LocalType)
+	// GetFieldValue generates value for create/update/delete operations.
+	GetFieldValue(ctx context.Context, localType LocalType, isDeleted bool) any
 
-	GetFieldNameAndTypeForDelete(
-		ctx context.Context, schema string, table string,
-	) (fieldName string, fieldType LocalType)
+	// GetDeleteCondition returns WHERE condition for soft delete query.
+	GetDeleteCondition(ctx context.Context) string
 
-	GetValueByFieldTypeForCreateOrUpdate(
-		ctx context.Context, fieldType LocalType, isDeletedField bool,
-	) (dataValue any)
-
-	GetDataByFieldNameAndTypeForDelete(
-		ctx context.Context, fieldPrefix, fieldName string, fieldType LocalType,
-	) (dataHolder string, dataValue any)
-
-	GetWhereConditionForDelete(ctx context.Context) string
+	// GetDeleteData returns UPDATE statement data for soft delete.
+	GetDeleteData(ctx context.Context, prefix, fieldName string, localType LocalType) (holder string, value any)
 }
 
 // getSoftFieldNameAndTypeCacheItem is the internal struct for storing create/update/delete fields.
@@ -102,137 +101,83 @@ func (m *Model) softTimeMaintainer() iSoftTimeMaintainer {
 	}
 }
 
-// GetFieldNameAndTypeForCreate checks and returns the field name for record creating time.
-// If there's no field name for storing creating time, it returns an empty string.
+// GetFieldInfo returns field name and type for specified field purpose.
 // It checks the key with or without cases or chars '-'/'_'/'.'/' '.
-func (m *softTimeMaintainer) GetFieldNameAndTypeForCreate(
-	ctx context.Context, schema string, table string,
-) (fieldName string, fieldType LocalType) {
-	// It checks whether this feature disabled.
+func (m *softTimeMaintainer) GetFieldInfo(
+	ctx context.Context, schema, table string, fieldPurpose SoftTimeFieldType,
+) (fieldName string, localType LocalType) {
+	// Check if feature is disabled
 	if m.db.GetConfig().TimeMaintainDisabled {
 		return "", LocalTypeUndefined
 	}
-	tableName := ""
-	if table != "" {
-		tableName = table
-	} else {
-		tableName = m.tablesInit
-	}
-	config := m.db.GetConfig()
-	if config.CreatedAt != "" {
-		return m.getSoftFieldNameAndType(
-			ctx, schema, tableName, []string{config.CreatedAt},
-		)
-	}
-	return m.getSoftFieldNameAndType(
-		ctx, schema, tableName, createdFieldNames,
-	)
-}
 
-// GetFieldNameAndTypeForUpdate checks and returns the field name for record updating time.
-// If there's no field name for storing updating time, it returns an empty string.
-// It checks the key with or without cases or chars '-'/'_'/'.'/' '.
-func (m *softTimeMaintainer) GetFieldNameAndTypeForUpdate(
-	ctx context.Context, schema string, table string,
-) (fieldName string, fieldType LocalType) {
-	// It checks whether this feature disabled.
-	if m.db.GetConfig().TimeMaintainDisabled {
-		return "", LocalTypeUndefined
-	}
-	tableName := ""
-	if table != "" {
-		tableName = table
-	} else {
+	// Determine table name
+	tableName := table
+	if tableName == "" {
 		tableName = m.tablesInit
 	}
-	config := m.db.GetConfig()
-	if config.UpdatedAt != "" {
-		return m.getSoftFieldNameAndType(
-			ctx, schema, tableName, []string{config.UpdatedAt},
-		)
-	}
-	return m.getSoftFieldNameAndType(
-		ctx, schema, tableName, updatedFieldNames,
-	)
-}
 
-// GetFieldNameAndTypeForDelete checks and returns the field name for record deleting time.
-// If there's no field name for storing deleting time, it returns an empty string.
-// It checks the key with or without cases or chars '-'/'_'/'.'/' '.
-func (m *softTimeMaintainer) GetFieldNameAndTypeForDelete(
-	ctx context.Context, schema string, table string,
-) (fieldName string, fieldType LocalType) {
-	// It checks whether this feature disabled.
-	if m.db.GetConfig().TimeMaintainDisabled {
-		return "", LocalTypeUndefined
-	}
-	tableName := ""
-	if table != "" {
-		tableName = table
-	} else {
-		tableName = m.tablesInit
-	}
+	// Get config and field candidates
 	config := m.db.GetConfig()
-	if config.DeletedAt != "" {
-		return m.getSoftFieldNameAndType(
-			ctx, schema, tableName, []string{config.DeletedAt},
-		)
-	}
-	return m.getSoftFieldNameAndType(
-		ctx, schema, tableName, deletedFieldNames,
+	var (
+		configField   string
+		defaultFields []string
 	)
+
+	switch fieldPurpose {
+	case SoftTimeFieldCreate:
+		configField = config.CreatedAt
+		defaultFields = createdFieldNames
+	case SoftTimeFieldUpdate:
+		configField = config.UpdatedAt
+		defaultFields = updatedFieldNames
+	case SoftTimeFieldDelete:
+		configField = config.DeletedAt
+		defaultFields = deletedFieldNames
+	}
+
+	// Use config field if specified, otherwise use defaults
+	if configField != "" {
+		return m.getSoftFieldNameAndType(ctx, schema, tableName, []string{configField})
+	}
+	return m.getSoftFieldNameAndType(ctx, schema, tableName, defaultFields)
 }
 
 // getSoftFieldNameAndType retrieves and returns the field name of the table for possible key.
 func (m *softTimeMaintainer) getSoftFieldNameAndType(
-	ctx context.Context,
-	schema string, table string, checkFiledNames []string,
+	ctx context.Context, schema, table string, candidateFields []string,
 ) (fieldName string, fieldType LocalType) {
-	var (
-		innerMemCache = m.db.GetCore().GetInnerMemCache()
-		cacheKey      = fmt.Sprintf(
-			`getSoftFieldNameAndType:%s#%s#%s`,
-			schema, table, strings.Join(checkFiledNames, "_"),
-		)
-		cacheDuration = gcache.DurationNoExpire
-		cacheFunc     = func(ctx context.Context) (value any, err error) {
-			// Ignore the error from TableFields.
-			fieldsMap, err := m.TableFields(table, schema)
-			if err != nil {
-				return nil, err
-			}
-			if len(fieldsMap) == 0 {
-				return nil, nil
-			}
-			for _, checkFiledName := range checkFiledNames {
-				fieldName = searchFieldNameFromMap(fieldsMap, checkFiledName)
-				if fieldName != "" {
-					fieldType, _ = m.db.CheckLocalTypeForField(
-						ctx, fieldsMap[fieldName].Type, nil,
-					)
-					var cacheItem = getSoftFieldNameAndTypeCacheItem{
-						FieldName: fieldName,
-						FieldType: fieldType,
-					}
-					return cacheItem, nil
-				}
-			}
-			return
+	// Build cache key
+	cacheKey := genSoftTimeFieldNameTypeCacheKey(schema, table, candidateFields)
+
+	// Try to get from cache
+	cache := m.db.GetCore().GetInnerMemCache()
+	result, err := cache.GetOrSetFunc(ctx, cacheKey, func(ctx context.Context) (any, error) {
+		// Get table fields
+		fieldsMap, err := m.TableFields(table, schema)
+		if err != nil || len(fieldsMap) == 0 {
+			return nil, err
 		}
-	)
-	result, err := innerMemCache.GetOrSetFunc(
-		ctx, cacheKey, cacheFunc, cacheDuration,
-	)
-	if err != nil {
-		return
+
+		// Search for matching field
+		for _, field := range candidateFields {
+			if name := searchFieldNameFromMap(fieldsMap, field); name != "" {
+				fType, _ := m.db.CheckLocalTypeForField(ctx, fieldsMap[name].Type, nil)
+				return getSoftFieldNameAndTypeCacheItem{
+					FieldName: name,
+					FieldType: fType,
+				}, nil
+			}
+		}
+		return nil, nil
+	}, gcache.DurationNoExpire)
+
+	if err != nil || result == nil {
+		return "", LocalTypeUndefined
 	}
-	if result == nil {
-		return
-	}
-	cacheItem := result.Val().(getSoftFieldNameAndTypeCacheItem)
-	fieldName = cacheItem.FieldName
-	fieldType = cacheItem.FieldType
-	return
+
+	item := result.Val().(getSoftFieldNameAndTypeCacheItem)
+	return item.FieldName, item.FieldType
 }
 
 func searchFieldNameFromMap(fieldsMap map[string]*TableField, key string) string {
@@ -252,13 +197,13 @@ func searchFieldNameFromMap(fieldsMap map[string]*TableField, key string) string
 	return ""
 }
 
-// GetWhereConditionForDelete retrieves and returns the condition string for soft deleting.
+// GetDeleteCondition returns WHERE condition for soft delete query.
 // It supports multiple tables string like:
 // "user u, user_detail ud"
 // "user u LEFT JOIN user_detail ud ON(ud.uid=u.uid)"
 // "user LEFT JOIN user_detail ON(user_detail.uid=user.uid)"
 // "user u LEFT JOIN user_detail ud ON(ud.uid=u.uid) LEFT JOIN user_stats us ON(us.uid=u.uid)".
-func (m *softTimeMaintainer) GetWhereConditionForDelete(ctx context.Context) string {
+func (m *softTimeMaintainer) GetDeleteCondition(ctx context.Context) string {
 	if m.unscoped {
 		return ""
 	}
@@ -284,9 +229,9 @@ func (m *softTimeMaintainer) GetWhereConditionForDelete(ctx context.Context) str
 		return conditionArray.Join(" AND ")
 	}
 	// Only one table.
-	fieldName, fieldType := m.GetFieldNameAndTypeForDelete(ctx, "", m.tablesInit)
+	fieldName, fieldType := m.GetFieldInfo(ctx, "", m.tablesInit, SoftTimeFieldDelete)
 	if fieldName != "" {
-		return m.getConditionByFieldNameAndTypeForSoftDeleting(ctx, "", fieldName, fieldType)
+		return m.buildDeleteCondition(ctx, "", fieldName, fieldType)
 	}
 	return ""
 }
@@ -310,140 +255,130 @@ func (m *softTimeMaintainer) getConditionOfTableStringForSoftDeleting(ctx contex
 	} else {
 		table = array2[0]
 	}
-	fieldName, fieldType := m.GetFieldNameAndTypeForDelete(ctx, schema, table)
+	fieldName, fieldType := m.GetFieldInfo(ctx, schema, table, SoftTimeFieldDelete)
 	if fieldName == "" {
 		return ""
 	}
 	if len(array1) >= 3 {
-		return m.getConditionByFieldNameAndTypeForSoftDeleting(ctx, array1[2], fieldName, fieldType)
+		return m.buildDeleteCondition(ctx, array1[2], fieldName, fieldType)
 	}
 	if len(array1) >= 2 {
-		return m.getConditionByFieldNameAndTypeForSoftDeleting(ctx, array1[1], fieldName, fieldType)
+		return m.buildDeleteCondition(ctx, array1[1], fieldName, fieldType)
 	}
-	return m.getConditionByFieldNameAndTypeForSoftDeleting(ctx, table, fieldName, fieldType)
+	return m.buildDeleteCondition(ctx, table, fieldName, fieldType)
 }
 
-// GetDataByFieldNameAndTypeForDelete creates and returns the placeholder and value for
-// specified field name and type in soft-deleting scenario.
-func (m *softTimeMaintainer) GetDataByFieldNameAndTypeForDelete(
-	ctx context.Context, fieldPrefix, fieldName string, fieldType LocalType,
-) (dataHolder string, dataValue any) {
-	var (
-		quotedFieldPrefix = m.db.GetCore().QuoteWord(fieldPrefix)
-		quotedFieldName   = m.db.GetCore().QuoteWord(fieldName)
-	)
-	if quotedFieldPrefix != "" {
-		quotedFieldName = fmt.Sprintf(`%s.%s`, quotedFieldPrefix, quotedFieldName)
+// GetDeleteData returns UPDATE statement data for soft delete.
+func (m *softTimeMaintainer) GetDeleteData(
+	ctx context.Context, prefix, fieldName string, fieldType LocalType,
+) (holder string, value any) {
+	core := m.db.GetCore()
+	quotedName := core.QuoteWord(fieldName)
+
+	if prefix != "" {
+		quotedName = fmt.Sprintf(`%s.%s`, core.QuoteWord(prefix), quotedName)
 	}
-	dataHolder = fmt.Sprintf(`%s=?`, quotedFieldName)
-	dataValue = m.GetValueByFieldTypeForCreateOrUpdate(ctx, fieldType, false)
+
+	holder = fmt.Sprintf(`%s=?`, quotedName)
+	value = m.GetFieldValue(ctx, fieldType, false)
 	return
 }
 
-func (m *softTimeMaintainer) getConditionByFieldNameAndTypeForSoftDeleting(
-	ctx context.Context, fieldPrefix, fieldName string, fieldType LocalType,
+// buildDeleteCondition builds WHERE condition for soft delete filtering.
+func (m *softTimeMaintainer) buildDeleteCondition(
+	ctx context.Context, prefix, fieldName string, fieldType LocalType,
 ) string {
-	var (
-		quotedFieldPrefix = m.db.GetCore().QuoteWord(fieldPrefix)
-		quotedFieldName   = m.db.GetCore().QuoteWord(fieldName)
-	)
-	if quotedFieldPrefix != "" {
-		quotedFieldName = fmt.Sprintf(`%s.%s`, quotedFieldPrefix, quotedFieldName)
+	core := m.db.GetCore()
+	quotedName := core.QuoteWord(fieldName)
+
+	if prefix != "" {
+		quotedName = fmt.Sprintf(`%s.%s`, core.QuoteWord(prefix), quotedName)
 	}
 	switch m.softTimeOption.SoftTimeType {
 	case SoftTimeTypeAuto:
 		switch fieldType {
 		case LocalTypeDate, LocalTypeTime, LocalTypeDatetime:
-			return fmt.Sprintf(`%s IS NULL`, quotedFieldName)
+			return fmt.Sprintf(`%s IS NULL`, quotedName)
 		case LocalTypeInt, LocalTypeUint, LocalTypeInt64, LocalTypeUint64, LocalTypeBool:
-			return fmt.Sprintf(`%s=0`, quotedFieldName)
+			return fmt.Sprintf(`%s=0`, quotedName)
 		default:
-			intlog.Errorf(
-				ctx,
-				`invalid field type "%s" of field name "%s" with prefix "%s" for soft deleting condition`,
-				fieldType, fieldName, fieldPrefix,
-			)
+			intlog.Errorf(ctx, `invalid field type "%s" for soft delete condition: prefix=%s, field=%s`, fieldType, prefix, fieldName)
+			return ""
 		}
 
 	case SoftTimeTypeTime:
-		return fmt.Sprintf(`%s IS NULL`, quotedFieldName)
+		return fmt.Sprintf(`%s IS NULL`, quotedName)
 
 	default:
-		return fmt.Sprintf(`%s=0`, quotedFieldName)
+		return fmt.Sprintf(`%s=0`, quotedName)
 	}
-	return ""
 }
 
-// GetValueByFieldTypeForCreateOrUpdate creates and returns the value for specified field type,
-// usually for creating or updating operations.
-func (m *softTimeMaintainer) GetValueByFieldTypeForCreateOrUpdate(
-	ctx context.Context, fieldType LocalType, isDeletedField bool,
+// GetFieldValue generates value for create/update/delete operations.
+func (m *softTimeMaintainer) GetFieldValue(
+	ctx context.Context, fieldType LocalType, isDeleted bool,
 ) any {
-	var value any
-	if isDeletedField {
-		switch fieldType {
-		case LocalTypeDate, LocalTypeTime, LocalTypeDatetime:
-			value = nil
-		default:
-			value = 0
-		}
-		return value
+	// For deleted field, return "empty" value
+	if isDeleted {
+		return m.getEmptyValue(fieldType)
 	}
+
+	// For create/update/delete, return current time value
 	switch m.softTimeOption.SoftTimeType {
 	case SoftTimeTypeAuto:
-		switch fieldType {
-		case LocalTypeDate, LocalTypeTime, LocalTypeDatetime:
-			value = gtime.Now()
-		case LocalTypeInt, LocalTypeUint, LocalTypeInt64, LocalTypeUint64:
-			value = gtime.Timestamp()
-		case LocalTypeBool:
-			value = 1
-		default:
-			intlog.Errorf(
-				ctx,
-				`invalid field type "%s" for soft deleting data`,
-				fieldType,
-			)
-		}
-
+		return m.getAutoValue(ctx, fieldType)
 	default:
 		switch fieldType {
 		case LocalTypeBool:
-			value = 1
+			return 1
 		default:
-			value = m.createValueBySoftTimeOption(isDeletedField)
+			return m.getTimestampValue()
 		}
 	}
-	return value
 }
 
-func (m *softTimeMaintainer) createValueBySoftTimeOption(isDeletedField bool) any {
-	var value any
-	if isDeletedField {
-		switch m.softTimeOption.SoftTimeType {
-		case SoftTimeTypeTime:
-			value = nil
-		default:
-			value = 0
-		}
-		return value
-	}
+// getTimestampValue returns timestamp value for soft time.
+func (m *softTimeMaintainer) getTimestampValue() any {
 	switch m.softTimeOption.SoftTimeType {
 	case SoftTimeTypeTime:
-		value = gtime.Now()
+		return gtime.Now()
 	case SoftTimeTypeTimestamp:
-		value = gtime.Timestamp()
+		return gtime.Timestamp()
 	case SoftTimeTypeTimestampMilli:
-		value = gtime.TimestampMilli()
+		return gtime.TimestampMilli()
 	case SoftTimeTypeTimestampMicro:
-		value = gtime.TimestampMicro()
+		return gtime.TimestampMicro()
 	case SoftTimeTypeTimestampNano:
-		value = gtime.TimestampNano()
+		return gtime.TimestampNano()
 	default:
 		panic(gerror.NewCodef(
 			gcode.CodeInternalPanic,
 			`unrecognized SoftTimeType "%d"`, m.softTimeOption.SoftTimeType,
 		))
 	}
-	return value
+}
+
+// getEmptyValue returns "empty" value for deleted field.
+func (m *softTimeMaintainer) getEmptyValue(fieldType LocalType) any {
+	switch fieldType {
+	case LocalTypeDate, LocalTypeTime, LocalTypeDatetime:
+		return nil
+	default:
+		return 0
+	}
+}
+
+// getAutoValue returns auto-detected value based on field type.
+func (m *softTimeMaintainer) getAutoValue(ctx context.Context, fieldType LocalType) any {
+	switch fieldType {
+	case LocalTypeDate, LocalTypeTime, LocalTypeDatetime:
+		return gtime.Now()
+	case LocalTypeInt, LocalTypeUint, LocalTypeInt64, LocalTypeUint64:
+		return gtime.Timestamp()
+	case LocalTypeBool:
+		return 1
+	default:
+		intlog.Errorf(ctx, `invalid field type "%s" for soft time auto value`, fieldType)
+		return nil
+	}
 }
diff --git a/database/gdb/gdb_model_update.go b/database/gdb/gdb_model_update.go
index 05e430b13..714c6d06e 100644
--- a/database/gdb/gdb_model_update.go
+++ b/database/gdb/gdb_model_update.go
@@ -50,9 +50,7 @@ func (m *Model) Update(dataAndWhere ...any) (result sql.Result, err error) {
 		reflectInfo                                   = reflection.OriginTypeAndKind(m.data)
 		conditionWhere, conditionExtra, conditionArgs = m.formatCondition(ctx, false, false)
 		conditionStr                                  = conditionWhere + conditionExtra
-		fieldNameUpdate, fieldTypeUpdate              = stm.GetFieldNameAndTypeForUpdate(
-			ctx, "", m.tablesInit,
-		)
+		fieldNameUpdate, fieldTypeUpdate              = stm.GetFieldInfo(ctx, "", m.tablesInit, SoftTimeFieldUpdate)
 	)
 	if fieldNameUpdate != "" && (m.unscoped || m.isFieldInFieldsEx(fieldNameUpdate)) {
 		fieldNameUpdate = ""
@@ -68,7 +66,7 @@ func (m *Model) Update(dataAndWhere ...any) (result sql.Result, err error) {
 		var dataMap = anyValueToMapBeforeToRecord(newData)
 		// Automatically update the record updating time.
 		if fieldNameUpdate != "" && empty.IsNil(dataMap[fieldNameUpdate]) {
-			dataValue := stm.GetValueByFieldTypeForCreateOrUpdate(ctx, fieldTypeUpdate, false)
+			dataValue := stm.GetFieldValue(ctx, fieldTypeUpdate, false)
 			dataMap[fieldNameUpdate] = dataValue
 		}
 		newData = dataMap
@@ -77,7 +75,7 @@ func (m *Model) Update(dataAndWhere ...any) (result sql.Result, err error) {
 		var updateStr = gconv.String(newData)
 		// Automatically update the record updating time.
 		if fieldNameUpdate != "" && !gstr.Contains(updateStr, fieldNameUpdate) {
-			dataValue := stm.GetValueByFieldTypeForCreateOrUpdate(ctx, fieldTypeUpdate, false)
+			dataValue := stm.GetFieldValue(ctx, fieldTypeUpdate, false)
 			updateStr += fmt.Sprintf(`,%s=?`, fieldNameUpdate)
 			conditionArgs = append([]any{dataValue}, conditionArgs...)
 		}
diff --git a/database/gdb/gdb_model_utility.go b/database/gdb/gdb_model_utility.go
index 4da7dc69e..1ced41c39 100644
--- a/database/gdb/gdb_model_utility.go
+++ b/database/gdb/gdb_model_utility.go
@@ -68,6 +68,11 @@ func (m *Model) mappingAndFilterToTableFields(table string, fields []any, filter
 	if fieldsTable != "" {
 		hasTable, _ := m.db.GetCore().HasTable(fieldsTable)
 		if !hasTable {
+			if fieldsTable != m.tablesInit {
+				// Table/alias unknown (e.g., FieldsPrefix called before LeftJoin), skip filtering.
+				return fields
+			}
+			// HasTable cache miss for main table, fallback to use main table for field mapping.
 			fieldsTable = m.tablesInit
 		}
 	}
diff --git a/database/gdb/gdb_panic_recovery_test.go b/database/gdb/gdb_panic_recovery_test.go
new file mode 100644
index 000000000..92590290f
--- /dev/null
+++ b/database/gdb/gdb_panic_recovery_test.go
@@ -0,0 +1,159 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gdb
+
+import (
+	"context"
+	"database/sql"
+	"strings"
+	"testing"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+// mockPanicStmt simulates a prepared statement that panics during execution
+type mockPanicStmt struct {
+	panicMessage string
+}
+
+func (m *mockPanicStmt) ExecContext(ctx context.Context, args ...any) (sql.Result, error) {
+	if m.panicMessage != "" {
+		panic(m.panicMessage)
+	}
+	panic("math/big: buffer too small to fit value")
+}
+
+func (m *mockPanicStmt) QueryContext(ctx context.Context, args ...any) (*sql.Rows, error) {
+	if m.panicMessage != "" {
+		panic(m.panicMessage)
+	}
+	panic("math/big: buffer too small to fit value")
+}
+
+func (m *mockPanicStmt) QueryRowContext(ctx context.Context, args ...any) *sql.Row {
+	if m.panicMessage != "" {
+		panic(m.panicMessage)
+	}
+	panic("math/big: buffer too small to fit value")
+}
+
+func (m *mockPanicStmt) Close() error {
+	return nil
+}
+
+// Test_PanicRecoveryErrorWrapping tests that the panic recovery properly wraps errors
+// with correct error codes and messages
+func Test_PanicRecoveryErrorWrapping(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test creating an error from a string panic value
+		defer func() {
+			if exception := recover(); exception != nil {
+				var err error
+				if v, ok := exception.(error); ok && gerror.HasStack(v) {
+					err = v
+				} else {
+					err = gerror.WrapCodef(gcode.CodeDbOperationError, gerror.NewCodef(gcode.CodeInternalPanic, "%+v", exception), "test SQL")
+				}
+
+				t.AssertNE(err, nil)
+				t.Assert(strings.Contains(err.Error(), "buffer too small"), true)
+				t.Assert(strings.Contains(err.Error(), "test SQL"), true)
+			}
+		}()
+
+		// Simulate the panic that would occur in database operations
+		panic("math/big: buffer too small to fit value")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test creating an error from an error panic value with stack
+		defer func() {
+			if exception := recover(); exception != nil {
+				var err error
+				if v, ok := exception.(error); ok && gerror.HasStack(v) {
+					err = v
+				} else {
+					err = gerror.WrapCodef(gcode.CodeDbOperationError, gerror.NewCodef(gcode.CodeInternalPanic, "%+v", exception), "test SQL")
+				}
+
+				t.AssertNE(err, nil)
+				// Since gerror has stack, it should preserve the original error
+				t.Assert(strings.Contains(err.Error(), "custom database error"), true)
+			}
+		}()
+
+		// Simulate a panic with a custom error that has stack
+		customErr := gerror.New("custom database error")
+		panic(customErr)
+	})
+}
+
+// Test_DoCommit_StmtPanicRecovery simulates the scenario from the issue where
+// statement execution causes a panic during DoCommit operations
+func Test_DoCommit_StmtPanicRecovery(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// We'll test the panic recovery by triggering it in the defer function
+		// Since we can't easily mock sql.Stmt, we'll test the panic recovery mechanism directly
+
+		testPanicRecovery := func(panicValue any, sqlText string) (err error) {
+			defer func() {
+				if exception := recover(); exception != nil {
+					if err == nil {
+						if v, ok := exception.(error); ok && gerror.HasStack(v) {
+							err = v
+						} else {
+							err = gerror.WrapCodef(gcode.CodeDbOperationError, gerror.NewCodef(gcode.CodeInternalPanic, "%+v", exception), FormatSqlWithArgs(sqlText, []any{123}))
+						}
+					}
+				}
+			}()
+
+			// Simulate the panic that would occur in database operations
+			panic(panicValue)
+		}
+
+		// Test different panic scenarios
+		testCases := []struct {
+			name       string
+			panicValue any
+			sqlText    string
+		}{
+			{
+				name:       "String panic from math/big",
+				panicValue: "math/big: buffer too small to fit value",
+				sqlText:    "INSERT INTO test VALUES (?)",
+			},
+			{
+				name:       "Custom error panic",
+				panicValue: gerror.New("clickhouse driver panic"),
+				sqlText:    "SELECT * FROM test WHERE id = ?",
+			},
+		}
+
+		for _, tc := range testCases {
+			t.Log("Testing:", tc.name)
+
+			// Test the panic recovery mechanism
+			err := testPanicRecovery(tc.panicValue, tc.sqlText)
+
+			// After our fix, these should return errors instead of panicking
+			t.AssertNE(err, nil)
+
+			// Verify the error contains information about the panic
+			errorMsg := err.Error()
+
+			if tc.name == "String panic from math/big" {
+				t.Assert(strings.Contains(errorMsg, "buffer too small"), true)
+				t.Assert(strings.Contains(errorMsg, "INSERT INTO test VALUES"), true)
+			} else {
+				t.Assert(strings.Contains(errorMsg, "clickhouse driver panic"), true)
+			}
+		}
+	})
+}
diff --git a/database/gdb/gdb_type_result.go b/database/gdb/gdb_type_result.go
index d35f7b0d8..b1c1767ae 100644
--- a/database/gdb/gdb_type_result.go
+++ b/database/gdb/gdb_type_result.go
@@ -76,8 +76,8 @@ func (r Result) List() List {
 // Array retrieves and returns specified column values as slice.
 // The parameter `field` is optional is the column field is only one.
 // The default `field` is the first field name of the first item in `Result` if parameter `field` is not given.
-func (r Result) Array(field ...string) []Value {
-	array := make([]Value, len(r))
+func (r Result) Array(field ...string) Array {
+	array := make(Array, len(r))
 	if len(r) == 0 {
 		return array
 	}
diff --git a/database/gdb/gdb_z_core_config_external_test.go b/database/gdb/gdb_z_core_config_external_test.go
new file mode 100644
index 000000000..9df60c65b
--- /dev/null
+++ b/database/gdb/gdb_z_core_config_external_test.go
@@ -0,0 +1,1229 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gdb_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_GetAllConfig(t *testing.T) {
+	// Test case 1: Empty configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config to empty
+		gdb.SetConfig(make(gdb.Config))
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 0)
+	})
+
+	// Test case 2: Single configuration group with one node
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		testNode := gdb.ConfigNode{
+			Host: "127.0.0.1",
+			Port: "3306",
+			User: "root",
+			Pass: "123456",
+			Name: "test_db",
+			Type: "mysql",
+		}
+
+		err := gdb.AddConfigNode("test_group", testNode)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["test_group"]), 1)
+		t.Assert(result["test_group"][0].Host, "127.0.0.1")
+		t.Assert(result["test_group"][0].Port, "3306")
+		t.Assert(result["test_group"][0].User, "root")
+		t.Assert(result["test_group"][0].Pass, "123456")
+		t.Assert(result["test_group"][0].Name, "test_db")
+		t.Assert(result["test_group"][0].Type, "mysql")
+	})
+
+	// Test case 3: Multiple configuration groups with multiple nodes
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		// Add first group with two nodes
+		testNode1 := gdb.ConfigNode{
+			Host: "127.0.0.1",
+			Port: "3306",
+			User: "root",
+			Pass: "123456",
+			Name: "master_db",
+			Type: "mysql",
+			Role: "master",
+		}
+		testNode2 := gdb.ConfigNode{
+			Host: "127.0.0.2",
+			Port: "3306",
+			User: "root",
+			Pass: "123456",
+			Name: "slave_db",
+			Type: "mysql",
+			Role: "slave",
+		}
+
+		err := gdb.AddConfigNode("mysql_cluster", testNode1)
+		t.AssertNil(err)
+		err = gdb.AddConfigNode("mysql_cluster", testNode2)
+		t.AssertNil(err)
+
+		// Add second group with one node
+		testNode3 := gdb.ConfigNode{
+			Host: "localhost",
+			Port: "5432",
+			User: "postgres",
+			Pass: "password",
+			Name: "pg_db",
+			Type: "pgsql",
+		}
+
+		err = gdb.AddConfigNode("postgres_db", testNode3)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 2)
+
+		// Check mysql_cluster group
+		t.Assert(len(result["mysql_cluster"]), 2)
+		t.Assert(result["mysql_cluster"][0].Host, "127.0.0.1")
+		t.Assert(result["mysql_cluster"][0].Role, "master")
+		t.Assert(result["mysql_cluster"][1].Host, "127.0.0.2")
+		t.Assert(result["mysql_cluster"][1].Role, "slave")
+
+		// Check postgres_db group
+		t.Assert(len(result["postgres_db"]), 1)
+		t.Assert(result["postgres_db"][0].Host, "localhost")
+		t.Assert(result["postgres_db"][0].Port, "5432")
+		t.Assert(result["postgres_db"][0].Type, "pgsql")
+	})
+
+	// Test case 4: Configuration with Link syntax
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		testNode := gdb.ConfigNode{
+			Link: "mysql:root:123456@tcp(127.0.0.1:3306)/test_db?charset=utf8",
+		}
+
+		err := gdb.AddConfigNode("link_test", testNode)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["link_test"]), 1)
+
+		// Check parsed values from link
+		node := result["link_test"][0]
+		t.Assert(node.Type, "mysql")
+		t.Assert(node.User, "root")
+		t.Assert(node.Pass, "123456")
+		t.Assert(node.Host, "127.0.0.1")
+		t.Assert(node.Port, "3306")
+		t.Assert(node.Name, "test_db")
+		t.Assert(node.Charset, "utf8")
+		t.Assert(node.Protocol, "tcp")
+	})
+
+	// Test case 5: Default group configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		testNode := gdb.ConfigNode{
+			Host: "localhost",
+			Port: "3306",
+			User: "user",
+			Pass: "pass",
+			Name: "default_db",
+			Type: "mysql",
+		}
+
+		err := gdb.AddDefaultConfigNode(testNode)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["default"]), 1)
+		t.Assert(result["default"][0].Host, "localhost")
+		t.Assert(result["default"][0].Name, "default_db")
+	})
+
+	// Test case 6: SetConfig with multiple groups
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		testConfig := gdb.Config{
+			"group1": gdb.ConfigGroup{
+				{
+					Host: "host1",
+					Port: "3306",
+					User: "user1",
+					Pass: "pass1",
+					Name: "db1",
+					Type: "mysql",
+				},
+			},
+			"group2": gdb.ConfigGroup{
+				{
+					Host: "host2",
+					Port: "5432",
+					User: "user2",
+					Pass: "pass2",
+					Name: "db2",
+					Type: "pgsql",
+				},
+				{
+					Host: "host3",
+					Port: "5432",
+					User: "user3",
+					Pass: "pass3",
+					Name: "db3",
+					Type: "pgsql",
+				},
+			},
+		}
+
+		err := gdb.SetConfig(testConfig)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 2)
+		t.Assert(len(result["group1"]), 1)
+		t.Assert(len(result["group2"]), 2)
+
+		t.Assert(result["group1"][0].Host, "host1")
+		t.Assert(result["group1"][0].Type, "mysql")
+
+		t.Assert(result["group2"][0].Host, "host2")
+		t.Assert(result["group2"][0].Type, "pgsql")
+		t.Assert(result["group2"][1].Host, "host3")
+		t.Assert(result["group2"][1].Type, "pgsql")
+	})
+
+	// Test case 7: Test return value is a copy (not reference)
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		testNode := gdb.ConfigNode{
+			Host: "original_host",
+			Port: "3306",
+			User: "original_user",
+			Pass: "original_pass",
+			Name: "original_db",
+			Type: "mysql",
+		}
+
+		err := gdb.AddConfigNode("test_copy", testNode)
+		t.AssertNil(err)
+
+		// Get config and modify it
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+
+		// Verify original values
+		t.Assert(result["test_copy"][0].Host, "original_host")
+
+		// Note: GetAllConfig returns the internal config directly (not a copy)
+		// This is by design for performance reasons
+		// So modifying the returned config would affect the internal state
+		// This test just verifies the current behavior
+	})
+}
+
+func Test_SetConfig(t *testing.T) {
+	// Test case 1: Normal configuration setting
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		testConfig := gdb.Config{
+			"group1": gdb.ConfigGroup{
+				{
+					Host: "127.0.0.1",
+					Port: "3306",
+					User: "root",
+					Pass: "123456",
+					Name: "test_db",
+					Type: "mysql",
+				},
+			},
+			"group2": gdb.ConfigGroup{
+				{
+					Host: "192.168.1.100",
+					Port: "5432",
+					User: "postgres",
+					Pass: "password",
+					Name: "pg_db",
+					Type: "pgsql",
+				},
+			},
+		}
+
+		err := gdb.SetConfig(testConfig)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 2)
+		t.Assert(result["group1"][0].Host, "127.0.0.1")
+		t.Assert(result["group2"][0].Type, "pgsql")
+	})
+
+	// Test case 2: Empty configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		testConfig := gdb.Config{}
+		err := gdb.SetConfig(testConfig)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 0)
+	})
+
+	// Test case 3: Configuration with Link syntax
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		testConfig := gdb.Config{
+			"mysql_link": gdb.ConfigGroup{
+				{
+					Link: "mysql:root:123456@tcp(127.0.0.1:3306)/test_db?charset=utf8",
+				},
+			},
+		}
+
+		err := gdb.SetConfig(testConfig)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		node := result["mysql_link"][0]
+		t.Assert(node.Type, "mysql")
+		t.Assert(node.User, "root")
+		t.Assert(node.Host, "127.0.0.1")
+		t.Assert(node.Port, "3306")
+		t.Assert(node.Name, "test_db")
+	})
+
+	// Test case 4: Configuration with invalid Link syntax
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		testConfig := gdb.Config{
+			"invalid_link": gdb.ConfigGroup{
+				{
+					Link: "invalid_link_format",
+				},
+			},
+		}
+
+		err := gdb.SetConfig(testConfig)
+		t.AssertNE(err, nil)
+	})
+}
+
+func Test_SetConfigGroup(t *testing.T) {
+	// Test case 1: Set new group configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		nodes := gdb.ConfigGroup{
+			{
+				Host: "127.0.0.1",
+				Port: "3306",
+				User: "root",
+				Pass: "123456",
+				Name: "db1",
+				Type: "mysql",
+				Role: "master",
+			},
+			{
+				Host: "127.0.0.2",
+				Port: "3306",
+				User: "root",
+				Pass: "123456",
+				Name: "db2",
+				Type: "mysql",
+				Role: "slave",
+			},
+		}
+
+		err := gdb.SetConfigGroup("test_group", nodes)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["test_group"]), 2)
+		t.Assert(result["test_group"][0].Role, "master")
+		t.Assert(result["test_group"][1].Role, "slave")
+	})
+
+	// Test case 2: Overwrite existing group configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		// First set
+		nodes1 := gdb.ConfigGroup{
+			{
+				Host: "old_host",
+				Port: "3306",
+				User: "old_user",
+				Name: "old_db",
+				Type: "mysql",
+			},
+		}
+		err := gdb.SetConfigGroup("test_group", nodes1)
+		t.AssertNil(err)
+
+		// Overwrite with new config
+		nodes2 := gdb.ConfigGroup{
+			{
+				Host: "new_host",
+				Port: "5432",
+				User: "new_user",
+				Name: "new_db",
+				Type: "pgsql",
+			},
+		}
+		err = gdb.SetConfigGroup("test_group", nodes2)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["test_group"]), 1)
+		t.Assert(result["test_group"][0].Host, "new_host")
+		t.Assert(result["test_group"][0].Type, "pgsql")
+	})
+
+	// Test case 3: Empty group configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		nodes := gdb.ConfigGroup{}
+		err := gdb.SetConfigGroup("empty_group", nodes)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["empty_group"]), 0)
+	})
+
+	// Test case 4: Configuration with invalid Link syntax
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		nodes := gdb.ConfigGroup{
+			{
+				Link: "invalid_link",
+			},
+		}
+
+		err := gdb.SetConfigGroup("invalid_group", nodes)
+		t.AssertNE(err, nil)
+	})
+}
+
+func Test_AddConfigNode(t *testing.T) {
+	// Test case 1: Add node to new group
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		node := gdb.ConfigNode{
+			Host: "127.0.0.1",
+			Port: "3306",
+			User: "root",
+			Pass: "123456",
+			Name: "test_db",
+			Type: "mysql",
+		}
+
+		err := gdb.AddConfigNode("new_group", node)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["new_group"]), 1)
+		t.Assert(result["new_group"][0].Host, "127.0.0.1")
+	})
+
+	// Test case 2: Add node to existing group
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		// Add first node
+		node1 := gdb.ConfigNode{
+			Host: "127.0.0.1",
+			Port: "3306",
+			User: "root",
+			Pass: "123456",
+			Name: "db1",
+			Type: "mysql",
+		}
+		err := gdb.AddConfigNode("existing_group", node1)
+		t.AssertNil(err)
+
+		// Add second node to same group
+		node2 := gdb.ConfigNode{
+			Host: "127.0.0.2",
+			Port: "3306",
+			User: "root",
+			Pass: "123456",
+			Name: "db2",
+			Type: "mysql",
+		}
+		err = gdb.AddConfigNode("existing_group", node2)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["existing_group"]), 2)
+		t.Assert(result["existing_group"][0].Name, "db1")
+		t.Assert(result["existing_group"][1].Name, "db2")
+	})
+
+	// Test case 3: Add node with Link syntax
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		node := gdb.ConfigNode{
+			Link: "mysql:root:password@tcp(192.168.1.100:3306)/mydb?charset=utf8mb4",
+		}
+
+		err := gdb.AddConfigNode("link_group", node)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["link_group"]), 1)
+		t.Assert(result["link_group"][0].Type, "mysql")
+		t.Assert(result["link_group"][0].Host, "192.168.1.100")
+		t.Assert(result["link_group"][0].Port, "3306")
+		t.Assert(result["link_group"][0].Name, "mydb")
+	})
+
+	// Test case 4: Add node with invalid Link syntax
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		node := gdb.ConfigNode{
+			Link: "invalid_link_format",
+		}
+
+		err := gdb.AddConfigNode("invalid_group", node)
+		t.AssertNE(err, nil)
+	})
+}
+
+func Test_AddDefaultConfigNode(t *testing.T) {
+	// Test case 1: Add node to default group
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		node := gdb.ConfigNode{
+			Host: "localhost",
+			Port: "3306",
+			User: "root",
+			Pass: "root",
+			Name: "default_db",
+			Type: "mysql",
+		}
+
+		err := gdb.AddDefaultConfigNode(node)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["default"]), 1)
+		t.Assert(result["default"][0].Host, "localhost")
+		t.Assert(result["default"][0].Name, "default_db")
+	})
+
+	// Test case 2: Add multiple nodes to default group
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		node1 := gdb.ConfigNode{
+			Host: "127.0.0.1",
+			Port: "3306",
+			User: "root",
+			Pass: "123456",
+			Name: "db1",
+			Type: "mysql",
+			Role: "master",
+		}
+		err := gdb.AddDefaultConfigNode(node1)
+		t.AssertNil(err)
+
+		node2 := gdb.ConfigNode{
+			Host: "127.0.0.2",
+			Port: "3306",
+			User: "root",
+			Pass: "123456",
+			Name: "db2",
+			Type: "mysql",
+			Role: "slave",
+		}
+		err = gdb.AddDefaultConfigNode(node2)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["default"]), 2)
+		t.Assert(result["default"][0].Role, "master")
+		t.Assert(result["default"][1].Role, "slave")
+	})
+
+	// Test case 3: Add node with Link syntax to default group
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		node := gdb.ConfigNode{
+			Link: "pgsql:postgres:password@tcp(localhost:5432)/testdb",
+		}
+
+		err := gdb.AddDefaultConfigNode(node)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["default"]), 1)
+		t.Assert(result["default"][0].Type, "pgsql")
+		t.Assert(result["default"][0].User, "postgres")
+		t.Assert(result["default"][0].Host, "localhost")
+		t.Assert(result["default"][0].Port, "5432")
+		t.Assert(result["default"][0].Name, "testdb")
+	})
+}
+
+func Test_AddDefaultConfigGroup(t *testing.T) {
+	// Test case 1: Add multiple nodes to default group (deprecated function)
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		nodes := gdb.ConfigGroup{
+			{
+				Host: "127.0.0.1",
+				Port: "3306",
+				User: "root",
+				Pass: "123456",
+				Name: "db1",
+				Type: "mysql",
+				Role: "master",
+			},
+			{
+				Host: "127.0.0.2",
+				Port: "3306",
+				User: "root",
+				Pass: "123456",
+				Name: "db2",
+				Type: "mysql",
+				Role: "slave",
+			},
+		}
+
+		err := gdb.AddDefaultConfigGroup(nodes)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["default"]), 2)
+		t.Assert(result["default"][0].Role, "master")
+		t.Assert(result["default"][1].Role, "slave")
+	})
+
+	// Test case 2: Overwrite existing default group configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		// First set
+		node1 := gdb.ConfigNode{
+			Host: "old_host",
+			Port: "3306",
+			User: "old_user",
+			Name: "old_db",
+			Type: "mysql",
+		}
+		err := gdb.AddDefaultConfigNode(node1)
+		t.AssertNil(err)
+
+		// Overwrite with new group config
+		nodes := gdb.ConfigGroup{
+			{
+				Host: "new_host",
+				Port: "5432",
+				User: "new_user",
+				Name: "new_db",
+				Type: "pgsql",
+			},
+		}
+		err = gdb.AddDefaultConfigGroup(nodes)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["default"]), 1)
+		t.Assert(result["default"][0].Host, "new_host")
+		t.Assert(result["default"][0].Type, "pgsql")
+	})
+}
+
+func Test_SetDefaultConfigGroup(t *testing.T) {
+	// Test case 1: Set default group configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		nodes := gdb.ConfigGroup{
+			{
+				Host: "192.168.1.10",
+				Port: "3306",
+				User: "admin",
+				Pass: "admin123",
+				Name: "main_db",
+				Type: "mysql",
+				Role: "master",
+			},
+			{
+				Host: "192.168.1.11",
+				Port: "3306",
+				User: "admin",
+				Pass: "admin123",
+				Name: "backup_db",
+				Type: "mysql",
+				Role: "slave",
+			},
+		}
+
+		err := gdb.SetDefaultConfigGroup(nodes)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["default"]), 2)
+		t.Assert(result["default"][0].Host, "192.168.1.10")
+		t.Assert(result["default"][0].Role, "master")
+		t.Assert(result["default"][1].Host, "192.168.1.11")
+		t.Assert(result["default"][1].Role, "slave")
+	})
+
+	// Test case 2: Empty default group configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config and add some initial data
+		gdb.SetConfig(make(gdb.Config))
+		err := gdb.AddDefaultConfigNode(gdb.ConfigNode{
+			Host: "temp_host",
+			Name: "temp_db",
+			Type: "mysql",
+		})
+		t.AssertNil(err)
+
+		// Set empty group
+		nodes := gdb.ConfigGroup{}
+		err = gdb.SetDefaultConfigGroup(nodes)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["default"]), 0)
+	})
+
+	// Test case 3: Configuration with Link syntax
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		nodes := gdb.ConfigGroup{
+			{
+				Link: "mysql:root:123456@tcp(localhost:3306)/test_db1",
+			},
+			{
+				Link: "pgsql:postgres:password@tcp(localhost:5432)/test_db2",
+			},
+		}
+
+		err := gdb.SetDefaultConfigGroup(nodes)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(len(result["default"]), 2)
+		t.Assert(result["default"][0].Type, "mysql")
+		t.Assert(result["default"][0].Name, "test_db1")
+		t.Assert(result["default"][1].Type, "pgsql")
+		t.Assert(result["default"][1].Name, "test_db2")
+	})
+}
+
+func Test_GetConfig(t *testing.T) {
+	// Test case 1: Get existing group configuration (deprecated function)
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		node := gdb.ConfigNode{
+			Host: "127.0.0.1",
+			Port: "3306",
+			User: "root",
+			Pass: "123456",
+			Name: "test_db",
+			Type: "mysql",
+		}
+
+		err := gdb.AddConfigNode("test_group", node)
+		t.AssertNil(err)
+
+		result := gdb.GetConfig("test_group")
+		t.Assert(len(result), 1)
+		t.Assert(result[0].Host, "127.0.0.1")
+		t.Assert(result[0].Type, "mysql")
+	})
+
+	// Test case 2: Get non-existing group configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		result := gdb.GetConfig("non_existing_group")
+		t.Assert(len(result), 0)
+	})
+}
+
+func Test_GetConfigGroup(t *testing.T) {
+	// Test case 1: Get existing group configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		nodes := gdb.ConfigGroup{
+			{
+				Host: "127.0.0.1",
+				Port: "3306",
+				User: "root",
+				Pass: "123456",
+				Name: "db1",
+				Type: "mysql",
+				Role: "master",
+			},
+			{
+				Host: "127.0.0.2",
+				Port: "3306",
+				User: "root",
+				Pass: "123456",
+				Name: "db2",
+				Type: "mysql",
+				Role: "slave",
+			},
+		}
+
+		err := gdb.SetConfigGroup("test_group", nodes)
+		t.AssertNil(err)
+
+		result, err := gdb.GetConfigGroup("test_group")
+		t.AssertNil(err)
+		t.Assert(len(result), 2)
+		t.Assert(result[0].Host, "127.0.0.1")
+		t.Assert(result[0].Role, "master")
+		t.Assert(result[1].Host, "127.0.0.2")
+		t.Assert(result[1].Role, "slave")
+	})
+
+	// Test case 2: Get non-existing group configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		result, err := gdb.GetConfigGroup("non_existing_group")
+		t.AssertNE(err, nil)
+		t.Assert(result, nil)
+	})
+
+	// Test case 3: Get empty group configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		err := gdb.SetConfigGroup("empty_group", gdb.ConfigGroup{})
+		t.AssertNil(err)
+
+		result, err := gdb.GetConfigGroup("empty_group")
+		t.AssertNil(err)
+		t.Assert(len(result), 0)
+	})
+}
+
+func Test_SetDefaultGroup(t *testing.T) {
+	// Test case 1: Set default group name
+	gtest.C(t, func(t *gtest.T) {
+		// Save original group and restore after test
+		originalGroup := gdb.GetDefaultGroup()
+		defer func() {
+			gdb.SetDefaultGroup(originalGroup)
+		}()
+
+		gdb.SetDefaultGroup("custom_default")
+		result := gdb.GetDefaultGroup()
+		t.Assert(result, "custom_default")
+	})
+
+	// Test case 2: Set empty default group name
+	gtest.C(t, func(t *gtest.T) {
+		// Save original group and restore after test
+		originalGroup := gdb.GetDefaultGroup()
+		defer func() {
+			gdb.SetDefaultGroup(originalGroup)
+		}()
+
+		gdb.SetDefaultGroup("")
+		result := gdb.GetDefaultGroup()
+		t.Assert(result, "")
+	})
+
+	// Test case 3: Multiple calls to SetDefaultGroup
+	gtest.C(t, func(t *gtest.T) {
+		// Save original group and restore after test
+		originalGroup := gdb.GetDefaultGroup()
+		defer func() {
+			gdb.SetDefaultGroup(originalGroup)
+		}()
+
+		gdb.SetDefaultGroup("first_group")
+		result1 := gdb.GetDefaultGroup()
+		t.Assert(result1, "first_group")
+
+		gdb.SetDefaultGroup("second_group")
+		result2 := gdb.GetDefaultGroup()
+		t.Assert(result2, "second_group")
+	})
+}
+
+func Test_GetDefaultGroup(t *testing.T) {
+	// Test case 1: Get default group name
+	gtest.C(t, func(t *gtest.T) {
+		// Save original group and restore after test
+		originalGroup := gdb.GetDefaultGroup()
+		defer func() {
+			gdb.SetDefaultGroup(originalGroup)
+		}()
+
+		// Test with default value
+		result := gdb.GetDefaultGroup()
+		t.Assert(result, "default")
+	})
+
+	// Test case 2: Get custom default group name
+	gtest.C(t, func(t *gtest.T) {
+		// Save original group and restore after test
+		originalGroup := gdb.GetDefaultGroup()
+		defer func() {
+			gdb.SetDefaultGroup(originalGroup)
+		}()
+
+		gdb.SetDefaultGroup("my_custom_group")
+		result := gdb.GetDefaultGroup()
+		t.Assert(result, "my_custom_group")
+	})
+}
+
+func Test_IsConfigured(t *testing.T) {
+	// Test case 1: No configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config to empty
+		gdb.SetConfig(make(gdb.Config))
+
+		result := gdb.IsConfigured()
+		t.Assert(result, false)
+	})
+
+	// Test case 2: Has configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		node := gdb.ConfigNode{
+			Host: "127.0.0.1",
+			Port: "3306",
+			User: "root",
+			Pass: "123456",
+			Name: "test_db",
+			Type: "mysql",
+		}
+
+		err := gdb.AddConfigNode("test_group", node)
+		t.AssertNil(err)
+
+		result := gdb.IsConfigured()
+		t.Assert(result, true)
+	})
+
+	// Test case 3: Has empty group configuration
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		err := gdb.SetConfigGroup("empty_group", gdb.ConfigGroup{})
+		t.AssertNil(err)
+
+		result := gdb.IsConfigured()
+		t.Assert(result, true)
+	})
+}
+
+func Test_ConfigNode_ConnectionPoolSettings(t *testing.T) {
+	// Test connection pool configuration fields
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := gdb.GetAllConfig()
+		defer func() {
+			gdb.SetConfig(originalConfig)
+		}()
+
+		// Reset config
+		gdb.SetConfig(make(gdb.Config))
+
+		testNode := gdb.ConfigNode{
+			Host:             "127.0.0.1",
+			Port:             "3306",
+			User:             "root",
+			Pass:             "123456",
+			Name:             "test_db",
+			Type:             "mysql",
+			MaxIdleConnCount: 10,
+			MaxOpenConnCount: 100,
+			MaxConnLifeTime:  30 * time.Second,
+			MaxIdleConnTime:  10 * time.Second,
+		}
+
+		err := gdb.AddConfigNode("pool_test", testNode)
+		t.AssertNil(err)
+
+		result := gdb.GetAllConfig()
+		t.Assert(len(result), 1)
+		t.Assert(result["pool_test"][0].MaxIdleConnCount, 10)
+		t.Assert(result["pool_test"][0].MaxOpenConnCount, 100)
+		t.Assert(result["pool_test"][0].MaxConnLifeTime, 30*time.Second)
+		t.Assert(result["pool_test"][0].MaxIdleConnTime, 10*time.Second)
+	})
+}
diff --git a/database/gdb/gdb_z_core_config_test.go b/database/gdb/gdb_z_core_config_test.go
new file mode 100644
index 000000000..0deb8ab58
--- /dev/null
+++ b/database/gdb/gdb_z_core_config_test.go
@@ -0,0 +1,209 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gdb
+
+import (
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/os/glog"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_Core_SetDebug_GetDebug(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := configs.config
+		defer func() {
+			configs.config = originalConfig
+		}()
+
+		// Create a test configuration
+		configs.config = make(Config)
+		testNode := ConfigNode{
+			Host: "127.0.0.1",
+			Port: "3306",
+			User: "root",
+			Pass: "123456",
+			Name: "test_db",
+			Type: "mysql",
+		}
+		err := AddConfigNode("test_group", testNode)
+		t.AssertNil(err)
+
+		// Create Core instance
+		node, err := GetConfigGroup("test_group")
+		t.AssertNil(err)
+		core := &Core{
+			group:  "test_group",
+			config: &node[0],
+			debug:  gtype.NewBool(false),
+		}
+
+		// Test default value
+		result := core.GetDebug()
+		t.Assert(result, false)
+
+		// Test setting debug to true
+		core.SetDebug(true)
+		result = core.GetDebug()
+		t.Assert(result, true)
+
+		// Test setting debug to false
+		core.SetDebug(false)
+		result = core.GetDebug()
+		t.Assert(result, false)
+	})
+}
+
+func Test_Core_SetDryRun_GetDryRun(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := configs.config
+		defer func() {
+			configs.config = originalConfig
+		}()
+
+		// Create a test configuration
+		configs.config = make(Config)
+		testNode := ConfigNode{
+			Host:   "127.0.0.1",
+			Port:   "3306",
+			User:   "root",
+			Pass:   "123456",
+			Name:   "test_db",
+			Type:   "mysql",
+			DryRun: false,
+		}
+		err := AddConfigNode("test_group", testNode)
+		t.AssertNil(err)
+
+		// Create Core instance
+		node, err := GetConfigGroup("test_group")
+		t.AssertNil(err)
+		core := &Core{
+			group:  "test_group",
+			config: &node[0],
+		}
+
+		// Test default value
+		result := core.GetDryRun()
+		t.Assert(result, false)
+
+		// Test setting dry run to true
+		core.SetDryRun(true)
+		result = core.GetDryRun()
+		t.Assert(result, true)
+
+		// Test setting dry run to false
+		core.SetDryRun(false)
+		result = core.GetDryRun()
+		t.Assert(result, false)
+	})
+}
+
+func Test_Core_SetLogger_GetLogger(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create Core instance
+		core := &Core{}
+
+		// Test setting custom logger
+		customLogger := glog.New()
+		core.SetLogger(customLogger)
+		result := core.GetLogger()
+		t.Assert(result, customLogger)
+
+		// Test setting nil logger
+		core.SetLogger(nil)
+		result = core.GetLogger()
+		t.Assert(result, nil)
+	})
+}
+
+func Test_Core_SetMaxConnections(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create Core instance
+		core := &Core{}
+
+		// Test SetMaxIdleConnCount
+		core.SetMaxIdleConnCount(10)
+		t.Assert(core.dynamicConfig.MaxIdleConnCount, 10)
+
+		// Test SetMaxOpenConnCount
+		core.SetMaxOpenConnCount(20)
+		t.Assert(core.dynamicConfig.MaxOpenConnCount, 20)
+
+		// Test SetMaxConnLifeTime
+		testDuration := time.Hour
+		core.SetMaxConnLifeTime(testDuration)
+		t.Assert(core.dynamicConfig.MaxConnLifeTime, testDuration)
+
+		// Test SetMaxIdleConnTime
+		idleTimeDuration := 30 * time.Minute
+		core.SetMaxIdleConnTime(idleTimeDuration)
+		t.Assert(core.dynamicConfig.MaxIdleConnTime, idleTimeDuration)
+	})
+}
+
+func Test_Core_GetCache(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create Core instance
+		core := &Core{}
+
+		cache := core.GetCache()
+		// Cache might be nil if not initialized, so we just test that the call doesn't panic
+		_ = cache
+	})
+}
+
+func Test_Core_GetGroup(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create Core instance
+		core := &Core{
+			group: "test_group",
+		}
+
+		group := core.GetGroup()
+		t.Assert(group, "test_group")
+	})
+}
+
+func Test_Core_GetPrefix(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Save original config and restore after test
+		originalConfig := configs.config
+		defer func() {
+			configs.config = originalConfig
+		}()
+
+		// Create a test configuration
+		configs.config = make(Config)
+		testNode := ConfigNode{
+			Host:   "127.0.0.1",
+			Port:   "3306",
+			User:   "root",
+			Pass:   "123456",
+			Name:   "test_db",
+			Type:   "mysql",
+			Prefix: "gf_",
+		}
+		err := AddConfigNode("test_group", testNode)
+		t.AssertNil(err)
+
+		// Create Core instance
+		node, err := GetConfigGroup("test_group")
+		t.AssertNil(err)
+		core := &Core{
+			group:  "test_group",
+			config: &node[0],
+		}
+
+		prefix := core.GetPrefix()
+		t.Assert(prefix, "gf_")
+	})
+}
diff --git a/database/gredis/gredis_config.go b/database/gredis/gredis_config.go
index 69d410a8f..6b1124f25 100644
--- a/database/gredis/gredis_config.go
+++ b/database/gredis/gredis_config.go
@@ -50,8 +50,10 @@ const (
 )
 
 var (
+	// configChecker checks whether the *Config is nil.
+	configChecker = func(v *Config) bool { return v == nil }
 	// Configuration groups.
-	localConfigMap = gmap.NewStrAnyMap(true)
+	localConfigMap = gmap.NewKVMapWithChecker[string, *Config](configChecker, true)
 )
 
 // SetConfig sets the global configuration for specified group.
@@ -119,7 +121,7 @@ func GetConfig(name ...string) (config *Config, ok bool) {
 		group = name[0]
 	}
 	if v := localConfigMap.Get(group); v != nil {
-		return v.(*Config), true
+		return v, true
 	}
 	return &Config{}, false
 }
diff --git a/database/gredis/gredis_instance.go b/database/gredis/gredis_instance.go
index 68a2f67e2..1f44368c3 100644
--- a/database/gredis/gredis_instance.go
+++ b/database/gredis/gredis_instance.go
@@ -14,8 +14,9 @@ import (
 )
 
 var (
-	// localInstances for instance management of redis client.
-	localInstances = gmap.NewStrAnyMap(true)
+	// checker is the checker function for instances map.
+	checker        = func(v *Redis) bool { return v == nil }
+	localInstances = gmap.NewKVMapWithChecker[string, *Redis](checker, true)
 )
 
 // Instance returns an instance of redis client with specified group.
@@ -26,7 +27,7 @@ func Instance(name ...string) *Redis {
 	if len(name) > 0 && name[0] != "" {
 		group = name[0]
 	}
-	v := localInstances.GetOrSetFuncLock(group, func() any {
+	return localInstances.GetOrSetFuncLock(group, func() *Redis {
 		if config, ok := GetConfig(group); ok {
 			r, err := New(config)
 			if err != nil {
@@ -37,8 +38,4 @@ func Instance(name ...string) *Redis {
 		}
 		return nil
 	})
-	if v != nil {
-		return v.(*Redis)
-	}
-	return nil
 }
diff --git a/encoding/gjson/gjson.go b/encoding/gjson/gjson.go
index a939fb6eb..b2f915606 100644
--- a/encoding/gjson/gjson.go
+++ b/encoding/gjson/gjson.go
@@ -21,7 +21,7 @@ import (
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
-type ContentType string
+type ContentType = string
 
 const (
 	ContentTypeJSON       ContentType = `json`
@@ -35,23 +35,40 @@ const (
 )
 
 const (
-	defaultSplitChar = '.' // Separator char for hierarchical data access.
+	// Separator char for hierarchical data access.
+	defaultSplitChar = '.'
 )
 
 // Json is the customized JSON struct.
 type Json struct {
 	mu rwmutex.RWMutex
-	p  *any // Pointer for hierarchical data access, it's the root of data in default.
-	c  byte // Char separator('.' in default).
-	vc bool // Violence Check(false in default), which is used to access data when the hierarchical data key contains separator char.
+
+	// Pointer for hierarchical data access, it's the root of data in default.
+	p *any
+
+	// Char separator('.' in default).
+	c byte
+
+	// Violence Check(false in default),
+	// which is used to access data when the hierarchical data key contains separator char.
+	vc bool
 }
 
 // Options for Json object creating/loading.
 type Options struct {
-	Safe      bool        // Mark this object is for in concurrent-safe usage. This is especially for Json object creating.
-	Tags      string      // Custom priority tags for decoding, eg: "json,yaml,MyTag". This is especially for struct parsing into Json object.
-	Type      ContentType // Type specifies the data content type, eg: json, xml, yaml, toml, ini.
-	StrNumber bool        // StrNumber causes the Decoder to unmarshal a number into an any as a string instead of as a float64.
+	// Mark this object is for in concurrent-safe usage. This is especially for Json object creating.
+	Safe bool
+
+	// Custom priority tags for decoding, eg: "json,yaml,MyTag".
+	// This is specially for struct parsing into Json object.
+	Tags string
+
+	// Type specifies the data content type, eg: json, xml, yaml, toml, ini.
+	Type ContentType
+
+	// StrNumber causes the Decoder to unmarshal a number into an any as a string instead of as a float64.
+	// This is specially for json content parsing into Json object.
+	StrNumber bool
 }
 
 // iInterfaces is used for type assert api for Interfaces().
diff --git a/encoding/gjson/gjson_api.go b/encoding/gjson/gjson_api.go
index 63c75ee28..f00c9e3c8 100644
--- a/encoding/gjson/gjson_api.go
+++ b/encoding/gjson/gjson_api.go
@@ -142,6 +142,8 @@ func (j *Json) Contains(pattern string) bool {
 // The target value by `pattern` should be type of slice or map.
 // It returns -1 if the target value is not found, or its type is invalid.
 func (j *Json) Len(pattern string) int {
+	j.mu.RLock()
+	defer j.mu.RUnlock()
 	p := j.getPointerByPattern(pattern)
 	if p != nil {
 		switch (*p).(type) {
diff --git a/encoding/gjson/gjson_api_new_load.go b/encoding/gjson/gjson_api_new_load.go
index 761584b8b..c89c72658 100644
--- a/encoding/gjson/gjson_api_new_load.go
+++ b/encoding/gjson/gjson_api_new_load.go
@@ -76,13 +76,23 @@ func NewWithOptions(data any, options Options) *Json {
 			pointedData = gconv.Interfaces(data)
 
 		case reflect.Map:
-			pointedData = gconv.MapDeep(data, options.Tags)
+			pointedData = gconv.Map(data, gconv.MapOption{
+				Deep:            true,
+				OmitEmpty:       false,
+				Tags:            []string{options.Tags},
+				ContinueOnError: true,
+			})
 
 		case reflect.Struct:
 			if v, ok := data.(iVal); ok {
 				return NewWithOptions(v.Val(), options)
 			}
-			pointedData = gconv.MapDeep(data, options.Tags)
+			pointedData = gconv.Map(data, gconv.MapOption{
+				Deep:            true,
+				OmitEmpty:       false,
+				Tags:            []string{options.Tags},
+				ContinueOnError: true,
+			})
 
 		default:
 			pointedData = data
diff --git a/encoding/gjson/gjson_api_new_load_content.go b/encoding/gjson/gjson_api_new_load_content.go
index fa102e910..5ae5c6f9e 100644
--- a/encoding/gjson/gjson_api_new_load_content.go
+++ b/encoding/gjson/gjson_api_new_load_content.go
@@ -161,56 +161,86 @@ func loadContentWithOptions(data []byte, options Options) (*Json, error) {
 	if len(data) == 0 {
 		return NewWithOptions(nil, options), nil
 	}
-	if options.Type == "" {
-		options.Type, err = checkDataType(data)
+	var (
+		checkType   ContentType
+		decodedData any
+	)
+	if options.Type != "" {
+		checkType = gstr.TrimLeft(options.Type, ".")
+	} else {
+		checkType, err = checkDataType(data)
 		if err != nil {
 			return nil, err
 		}
 	}
-	options.Type = ContentType(gstr.TrimLeft(
-		string(options.Type), "."),
-	)
-	switch options.Type {
+	switch checkType {
 	case ContentTypeJSON, ContentTypeJs:
+		decoder := json.NewDecoder(bytes.NewReader(data))
+		if options.StrNumber {
+			decoder.UseNumber()
+		}
+		if err = decoder.Decode(&result); err != nil {
+			return nil, err
+		}
+		switch result.(type) {
+		case string, []byte:
+			return nil, gerror.Newf(`json decoding failed for content: %s`, data)
+		}
+		return NewWithOptions(result, options), nil
 
 	case ContentTypeXML:
-		data, err = gxml.ToJson(data)
+		decodedData, err = gxml.Decode(data)
+		if err != nil {
+			return nil, err
+		}
+		return NewWithOptions(decodedData, options), nil
 
 	case ContentTypeYaml, ContentTypeYml:
-		data, err = gyaml.ToJson(data)
+		decodedData, err = gyaml.Decode(data)
+		if err != nil {
+			return nil, err
+		}
+		return NewWithOptions(decodedData, options), nil
 
 	case ContentTypeToml:
-		data, err = gtoml.ToJson(data)
+		decodedData, err = gtoml.Decode(data)
+		if err != nil {
+			return nil, err
+		}
+		return NewWithOptions(decodedData, options), nil
 
 	case ContentTypeIni:
-		data, err = gini.ToJson(data)
+		decodedData, err = gini.Decode(data)
+		if err != nil {
+			return nil, err
+		}
+		return NewWithOptions(decodedData, options), nil
 
 	case ContentTypeProperties:
-		data, err = gproperties.ToJson(data)
+		decodedData, err = gproperties.Decode(data)
+		if err != nil {
+			return nil, err
+		}
+		return NewWithOptions(decodedData, options), nil
 
 	default:
-		err = gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			`unsupported type "%s" for loading`,
-			options.Type,
-		)
-	}
-	if err != nil {
-		return nil, err
-	}
 
-	decoder := json.NewDecoder(bytes.NewReader(data))
-	if options.StrNumber {
-		decoder.UseNumber()
 	}
-	if err = decoder.Decode(&result); err != nil {
-		return nil, err
+	// ignore some duplicated types, like js and yml,
+	// which are not necessary shown in error message.
+	allSupportedTypes := []string{
+		ContentTypeJSON,
+		ContentTypeXML,
+		ContentTypeYaml,
+		ContentTypeToml,
+		ContentTypeIni,
+		ContentTypeProperties,
 	}
-	switch result.(type) {
-	case string, []byte:
-		return nil, gerror.Newf(`json decoding failed for content: %s`, data)
-	}
-	return NewWithOptions(result, options), nil
+	return nil, gerror.NewCodef(
+		gcode.CodeInvalidParameter,
+		`unsupported type "%s" for loading, all supported types: %s`,
+		options.Type, gstr.Join(allSupportedTypes, ", "),
+	)
 }
 
 // checkDataType automatically checks and returns the data type for `content`.
@@ -247,33 +277,104 @@ func checkDataType(data []byte) (ContentType, error) {
 	}
 }
 
+// isXMLContent checks whether given content is XML format.
+// XML format is easy to be identified using regular expression.
 func isXMLContent(data []byte) bool {
 	return gregex.IsMatch(`^\s*<.+>[\S\s]+<.+>\s*$`, data)
 }
 
+// isYamlContent checks whether given content is YAML format.
 func isYamlContent(data []byte) bool {
-	return !gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*"""[\s\S]+"""`, data) &&
-		!gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*'''[\s\S]+'''`, data) &&
-		((gregex.IsMatch(`^[\n\r]*[\w\-\s\t]+\s*:\s*".+"`, data) ||
-			gregex.IsMatch(`^[\n\r]*[\w\-\s\t]+\s*:\s*\w+`, data)) ||
-			(gregex.IsMatch(`[\n\r]+[\w\-\s\t]+\s*:\s*".+"`, data) ||
-				gregex.IsMatch(`[\n\r]+[\w\-\s\t]+\s*:\s*\w+`, data)))
+	// x = y
+	// "x.x" = "y"
+	tomlFormat1 := gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*"""[\s\S]+"""`, data)
+	if tomlFormat1 {
+		return false
+	}
+	// "x.x" = '''
+	// y
+	// '''
+	tomlFormat2 := gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*'''[\s\S]+'''`, data)
+	if tomlFormat2 {
+		return false
+	}
+
+	// content starts with:
+	// x : "y"
+	yamlFormat1 := gregex.IsMatch(`^[\n\r]*[\w\-\s\t]+\s*:\s+".+"`, data)
+
+	// content starts with:
+	// x : y
+	yamlFormat2 := gregex.IsMatch(`^[\n\r]*[\w\-\s\t]+\s*:\s+\w+`, data)
+
+	// line starts with:
+	// x : "y"
+	yamlFormat3 := gregex.IsMatch(`[\n\r]+[\w\-\s\t]+\s*:\s+".+"`, data)
+
+	// line starts with:
+	// x : y
+	yamlFormat4 := gregex.IsMatch(`[\n\r]+[\w\-\s\t]+\s*:\s+\w+`, data)
+
+	// content starts with:
+	// "x" : "y"
+	yamlFormat5 := gregex.IsMatch(`^[\n\r]*".+":\s+".+"`, data)
+
+	// line starts with:
+	// "x" : y
+	yamlFormat6 := gregex.IsMatch(`[\n\r]+".+":\s+\w+`, data)
+
+	return yamlFormat1 || yamlFormat2 || yamlFormat3 || yamlFormat4 || yamlFormat5 || yamlFormat6
 }
 
+// isTomlContent checks whether given content is TOML format.
 func isTomlContent(data []byte) bool {
-	return !gregex.IsMatch(`^[\s\t\n\r]*;.+`, data) &&
-		!gregex.IsMatch(`[\s\t\n\r]+;.+`, data) &&
-		!gregex.IsMatch(`[\n\r]+[\s\t\w\-]+\.[\s\t\w\-]+\s*=\s*.+`, data) &&
-		(gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*".+"`, data) ||
-			gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*\w+`, data))
+	// content starts with:
+	// ; comment line
+	contentStartsWithSemicolonComment := gregex.IsMatch(`^[\s\t\n\r]*;.+`, data)
+	if contentStartsWithSemicolonComment {
+		return false
+	}
+	// line starts with:
+	// ; comment line
+	lineStartsWithSemicolonComment := gregex.IsMatch(`[\s\t\n\r]+;.+`, data)
+	if lineStartsWithSemicolonComment {
+		return false
+	}
+
+	// line starts with, this should not be toml format:
+	// key.with.dot = value
+	keyWithDot := gregex.IsMatch(`[\n\r]+[\s\t\w\-]+\.[\s\t\w\-]+\s*=\s*.+`, data)
+	if keyWithDot {
+		return false
+	}
+
+	// line starts with:
+	// key = value
+	// key = "value"
+	// "key" = "value"
+	// "key" = value
+	tomlFormat1 := gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*".+"`, data)
+	tomlFormat2 := gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*\w+`, data)
+	return tomlFormat1 || tomlFormat2
 }
 
+// isIniContent checks whether given content is INI format.
 func isIniContent(data []byte) bool {
-	return gregex.IsMatch(`\[[\w\.]+\]`, data) &&
-		(gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*".+"`, data) ||
-			gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*\w+`, data))
+	// no section like: [section], but ini format must have sections.
+	hasBrackets := gregex.IsMatch(`\[[\w\.]+\]`, data)
+	if !hasBrackets {
+		return false
+	}
+	iniFormat1 := gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*".+"`, data)
+	iniFormat2 := gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*\w+`, data)
+	return iniFormat1 || iniFormat2
 }
 
+// isPropertyContent checks whether given content is Properties format.
 func isPropertyContent(data []byte) bool {
-	return gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*\w+`, data)
+	// line starts with:
+	// key = value
+	// "key" = value
+	propertyFormat := gregex.IsMatch(`[\n\r]*[\s\t\w\-\."]+\s*=\s*\w+`, data)
+	return propertyFormat
 }
diff --git a/encoding/gjson/gjson_api_new_load_path.go b/encoding/gjson/gjson_api_new_load_path.go
index 7cdab5d86..ccb7a49ea 100644
--- a/encoding/gjson/gjson_api_new_load_path.go
+++ b/encoding/gjson/gjson_api_new_load_path.go
@@ -9,6 +9,7 @@ package gjson
 import "github.com/gogf/gf/v2/os/gfile"
 
 // Load loads content from specified file `path`, and creates a Json object from its content.
+//
 // Deprecated: use LoadPath instead.
 func Load(path string, safe ...bool) (*Json, error) {
 	var isSafe bool
@@ -28,7 +29,7 @@ func LoadPath(path string, options Options) (*Json, error) {
 		path = p
 	}
 	if options.Type == "" {
-		options.Type = ContentType(gfile.Ext(path))
+		options.Type = gfile.Ext(path)
 	}
-	return loadContentWithOptions(gfile.GetBytesWithCache(path), options)
+	return loadContentWithOptions(gfile.GetBytes(path), options)
 }
diff --git a/encoding/gjson/gjson_z_unit_feature_load_test.go b/encoding/gjson/gjson_z_unit_feature_load_test.go
index 4a1f5e098..116b3d8da 100644
--- a/encoding/gjson/gjson_z_unit_feature_load_test.go
+++ b/encoding/gjson/gjson_z_unit_feature_load_test.go
@@ -418,3 +418,13 @@ DBINFO.password=password
 		t.AssertNE(err, nil)
 	})
 }
+
+func Test_Load_YAML_For_I18n(t *testing.T) {
+	var data = []byte(gtest.DataContent("yaml", "i18n-issue.yaml"))
+	gtest.C(t, func(t *gtest.T) {
+		j, err := gjson.LoadContent(data)
+		t.AssertNil(err)
+		j.SetViolenceCheck(true)
+		t.Assert(j.Get("resourceUsage.workflow").String(), "workflow")
+	})
+}
diff --git a/encoding/gjson/testdata/yaml/i18n-issue.yaml b/encoding/gjson/testdata/yaml/i18n-issue.yaml
new file mode 100644
index 000000000..8a2ecd704
--- /dev/null
+++ b/encoding/gjson/testdata/yaml/i18n-issue.yaml
@@ -0,0 +1,16 @@
+"environment status is Creating/Updating, please wait for sync to complete": "环境当前状为创建中/更新中，请等待同步完成"
+"There are still queues in the current environment, please ensure there are no queues before deletion": "当前环境还存在队列，确保环境没有队列再删除"
+"the current repository has associated environments in use, please ensure no environment associations before deleting the repository": "当前仓库有关联环境正在使用，请确保没有环境关联再删除该仓库"
+"There are environments using this cluster, please ensure all environments have been deleted before deleting the cluster": "当前集群存在环境正在使用，请确保所有环境已经删除再删除该集群"
+
+"shareStrategy.Init": "未拆卡"
+"shareStrategy.Pending": "切分中"
+"shareStrategy.Success": "拆卡成功"
+"shareStrategy.Canceling": "拆卡取消中"
+"shareStrategy.unknown": "未知状态"
+"resourceUsage.none": "无"
+"resourceUsage.inference": "推理"
+"resourceUsage.training": "训练"
+"resourceUsage.workflow": "workflow"
+"resourceUsage.hybrid": "混合"
+"resourceUsage.unknown": "unknown"
\ No newline at end of file
diff --git a/encoding/gyaml/gyaml.go b/encoding/gyaml/gyaml.go
index 720ca569c..b5316714f 100644
--- a/encoding/gyaml/gyaml.go
+++ b/encoding/gyaml/gyaml.go
@@ -57,7 +57,12 @@ func Decode(content []byte) (map[string]any, error) {
 		err = gerror.Wrap(err, `yaml.Unmarshal failed`)
 		return nil, err
 	}
-	return gconv.MapDeep(result), nil
+	return gconv.Map(result,
+		gconv.MapOption{
+			Deep:            true,
+			OmitEmpty:       false,
+			ContinueOnError: true,
+		}), nil
 }
 
 // DecodeTo parses `content` into `result`.
diff --git a/errors/gcode/gcode_z_unit_test.go b/errors/gcode/gcode_z_unit_test.go
index 7bbd5b254..ee898bd6e 100644
--- a/errors/gcode/gcode_z_unit_test.go
+++ b/errors/gcode/gcode_z_unit_test.go
@@ -7,6 +7,7 @@
 package gcode_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/gogf/gf/v2/errors/gcode"
@@ -36,3 +37,21 @@ func Test_WithCode(t *testing.T) {
 		t.Assert(c.Detail(), "CodeInternalError")
 	})
 }
+
+func Test_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test with detail
+		c := gcode.New(100, "test message", "test detail")
+		t.Assert(c.(fmt.Stringer).String(), "100:test message test detail")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		// Test with message but no detail
+		c := gcode.New(100, "test message", nil)
+		t.Assert(c.(fmt.Stringer).String(), "100:test message")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		// Test with no message and no detail
+		c := gcode.New(100, "", nil)
+		t.Assert(c.(fmt.Stringer).String(), "100")
+	})
+}
diff --git a/errors/gerror/gerror.go b/errors/gerror/gerror.go
index e252d872a..514efe4e2 100644
--- a/errors/gerror/gerror.go
+++ b/errors/gerror/gerror.go
@@ -17,40 +17,48 @@ import (
 
 // IEqual is the interface for Equal feature.
 type IEqual interface {
-	Error() string
+	error
 	Equal(target error) bool
 }
 
 // ICode is the interface for Code feature.
 type ICode interface {
-	Error() string
+	error
 	Code() gcode.Code
 }
 
 // IStack is the interface for Stack feature.
 type IStack interface {
-	Error() string
+	error
 	Stack() string
 }
 
 // ICause is the interface for Cause feature.
 type ICause interface {
-	Error() string
+	error
 	Cause() error
 }
 
 // ICurrent is the interface for Current feature.
 type ICurrent interface {
-	Error() string
+	error
 	Current() error
 }
 
 // IUnwrap is the interface for Unwrap feature.
 type IUnwrap interface {
-	Error() string
+	error
 	Unwrap() error
 }
 
+// ITextArgs is the interface for Text and Args features.
+// This interface is mainly used for i18n features, that needs text and args separately.
+type ITextArgs interface {
+	error
+	Text() string
+	Args() []any
+}
+
 const (
 	// commaSeparatorSpace is the comma separator with space.
 	commaSeparatorSpace = ", "
diff --git a/errors/gerror/gerror_api.go b/errors/gerror/gerror_api.go
index 3b2b3915f..e2c6a836e 100644
--- a/errors/gerror/gerror_api.go
+++ b/errors/gerror/gerror_api.go
@@ -7,8 +7,6 @@
 package gerror
 
 import (
-	"fmt"
-
 	"github.com/gogf/gf/v2/errors/gcode"
 )
 
@@ -25,7 +23,8 @@ func New(text string) error {
 func Newf(format string, args ...any) error {
 	return &Error{
 		stack: callers(),
-		text:  fmt.Sprintf(format, args...),
+		text:  format,
+		args:  args,
 		code:  gcode.CodeNil,
 	}
 }
@@ -45,7 +44,8 @@ func NewSkip(skip int, text string) error {
 func NewSkipf(skip int, format string, args ...any) error {
 	return &Error{
 		stack: callers(skip),
-		text:  fmt.Sprintf(format, args...),
+		text:  format,
+		args:  args,
 		code:  gcode.CodeNil,
 	}
 }
@@ -74,7 +74,8 @@ func Wrapf(err error, format string, args ...any) error {
 	return &Error{
 		error: err,
 		stack: callers(),
-		text:  fmt.Sprintf(format, args...),
+		text:  format,
+		args:  args,
 		code:  Code(err),
 	}
 }
@@ -104,7 +105,8 @@ func WrapSkipf(skip int, err error, format string, args ...any) error {
 	return &Error{
 		error: err,
 		stack: callers(skip),
-		text:  fmt.Sprintf(format, args...),
+		text:  format,
+		args:  args,
 		code:  Code(err),
 	}
 }
diff --git a/errors/gerror/gerror_api_code.go b/errors/gerror/gerror_api_code.go
index c13305ca8..465baa8ea 100644
--- a/errors/gerror/gerror_api_code.go
+++ b/errors/gerror/gerror_api_code.go
@@ -7,7 +7,6 @@
 package gerror
 
 import (
-	"fmt"
 	"strings"
 
 	"github.com/gogf/gf/v2/errors/gcode"
@@ -26,7 +25,8 @@ func NewCode(code gcode.Code, text ...string) error {
 func NewCodef(code gcode.Code, format string, args ...any) error {
 	return &Error{
 		stack: callers(),
-		text:  fmt.Sprintf(format, args...),
+		text:  format,
+		args:  args,
 		code:  code,
 	}
 }
@@ -46,7 +46,8 @@ func NewCodeSkip(code gcode.Code, skip int, text ...string) error {
 func NewCodeSkipf(code gcode.Code, skip int, format string, args ...any) error {
 	return &Error{
 		stack: callers(skip),
-		text:  fmt.Sprintf(format, args...),
+		text:  format,
+		args:  args,
 		code:  code,
 	}
 }
@@ -74,7 +75,8 @@ func WrapCodef(code gcode.Code, err error, format string, args ...any) error {
 	return &Error{
 		error: err,
 		stack: callers(),
-		text:  fmt.Sprintf(format, args...),
+		text:  format,
+		args:  args,
 		code:  code,
 	}
 }
@@ -104,7 +106,8 @@ func WrapCodeSkipf(code gcode.Code, skip int, err error, format string, args ...
 	return &Error{
 		error: err,
 		stack: callers(skip),
-		text:  fmt.Sprintf(format, args...),
+		text:  format,
+		args:  args,
 		code:  code,
 	}
 }
diff --git a/errors/gerror/gerror_api_option.go b/errors/gerror/gerror_api_option.go
index 4ac7f1d93..40b7de308 100644
--- a/errors/gerror/gerror_api_option.go
+++ b/errors/gerror/gerror_api_option.go
@@ -13,6 +13,7 @@ type Option struct {
 	Error error      // Wrapped error if any.
 	Stack bool       // Whether recording stack information into error.
 	Text  string     // Error text, which is created by New* functions.
+	Args  []any      // Error arguments for formatted error text.
 	Code  gcode.Code // Error code if necessary.
 }
 
@@ -22,6 +23,7 @@ func NewWithOption(option Option) error {
 	err := &Error{
 		error: option.Error,
 		text:  option.Text,
+		args:  option.Args,
 		code:  option.Code,
 	}
 	if option.Stack {
@@ -31,6 +33,7 @@ func NewWithOption(option Option) error {
 }
 
 // NewOption creates and returns a custom error with Option.
+//
 // Deprecated: use NewWithOption instead.
 func NewOption(option Option) error {
 	return NewWithOption(option)
diff --git a/errors/gerror/gerror_api_stack.go b/errors/gerror/gerror_api_stack.go
index 5caa51172..36b7c37be 100644
--- a/errors/gerror/gerror_api_stack.go
+++ b/errors/gerror/gerror_api_stack.go
@@ -117,6 +117,7 @@ func As(err error, target any) bool {
 
 // HasError performs as Is.
 // This function is designed and implemented early before errors.Is of go stdlib.
+//
 // Deprecated: use Is instead.
 func HasError(err, target error) bool {
 	return errors.Is(err, target)
diff --git a/errors/gerror/gerror_error.go b/errors/gerror/gerror_error.go
index 18a181184..79a226f59 100644
--- a/errors/gerror/gerror_error.go
+++ b/errors/gerror/gerror_error.go
@@ -20,6 +20,7 @@ type Error struct {
 	error error      // Wrapped error.
 	stack stack      // Stack array, which records the stack information when this error is created or wrapped.
 	text  string     // Custom Error text when Error is created, might be empty when its code is not nil.
+	args  []any      // Custom arguments for formatting the error text.
 	code  gcode.Code // Error code if necessary.
 }
 
@@ -42,7 +43,7 @@ func (err *Error) Error() string {
 	if err == nil {
 		return ""
 	}
-	errStr := err.text
+	errStr := err.TextWithArgs()
 	if errStr == "" && err.code != nil {
 		errStr = err.code.Message()
 	}
@@ -76,7 +77,7 @@ func (err *Error) Cause() error {
 			// return loop
 			//
 			// To be compatible with Case of https://github.com/pkg/errors.
-			return errors.New(loop.text)
+			return errors.New(loop.TextWithArgs())
 		}
 	}
 	return nil
@@ -92,6 +93,7 @@ func (err *Error) Current() error {
 		error: nil,
 		stack: err.stack,
 		text:  err.text,
+		args:  err.args,
 		code:  err.code,
 	}
 }
@@ -118,8 +120,26 @@ func (err *Error) Equal(target error) bool {
 		return false
 	}
 	// Text should be the same.
-	if err.text != fmt.Sprintf(`%-s`, target) {
+	if err.TextWithArgs() != fmt.Sprintf(`%-s`, target) {
 		return false
 	}
 	return true
 }
+
+// TextWithArgs returns the formatted error text with its arguments.
+func (err *Error) TextWithArgs() string {
+	if len(err.args) > 0 {
+		return fmt.Sprintf(err.text, err.args...)
+	}
+	return err.text
+}
+
+// Text returns the error text of current error.
+func (err *Error) Text() string {
+	return err.text
+}
+
+// Args returns the error arguments of current error.
+func (err *Error) Args() []any {
+	return err.args
+}
diff --git a/errors/gerror/gerror_error_format.go b/errors/gerror/gerror_error_format.go
index 16be393e6..42f3b4296 100644
--- a/errors/gerror/gerror_error_format.go
+++ b/errors/gerror/gerror_error_format.go
@@ -23,7 +23,7 @@ func (err *Error) Format(s fmt.State, verb rune) {
 		switch {
 		case s.Flag('-'):
 			if err.text != "" {
-				_, _ = io.WriteString(s, err.text)
+				_, _ = io.WriteString(s, err.TextWithArgs())
 			} else {
 				_, _ = io.WriteString(s, err.Error())
 			}
diff --git a/errors/gerror/gerror_error_json.go b/errors/gerror/gerror_error_json.go
index 5c290d7af..bf9465fbe 100644
--- a/errors/gerror/gerror_error_json.go
+++ b/errors/gerror/gerror_error_json.go
@@ -6,8 +6,12 @@
 
 package gerror
 
-// MarshalJSON implements the interface MarshalJSON for json.Marshal.
-// Note that do not use pointer as its receiver here.
-func (err Error) MarshalJSON() ([]byte, error) {
-	return []byte(`"` + err.Error() + `"`), nil
+import (
+	"encoding/json"
+)
+
+// MarshalJSON implements the interface json.Marshaler for Error.
+// It serializes the error using its string representation.
+func (err *Error) MarshalJSON() ([]byte, error) {
+	return json.Marshal(err.Error())
 }
diff --git a/errors/gerror/gerror_z_unit_test.go b/errors/gerror/gerror_z_unit_test.go
index 83acc1837..e7ff53698 100644
--- a/errors/gerror/gerror_z_unit_test.go
+++ b/errors/gerror/gerror_z_unit_test.go
@@ -33,6 +33,64 @@ func (e *anotherError) Error() string {
 	return "another error"
 }
 
+// customCauseError implements ICause interface
+type customCauseError struct {
+	msg   string
+	cause error
+}
+
+func (e *customCauseError) Error() string { return e.msg }
+func (e *customCauseError) Cause() error  { return e.cause }
+
+// customStackError implements IStack interface
+type customStackError struct {
+	msg   string
+	stack string
+}
+
+func (e *customStackError) Error() string { return e.msg }
+func (e *customStackError) Stack() string { return e.stack }
+
+// customCurrentError implements ICurrent interface
+type customCurrentError struct {
+	msg     string
+	current error
+}
+
+func (e *customCurrentError) Error() string  { return e.msg }
+func (e *customCurrentError) Current() error { return e.current }
+
+// customUnwrapError implements IUnwrap interface
+type customUnwrapError struct {
+	msg    string
+	unwrap error
+}
+
+func (e *customUnwrapError) Error() string { return e.msg }
+func (e *customUnwrapError) Unwrap() error { return e.unwrap }
+
+// customEqualError implements IEqual interface
+type customEqualError struct {
+	msg string
+}
+
+func (e *customEqualError) Error() string { return e.msg }
+func (e *customEqualError) Equal(target error) bool {
+	if target == nil {
+		return false
+	}
+	return e.msg == target.Error()
+}
+
+// customCodeError implements ICode interface
+type customCodeError struct {
+	msg  string
+	code gcode.Code
+}
+
+func (e *customCodeError) Error() string    { return e.msg }
+func (e *customCodeError) Code() gcode.Code { return e.code }
+
 func nilError() error {
 	return nil
 }
@@ -395,6 +453,19 @@ func Test_Json(t *testing.T) {
 		t.Assert(e, nil)
 		t.Assert(string(b), `"2: 1"`)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		errNormal := gerror.New("test")
+		b, e := json.Marshal(errNormal)
+		t.Assert(e, nil)
+		t.Assert(string(b), `"test"`)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		// The string contains special characters.
+		errWithSign := gerror.New(`test ""`)
+		b, e := json.Marshal(errWithSign)
+		t.Assert(e, nil)
+		t.Assert(string(b), `"test \"\""`)
+	})
 }
 
 func Test_HasStack(t *testing.T) {
@@ -541,3 +612,218 @@ func Test_As(t *testing.T) {
 		gerror.As(errors.New("error"), nil)
 	})
 }
+
+func Test_NewOption_Deprecated(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test deprecated NewOption function
+		err := gerror.NewOption(gerror.Option{
+			Error: errors.New("base error"),
+			Stack: true,
+			Text:  "option text",
+			Code:  gcode.CodeInternalError,
+		})
+		t.AssertNE(err, nil)
+		t.Assert(gerror.Code(err), gcode.CodeInternalError)
+	})
+}
+
+func Test_Code_WithIUnwrap(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test Code() with custom error that implements IUnwrap but not ICode
+		innerErr := gerror.NewCode(gcode.CodeInternalError, "inner error")
+		unwrapErr := &customUnwrapError{msg: "unwrap error", unwrap: innerErr}
+		t.Assert(gerror.Code(unwrapErr), gcode.CodeInternalError)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		// Test Code() with nil
+		t.Assert(gerror.Code(nil), gcode.CodeNil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		// Test Code() with custom error that implements ICode
+		codeErr := &customCodeError{msg: "code error", code: gcode.CodeNotFound}
+		t.Assert(gerror.Code(codeErr), gcode.CodeNotFound)
+	})
+}
+
+func Test_Cause_WithIUnwrap(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test Cause() with custom error that implements IUnwrap but not ICause
+		rootErr := errors.New("root error")
+		unwrapErr := &customUnwrapError{msg: "unwrap error", unwrap: rootErr}
+		t.Assert(gerror.Cause(unwrapErr), rootErr)
+	})
+}
+
+func Test_Cause_WithICause(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test Cause() with custom error that implements ICause
+		rootErr := errors.New("root error")
+		causeErr := &customCauseError{msg: "cause error", cause: rootErr}
+		t.Assert(gerror.Cause(causeErr), rootErr)
+	})
+}
+
+func Test_Stack_WithIStack(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test Stack() with custom error that implements IStack
+		stackErr := &customStackError{msg: "stack error", stack: "custom stack trace"}
+		t.Assert(gerror.Stack(stackErr), "custom stack trace")
+	})
+}
+
+func Test_Current_WithICurrent(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test Current() with custom error that implements ICurrent
+		currentErr := errors.New("current error")
+		customErr := &customCurrentError{msg: "custom error", current: currentErr}
+		t.Assert(gerror.Current(customErr), currentErr)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		// Test Current() with standard error (does not implement ICurrent)
+		stdErr := errors.New("standard error")
+		t.Assert(gerror.Current(stdErr), stdErr)
+	})
+}
+
+func Test_Equal_WithIEqual(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test Equal() when target implements IEqual
+		err1 := errors.New("test error")
+		err2 := &customEqualError{msg: "test error"}
+		t.Assert(gerror.Equal(err1, err2), true)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		// Test Equal() when both are the same
+		err := errors.New("test error")
+		t.Assert(gerror.Equal(err, err), true)
+	})
+}
+
+func Test_Error_Cause_WithICause(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test Error.Cause() when inner error implements ICause
+		rootErr := errors.New("root")
+		causeErr := &customCauseError{msg: "cause", cause: rootErr}
+		wrappedErr := gerror.Wrap(causeErr, "wrapped")
+		t.Assert(gerror.Cause(wrappedErr), rootErr)
+	})
+}
+
+func Test_Error_WithCodeMessage(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test Error.Error() when text is empty but code has message
+		err := gerror.NewCode(gcode.CodeInternalError)
+		t.Assert(err.Error(), "Internal Error")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		// Test Error.Error() when text is empty and code has message, with wrapped error
+		innerErr := errors.New("inner")
+		err := gerror.WrapCode(gcode.CodeInternalError, innerErr)
+		t.Assert(err.Error(), "Internal Error: inner")
+	})
+}
+
+func Test_Format_PlusS(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test %+s format (stack only)
+		err := gerror.New("test error")
+		stackStr := fmt.Sprintf("%+s", err)
+		t.Assert(len(stackStr) > 0, true)
+		t.AssertNE(stackStr, "test error")
+	})
+}
+
+func Test_Format_MinusS_EmptyText(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test %-s format when text is empty but code has message
+		err := gerror.NewCode(gcode.CodeInternalError)
+		result := fmt.Sprintf("%-s", err)
+		t.Assert(result, "Internal Error")
+	})
+}
+
+func Test_Stack_DeepNested(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test deeply nested errors stack
+		err := gerror.New("level1")
+		for i := 2; i <= 5; i++ {
+			err = gerror.Wrap(err, fmt.Sprintf("level%d", i))
+		}
+		stack := gerror.Stack(err)
+		t.Assert(len(stack) > 0, true)
+	})
+}
+
+func Test_Stack_NilError(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var err *gerror.Error = nil
+		t.Assert(err.Stack(), "")
+	})
+}
+
+func Test_Stack_WithStandardError(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test stack with wrapped standard error
+		stdErr := errors.New("standard error")
+		err := gerror.Wrap(stdErr, "wrapped")
+		stack := gerror.Stack(err)
+		t.Assert(len(stack) > 0, true)
+	})
+}
+
+func Test_NewCode_MultipleTexts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test NewCode with multiple text arguments
+		err := gerror.NewCode(gcode.CodeInternalError, "text1", "text2", "text3")
+		t.Assert(err.Error(), "text1, text2, text3")
+	})
+}
+
+func Test_NewCodeSkip_MultipleTexts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test NewCodeSkip with multiple text arguments
+		err := gerror.NewCodeSkip(gcode.CodeInternalError, 0, "text1", "text2")
+		t.Assert(err.Error(), "text1, text2")
+	})
+}
+
+func Test_WrapCode_MultipleTexts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test WrapCode with multiple text arguments
+		innerErr := errors.New("inner")
+		err := gerror.WrapCode(gcode.CodeInternalError, innerErr, "text1", "text2")
+		t.Assert(err.Error(), "text1, text2: inner")
+	})
+}
+
+func Test_WrapCodeSkip_MultipleTexts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test WrapCodeSkip with multiple text arguments
+		innerErr := errors.New("inner")
+		err := gerror.WrapCodeSkip(gcode.CodeInternalError, 0, innerErr, "text1", "text2")
+		t.Assert(err.Error(), "text1, text2: inner")
+	})
+}
+
+func Test_TextArgs(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		err := gerror.New("text")
+		textArgs := err.(gerror.ITextArgs)
+		t.Assert(textArgs.Text(), "text")
+		t.Assert(textArgs.Args(), nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		err := gerror.Newf("text: %s", "arg1")
+		textArgs := err.(gerror.ITextArgs)
+		t.Assert(textArgs.Text(), "text: %s")
+		t.Assert(textArgs.Args(), []any{"arg1"})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		err1 := errors.New("text")
+		err2 := gerror.Wrapf(err1, "wrap: %s", "arg1")
+		textArgs := err2.(gerror.ITextArgs)
+		t.Assert(textArgs.Error(), "wrap: arg1: text")
+		t.Assert(textArgs.Text(), "wrap: %s")
+		t.Assert(textArgs.Args(), []any{"arg1"})
+	})
+}
diff --git a/examples b/examples
deleted file mode 160000
index f15e0c197..000000000
--- a/examples
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit f15e0c1978935dbe44ae6a7b8fe91de53abf1beb
diff --git a/frame/gins/gins_database.go b/frame/gins/gins_database.go
index dd04fda10..0d420de49 100644
--- a/frame/gins/gins_database.go
+++ b/frame/gins/gins_database.go
@@ -89,7 +89,7 @@ func Database(name ...string) gdb.DB {
 				}
 			}
 			if len(cg) > 0 {
-				if gdb.GetConfig(group) == nil {
+				if gcg, _ := gdb.GetConfigGroup(group); gcg == nil {
 					intlog.Printf(ctx, "add configuration for group: %s, %#v", g, cg)
 					if err := gdb.SetConfigGroup(g, cg); err != nil {
 						panic(err)
@@ -108,7 +108,7 @@ func Database(name ...string) gdb.DB {
 				cg = append(cg, *node)
 			}
 			if len(cg) > 0 {
-				if gdb.GetConfig(group) == nil {
+				if gcg, _ := gdb.GetConfigGroup(group); gcg == nil {
 					intlog.Printf(ctx, "add configuration for group: %s, %#v", gdb.DefaultGroupName, cg)
 					if err := gdb.SetConfigGroup(gdb.DefaultGroupName, cg); err != nil {
 						panic(err)
diff --git a/go.mod b/go.mod
index de9b455f0..a8b9e8120 100644
--- a/go.mod
+++ b/go.mod
@@ -5,18 +5,18 @@ go 1.23.0
 require (
 	github.com/BurntSushi/toml v1.5.0
 	github.com/clbanning/mxj/v2 v2.7.0
-	github.com/emirpasic/gods v1.18.1
+	github.com/emirpasic/gods/v2 v2.0.0-alpha
 	github.com/fatih/color v1.18.0
 	github.com/fsnotify/fsnotify v1.9.0
 	github.com/gorilla/websocket v1.5.3
 	github.com/grokify/html-strip-tags-go v0.1.0
 	github.com/magiconair/properties v1.8.10
-	github.com/olekukonko/tablewriter v1.0.9
-	go.opentelemetry.io/otel v1.37.0
-	go.opentelemetry.io/otel/sdk v1.37.0
-	go.opentelemetry.io/otel/trace v1.37.0
-	golang.org/x/net v0.43.0
-	golang.org/x/text v0.28.0
+	github.com/olekukonko/tablewriter v1.1.0
+	go.opentelemetry.io/otel v1.38.0
+	go.opentelemetry.io/otel/sdk v1.38.0
+	go.opentelemetry.io/otel/trace v1.38.0
+	golang.org/x/net v0.40.0
+	golang.org/x/text v0.25.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -24,14 +24,13 @@ require (
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
-	github.com/rogpeppe/go-internal v1.14.1 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
 )
diff --git a/go.sum b/go.sum
index e58d3957d..0718fa9fe 100644
--- a/go.sum
+++ b/go.sum
@@ -4,8 +4,8 @@ github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyM
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
+github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -29,8 +29,9 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -39,36 +40,38 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/i18n/gi18n/gi18n_instance.go b/i18n/gi18n/gi18n_instance.go
index 8a41c34ad..465888c91 100644
--- a/i18n/gi18n/gi18n_instance.go
+++ b/i18n/gi18n/gi18n_instance.go
@@ -14,9 +14,11 @@ const (
 )
 
 var (
+	// checker is used for checking whether the value is nil.
+	checker = func(v *Manager) bool { return v == nil }
 	// instances is the instances map for management
 	// for multiple i18n instance by name.
-	instances = gmap.NewStrAnyMap(true)
+	instances = gmap.NewKVMapWithChecker[string, *Manager](checker, true)
 )
 
 // Instance returns an instance of Resource.
@@ -26,7 +28,7 @@ func Instance(name ...string) *Manager {
 	if len(name) > 0 && name[0] != "" {
 		key = name[0]
 	}
-	return instances.GetOrSetFuncLock(key, func() any {
+	return instances.GetOrSetFuncLock(key, func() *Manager {
 		return New()
-	}).(*Manager)
+	})
 }
diff --git a/i18n/gi18n/gi18n_manager.go b/i18n/gi18n/gi18n_manager.go
index 6c126d09c..6b9fa4f60 100644
--- a/i18n/gi18n/gi18n_manager.go
+++ b/i18n/gi18n/gi18n_manager.go
@@ -298,7 +298,7 @@ func (m *Manager) init(ctx context.Context) {
 			if m.data[lang] == nil {
 				m.data[lang] = make(map[string]string)
 			}
-			if j, err := gjson.LoadContent(gfile.GetBytes(file)); err == nil {
+			if j, err := gjson.LoadPath(file, gjson.Options{}); err == nil {
 				for k, v := range j.Var().Map() {
 					m.data[lang][k] = gconv.String(v)
 				}
diff --git a/i18n/gi18n/gi18n_z_unit_test.go b/i18n/gi18n/gi18n_z_unit_test.go
index 2a1d672a4..ef03a622b 100644
--- a/i18n/gi18n/gi18n_z_unit_test.go
+++ b/i18n/gi18n/gi18n_z_unit_test.go
@@ -259,3 +259,25 @@ func Test_PathInNormal(t *testing.T) {
 		t.Assert(i18n.T(context.Background(), "{#lang}"), "en-US")
 	})
 }
+
+func Test_Issue_Yaml(t *testing.T) {
+	// Copy i18n files to current directory.
+	err := gfile.CopyDir(
+		gtest.DataPath("issue-yaml"),
+		gfile.Join(gdebug.CallerDirectory(), "manifest/i18n"),
+	)
+	// Remove copied files after testing.
+	defer gfile.RemoveAll(gfile.Join(gdebug.CallerDirectory(), "manifest"))
+
+	gtest.AssertNil(err)
+
+	var (
+		i18n = gi18n.New()
+		ctx  = context.Background()
+	)
+
+	gtest.C(t, func(t *gtest.T) {
+		i18n.SetLanguage("zh")
+		t.Assert(i18n.T(ctx, "{#resourceUsage.workflow}"), "workflow")
+	})
+}
diff --git a/i18n/gi18n/testdata/issue-yaml/zh.yaml b/i18n/gi18n/testdata/issue-yaml/zh.yaml
new file mode 100644
index 000000000..8a2ecd704
--- /dev/null
+++ b/i18n/gi18n/testdata/issue-yaml/zh.yaml
@@ -0,0 +1,16 @@
+"environment status is Creating/Updating, please wait for sync to complete": "环境当前状为创建中/更新中，请等待同步完成"
+"There are still queues in the current environment, please ensure there are no queues before deletion": "当前环境还存在队列，确保环境没有队列再删除"
+"the current repository has associated environments in use, please ensure no environment associations before deleting the repository": "当前仓库有关联环境正在使用，请确保没有环境关联再删除该仓库"
+"There are environments using this cluster, please ensure all environments have been deleted before deleting the cluster": "当前集群存在环境正在使用，请确保所有环境已经删除再删除该集群"
+
+"shareStrategy.Init": "未拆卡"
+"shareStrategy.Pending": "切分中"
+"shareStrategy.Success": "拆卡成功"
+"shareStrategy.Canceling": "拆卡取消中"
+"shareStrategy.unknown": "未知状态"
+"resourceUsage.none": "无"
+"resourceUsage.inference": "推理"
+"resourceUsage.training": "训练"
+"resourceUsage.workflow": "workflow"
+"resourceUsage.hybrid": "混合"
+"resourceUsage.unknown": "unknown"
\ No newline at end of file
diff --git a/internal/errors/errors.go b/internal/errors/errors.go
index b1f83aa5e..eaadd2351 100644
--- a/internal/errors/errors.go
+++ b/internal/errors/errors.go
@@ -16,6 +16,7 @@ type StackMode string
 
 const (
 	// commandEnvKeyForBrief is the command environment name for switch key for brief error stack.
+	//
 	// Deprecated: use commandEnvKeyForStackMode instead.
 	commandEnvKeyForBrief = "gf.gerror.brief"
 
diff --git a/internal/httputil/httputils.go b/internal/httputil/httputils.go
index 41603e042..22cabfa19 100644
--- a/internal/httputil/httputils.go
+++ b/internal/httputil/httputils.go
@@ -13,7 +13,6 @@ import (
 
 	"github.com/gogf/gf/v2/encoding/gurl"
 	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
@@ -47,15 +46,6 @@ func BuildParams(params any, noUrlEncode ...bool) (encodedParamStr string) {
 	if len(noUrlEncode) == 1 {
 		urlEncode = !noUrlEncode[0]
 	}
-	// If there's file uploading, it ignores the url encoding.
-	if urlEncode {
-		for k, v := range m {
-			if gstr.Contains(k, fileUploadingKey) || gstr.Contains(gconv.String(v), fileUploadingKey) {
-				urlEncode = false
-				break
-			}
-		}
-	}
 	s := ""
 	for k, v := range m {
 		// Ignore nil attributes.
@@ -67,8 +57,8 @@ func BuildParams(params any, noUrlEncode ...bool) (encodedParamStr string) {
 		}
 		s = gconv.String(v)
 		if urlEncode {
-			if strings.HasPrefix(s, fileUploadingKey) && len(s) > len(fileUploadingKey) {
-				// No url encoding if uploading file.
+			if strings.HasPrefix(s, fileUploadingKey) {
+				// No url encoding if value starts with file uploading marker.
 			} else {
 				s = gurl.Encode(s)
 			}
diff --git a/internal/httputil/httputils_test.go b/internal/httputil/httputils_test.go
index 8833b9534..24a3ba333 100644
--- a/internal/httputil/httputils_test.go
+++ b/internal/httputil/httputils_test.go
@@ -51,3 +51,132 @@ func TestIssue4023(t *testing.T) {
 		t.Assert(params, "key1=value1")
 	})
 }
+
+// TestBuildParams_SpecialCharacters tests URL encoding of special characters.
+func TestBuildParams_SpecialCharacters(t *testing.T) {
+	// Test special characters are properly URL encoded.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"key": "value=with=equals",
+		}
+		params := httputil.BuildParams(data)
+		// = should be encoded as %3D
+		t.Assert(gstr.Contains(params, "key=value%3Dwith%3Dequals"), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"key": "value&with&ampersand",
+		}
+		params := httputil.BuildParams(data)
+		// & should be encoded as %26
+		t.Assert(gstr.Contains(params, "key=value%26with%26ampersand"), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"key": "value with spaces",
+		}
+		params := httputil.BuildParams(data)
+		// space should be encoded as + or %20
+		t.Assert(gstr.Contains(params, "key=value") && gstr.Contains(params, "with") && gstr.Contains(params, "spaces"), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"key": "value%percent",
+		}
+		params := httputil.BuildParams(data)
+		// % should be encoded as %25
+		t.Assert(gstr.Contains(params, "key=value%25percent"), true)
+	})
+}
+
+// TestBuildParams_FileUploadMarker tests that @file: prefix is not URL encoded.
+func TestBuildParams_FileUploadMarker(t *testing.T) {
+	// Test @file: with path is not encoded.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"file": "@file:/path/to/file.txt",
+		}
+		params := httputil.BuildParams(data)
+		// @file: should NOT be encoded
+		t.Assert(gstr.Contains(params, "file=@file:/path/to/file.txt"), true)
+	})
+
+	// Test @file: without path is not encoded.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"name": "@file:",
+		}
+		params := httputil.BuildParams(data)
+		// @file: alone should NOT be encoded
+		t.Assert(gstr.Contains(params, "name=@file:"), true)
+	})
+
+	// Test @file: with path does not affect other fields encoding.
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"file":  "@file:/path/to/file.txt",
+			"field": "value=1&b=2",
+		}
+		params := httputil.BuildParams(data)
+		// @file: should NOT be encoded
+		t.Assert(gstr.Contains(params, "@file:/path/to/file.txt"), true)
+		// Other field's special characters SHOULD be encoded
+		t.Assert(gstr.Contains(params, "field=value%3D1%26b%3D2"), true)
+	})
+}
+
+// TestBuildParams_NoUrlEncode tests the noUrlEncode parameter.
+func TestBuildParams_NoUrlEncode(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"key": "value=1&b=2",
+		}
+		// With noUrlEncode = true, special characters should NOT be encoded.
+		params := httputil.BuildParams(data, true)
+		t.Assert(gstr.Contains(params, "key=value=1&b=2"), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := g.Map{
+			"key": "value=1&b=2",
+		}
+		// With noUrlEncode = false (default), special characters SHOULD be encoded.
+		params := httputil.BuildParams(data, false)
+		t.Assert(gstr.Contains(params, "key=value%3D1%26b%3D2"), true)
+	})
+}
+
+// TestBuildParams_StringInput tests string input is returned as-is.
+func TestBuildParams_StringInput(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		data := "key=value&key2=value2"
+		params := httputil.BuildParams(data)
+		t.Assert(params, "key=value&key2=value2")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		data := []byte("key=value&key2=value2")
+		params := httputil.BuildParams(data)
+		t.Assert(params, "key=value&key2=value2")
+	})
+}
+
+// TestBuildParams_SliceInput tests slice input.
+func TestBuildParams_SliceInput(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		data := []any{g.Map{"a": "1", "b": "2"}}
+		params := httputil.BuildParams(data)
+		t.Assert(gstr.Contains(params, "a=1"), true)
+		t.Assert(gstr.Contains(params, "b=2"), true)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Empty slice
+		data := []any{}
+		params := httputil.BuildParams(data)
+		t.Assert(params, "")
+	})
+}
diff --git a/internal/utils/utils_str.go b/internal/utils/utils_str.go
index 37cc0318c..6a8290f0d 100644
--- a/internal/utils/utils_str.go
+++ b/internal/utils/utils_str.go
@@ -9,6 +9,7 @@ package utils
 import (
 	"bytes"
 	"strings"
+	"unicode"
 )
 
 // DefaultTrimChars are the characters which are stripped by Trim* functions in default.
@@ -167,3 +168,13 @@ func StripSlashes(str string) string {
 	}
 	return buf.String()
 }
+
+// IsASCII checks whether given string is ASCII characters.
+func IsASCII(s string) bool {
+	for i := 0; i < len(s); i++ {
+		if s[i] > unicode.MaxASCII {
+			return false
+		}
+	}
+	return true
+}
diff --git a/internal/utils/utils_z_unit_test.go b/internal/utils/utils_z_unit_test.go
index 40b228e38..f59d9081f 100644
--- a/internal/utils/utils_z_unit_test.go
+++ b/internal/utils/utils_z_unit_test.go
@@ -128,3 +128,13 @@ func Test_IsNumeric(t *testing.T) {
 		t.Assert(utils.IsNumeric("+.1"), false)
 	})
 }
+
+func TestIsASCII(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		t.AssertEQ(utils.IsASCII("test"), true)
+		t.AssertEQ(utils.IsASCII("测试"), false)
+		t.AssertEQ(utils.IsASCII("テスト"), false)
+		t.AssertEQ(utils.IsASCII("테스트"), false)
+		t.AssertEQ(utils.IsASCII("😁😭❤️😓"), false)
+	})
+}
diff --git a/net/gclient/gclient_request.go b/net/gclient/gclient_request.go
index be63859a0..59e22751c 100644
--- a/net/gclient/gclient_request.go
+++ b/net/gclient/gclient_request.go
@@ -10,6 +10,7 @@ import (
 	"bytes"
 	"context"
 	"io"
+	"mime"
 	"mime/multipart"
 	"net/http"
 	"os"
@@ -17,6 +18,7 @@ import (
 	"time"
 
 	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/encoding/gurl"
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/internal/httputil"
@@ -172,7 +174,12 @@ func (c *Client) prepareRequest(ctx context.Context, method, url string, data ..
 		allowFileUploading = true
 	)
 	if len(data) > 0 {
-		switch c.header[httpHeaderContentType] {
+		mediaType, _, err := mime.ParseMediaType(c.header[httpHeaderContentType])
+		if err != nil {
+			// Fallback: use the raw header value if parsing fails.
+			mediaType = c.header[httpHeaderContentType]
+		}
+		switch mediaType {
 		case httpHeaderContentTypeJson:
 			switch data[0].(type) {
 			case string, []byte:
@@ -206,7 +213,12 @@ func (c *Client) prepareRequest(ctx context.Context, method, url string, data ..
 	if method == http.MethodGet {
 		var bodyBuffer *bytes.Buffer
 		if params != "" {
-			switch c.header[httpHeaderContentType] {
+			mediaType, _, err := mime.ParseMediaType(c.header[httpHeaderContentType])
+			if err != nil {
+				// Fallback: use the raw header value if parsing fails.
+				mediaType = c.header[httpHeaderContentType]
+			}
+			switch mediaType {
 			case
 				httpHeaderContentTypeJson,
 				httpHeaderContentTypeXml:
@@ -237,7 +249,7 @@ func (c *Client) prepareRequest(ctx context.Context, method, url string, data ..
 				isFileUploading = false
 			)
 			for _, item := range strings.Split(params, "&") {
-				array := strings.Split(item, "=")
+				array := strings.SplitN(item, "=", 2)
 				if len(array) < 2 {
 					continue
 				}
@@ -276,6 +288,14 @@ func (c *Client) prepareRequest(ctx context.Context, method, url string, data ..
 						fieldName  = array[0]
 						fieldValue = array[1]
 					)
+					// Decode URL-encoded field name and value.
+					// If decoding fails, use the original value.
+					if v, err := gurl.Decode(fieldName); err == nil {
+						fieldName = v
+					}
+					if v, err := gurl.Decode(fieldValue); err == nil {
+						fieldValue = v
+					}
 					if err = writer.WriteField(fieldName, fieldValue); err != nil {
 						return nil, gerror.Wrapf(
 							err, `write form field failed with "%s", "%s"`, fieldName, fieldValue,
diff --git a/net/gclient/gclient_z_unit_issue_test.go b/net/gclient/gclient_z_unit_issue_test.go
index b397f114a..8f7d7fa5d 100644
--- a/net/gclient/gclient_z_unit_issue_test.go
+++ b/net/gclient/gclient_z_unit_issue_test.go
@@ -80,3 +80,262 @@ func Test_Issue3748(t *testing.T) {
 		t.AssertNil(err)
 	})
 }
+
+// https://github.com/gogf/gf/issues/4156
+func Test_Issue4156(t *testing.T) {
+	s := g.Server(guid.S())
+	s.BindHandler("/upload", func(r *ghttp.Request) {
+		// Return the fieldName value received
+		r.Response.Write(r.Get("fieldName"))
+	})
+	s.SetDumpRouterMap(false)
+	s.Start()
+	defer s.Shutdown()
+
+	clientHost := fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())
+	time.Sleep(100 * time.Millisecond)
+
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		// When posting form with file upload, if value contains '=', it should not be truncated.
+		data := g.Map{
+			"file":      "@file:" + gtest.DataPath("upload", "file1.txt"),
+			"fieldName": "aaa=1&b=2",
+		}
+		content := client.PostContent(ctx, "/upload", data)
+		// The complete value should be received, not truncated at '='
+		t.Assert(content, "aaa=1&b=2")
+	})
+}
+
+// Test_Issue4156_MultipleSpecialChars tests file upload with various special characters in field values.
+func Test_Issue4156_MultipleSpecialChars(t *testing.T) {
+	s := g.Server(guid.S())
+	s.BindHandler("/upload", func(r *ghttp.Request) {
+		r.Response.Write(r.Get("field"))
+	})
+	s.SetDumpRouterMap(false)
+	s.Start()
+	defer s.Shutdown()
+
+	clientHost := fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())
+	time.Sleep(100 * time.Millisecond)
+
+	// Test with multiple equals signs
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		data := g.Map{
+			"file":  "@file:" + gtest.DataPath("upload", "file1.txt"),
+			"field": "a=1=2=3",
+		}
+		content := client.PostContent(ctx, "/upload", data)
+		t.Assert(content, "a=1=2=3")
+	})
+
+	// Test with multiple ampersands
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		data := g.Map{
+			"file":  "@file:" + gtest.DataPath("upload", "file1.txt"),
+			"field": "a&b&c&d",
+		}
+		content := client.PostContent(ctx, "/upload", data)
+		t.Assert(content, "a&b&c&d")
+	})
+
+	// Test with percent sign
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		data := g.Map{
+			"file":  "@file:" + gtest.DataPath("upload", "file1.txt"),
+			"field": "100%complete",
+		}
+		content := client.PostContent(ctx, "/upload", data)
+		t.Assert(content, "100%complete")
+	})
+
+	// Test with plus sign
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		data := g.Map{
+			"file":  "@file:" + gtest.DataPath("upload", "file1.txt"),
+			"field": "1+2+3",
+		}
+		content := client.PostContent(ctx, "/upload", data)
+		t.Assert(content, "1+2+3")
+	})
+
+	// Test with spaces
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		data := g.Map{
+			"file":  "@file:" + gtest.DataPath("upload", "file1.txt"),
+			"field": "hello world test",
+		}
+		content := client.PostContent(ctx, "/upload", data)
+		t.Assert(content, "hello world test")
+	})
+
+	// Test with mixed special characters
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		data := g.Map{
+			"file":  "@file:" + gtest.DataPath("upload", "file1.txt"),
+			"field": "key=value&foo=bar%20test+plus",
+		}
+		content := client.PostContent(ctx, "/upload", data)
+		t.Assert(content, "key=value&foo=bar%20test+plus")
+	})
+}
+
+// Test_Issue4156_MultipleFields tests file upload with multiple fields containing special characters.
+func Test_Issue4156_MultipleFields(t *testing.T) {
+	s := g.Server(guid.S())
+	s.BindHandler("/upload", func(r *ghttp.Request) {
+		// Return all field values as JSON-like format
+		r.Response.Writef("field1=%s,field2=%s,field3=%s",
+			r.Get("field1"), r.Get("field2"), r.Get("field3"))
+	})
+	s.SetDumpRouterMap(false)
+	s.Start()
+	defer s.Shutdown()
+
+	clientHost := fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())
+	time.Sleep(100 * time.Millisecond)
+
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		data := g.Map{
+			"file":   "@file:" + gtest.DataPath("upload", "file1.txt"),
+			"field1": "a=1",
+			"field2": "b&2",
+			"field3": "c%3",
+		}
+		content := client.PostContent(ctx, "/upload", data)
+		t.Assert(strings.Contains(content, "field1=a=1"), true)
+		t.Assert(strings.Contains(content, "field2=b&2"), true)
+		t.Assert(strings.Contains(content, "field3=c%3"), true)
+	})
+}
+
+// Test_Issue4156_NoFileUpload tests that normal POST without file upload still works correctly.
+func Test_Issue4156_NoFileUpload(t *testing.T) {
+	s := g.Server(guid.S())
+	s.BindHandler("/post", func(r *ghttp.Request) {
+		r.Response.Write(r.Get("field"))
+	})
+	s.SetDumpRouterMap(false)
+	s.Start()
+	defer s.Shutdown()
+
+	clientHost := fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())
+	time.Sleep(100 * time.Millisecond)
+
+	// Test normal POST with special characters (no file upload)
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		data := g.Map{
+			"field": "a=1&b=2",
+		}
+		content := client.PostContent(ctx, "/post", data)
+		t.Assert(content, "a=1&b=2")
+	})
+
+	// Test POST with Content-Type: application/x-www-form-urlencoded
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		client.SetHeader("Content-Type", "application/x-www-form-urlencoded")
+		data := g.Map{
+			"field": "value=with=equals&and&ampersand",
+		}
+		content := client.PostContent(ctx, "/post", data)
+		t.Assert(content, "value=with=equals&and&ampersand")
+	})
+}
+
+// Test_Issue4156_PreEncodedValue tests that pre-encoded values are handled correctly.
+func Test_Issue4156_PreEncodedValue(t *testing.T) {
+	s := g.Server(guid.S())
+	s.BindHandler("/upload", func(r *ghttp.Request) {
+		r.Response.Write(r.Get("field"))
+	})
+	s.SetDumpRouterMap(false)
+	s.Start()
+	defer s.Shutdown()
+
+	clientHost := fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())
+	time.Sleep(100 * time.Millisecond)
+
+	// Test with already URL-encoded value - should preserve the encoding
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		data := g.Map{
+			"file":  "@file:" + gtest.DataPath("upload", "file1.txt"),
+			"field": "value%3Dwith%26encoding", // User wants to send literal %3D
+		}
+		content := client.PostContent(ctx, "/upload", data)
+		// The literal %3D and %26 should be preserved
+		t.Assert(content, "value%3Dwith%26encoding")
+	})
+}
+
+// Test_Issue4156_EmptyAndSpecialValues tests edge cases with empty and special values.
+func Test_Issue4156_EmptyAndSpecialValues(t *testing.T) {
+	s := g.Server(guid.S())
+	s.BindHandler("/upload", func(r *ghttp.Request) {
+		r.Response.Write(r.Get("field"))
+	})
+	s.SetDumpRouterMap(false)
+	s.Start()
+	defer s.Shutdown()
+
+	clientHost := fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())
+	time.Sleep(100 * time.Millisecond)
+
+	// Test with value starting with =
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		data := g.Map{
+			"file":  "@file:" + gtest.DataPath("upload", "file1.txt"),
+			"field": "=startWithEquals",
+		}
+		content := client.PostContent(ctx, "/upload", data)
+		t.Assert(content, "=startWithEquals")
+	})
+
+	// Test with value ending with =
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		data := g.Map{
+			"file":  "@file:" + gtest.DataPath("upload", "file1.txt"),
+			"field": "endWithEquals=",
+		}
+		content := client.PostContent(ctx, "/upload", data)
+		t.Assert(content, "endWithEquals=")
+	})
+
+	// Test with only special characters
+	gtest.C(t, func(t *gtest.T) {
+		client := gclient.New()
+		client.SetPrefix(clientHost)
+		data := g.Map{
+			"file":  "@file:" + gtest.DataPath("upload", "file1.txt"),
+			"field": "=&=&=",
+		}
+		content := client.PostContent(ctx, "/upload", data)
+		t.Assert(content, "=&=&=")
+	})
+}
diff --git a/net/ghttp/ghttp.go b/net/ghttp/ghttp.go
index 60ecf1dce..3a58745db 100644
--- a/net/ghttp/ghttp.go
+++ b/net/ghttp/ghttp.go
@@ -176,9 +176,12 @@ var (
 	// It is used for quick HTTP method searching using map.
 	methodsMap = make(map[string]struct{})
 
+	// checker is used for checking whether the value is nil.
+	checker = func(v *Server) bool { return v == nil }
+
 	// serverMapping stores more than one server instances for current processes.
 	// The key is the name of the server, and the value is its instance.
-	serverMapping = gmap.NewStrAnyMap(true)
+	serverMapping = gmap.NewKVMapWithChecker[string, *Server](checker, true)
 
 	// serverRunning marks the running server counts.
 	// If there is no successful server running or all servers' shutdown, this value is 0.
diff --git a/net/ghttp/ghttp_response.go b/net/ghttp/ghttp_response.go
index b4e2d7ea3..12dae0cac 100644
--- a/net/ghttp/ghttp_response.go
+++ b/net/ghttp/ghttp_response.go
@@ -14,6 +14,7 @@ import (
 	"net/url"
 	"time"
 
+	"github.com/gogf/gf/v2/internal/utils"
 	"github.com/gogf/gf/v2/net/ghttp/internal/response"
 	"github.com/gogf/gf/v2/net/gtrace"
 	"github.com/gogf/gf/v2/os/gfile"
@@ -89,7 +90,12 @@ func (r *Response) ServeFileDownload(path string, name ...string) {
 	}
 	r.Header().Set("Content-Type", "application/force-download")
 	r.Header().Set("Accept-Ranges", "bytes")
-	r.Header().Set("Content-Disposition", fmt.Sprintf(`attachment;filename=%s`, url.QueryEscape(downloadName)))
+	if utils.IsASCII(downloadName) {
+		r.Header().Set("Content-Disposition", fmt.Sprintf(`attachment;filename=%s`, url.QueryEscape(downloadName)))
+	} else {
+		r.Header().Set("Content-Disposition", fmt.Sprintf(`attachment;filename*=UTF-8''%s`, url.QueryEscape(downloadName)))
+	}
+
 	r.Header().Set("Access-Control-Expose-Headers", "Content-Disposition")
 	r.Server.serveFile(r.Request, serveFile)
 }
diff --git a/net/ghttp/ghttp_response_view.go b/net/ghttp/ghttp_response_view.go
index ff780f123..35346f76c 100644
--- a/net/ghttp/ghttp_response_view.go
+++ b/net/ghttp/ghttp_response_view.go
@@ -85,7 +85,12 @@ func (r *Response) buildInVars(params ...map[string]any) map[string]any {
 		gutil.MapMerge(m, params[0])
 	}
 	// Retrieve custom template variables from request object.
-	sessionMap := gconv.MapDeep(r.Request.Session.MustData())
+	sessionMap := gconv.Map(r.Request.Session.MustData(),
+		gconv.MapOption{
+			Deep:            true,
+			OmitEmpty:       false,
+			ContinueOnError: true,
+		})
 	gutil.MapMerge(m, map[string]any{
 		"Form":    r.Request.GetFormMap(),
 		"Query":   r.Request.GetQueryMap(),
diff --git a/net/ghttp/ghttp_server.go b/net/ghttp/ghttp_server.go
index 57af5c3fb..a486c981c 100644
--- a/net/ghttp/ghttp_server.go
+++ b/net/ghttp/ghttp_server.go
@@ -96,7 +96,7 @@ func GetServer(name ...any) *Server {
 	if len(name) > 0 && name[0] != "" {
 		serverName = gconv.String(name[0])
 	}
-	v := serverMapping.GetOrSetFuncLock(serverName, func() any {
+	return serverMapping.GetOrSetFuncLock(serverName, func() *Server {
 		s := &Server{
 			instance:         serverName,
 			plugins:          make([]Plugin, 0),
@@ -118,7 +118,6 @@ func GetServer(name ...any) *Server {
 		s.Use(internalMiddlewareServerTracing)
 		return s
 	})
-	return v.(*Server)
 }
 
 // Start starts listening on configured port.
@@ -477,10 +476,9 @@ func Wait() {
 	<-allShutdownChan
 
 	// Remove plugins.
-	serverMapping.Iterator(func(k string, v any) bool {
-		s := v.(*Server)
-		if len(s.plugins) > 0 {
-			for _, p := range s.plugins {
+	serverMapping.Iterator(func(k string, v *Server) bool {
+		if len(v.plugins) > 0 {
+			for _, p := range v.plugins {
 				intlog.Printf(ctx, `remove plugin: %s`, p.Name())
 				if err := p.Remove(); err != nil {
 					intlog.Errorf(ctx, `%+v`, err)
diff --git a/net/ghttp/ghttp_server_admin_process.go b/net/ghttp/ghttp_server_admin_process.go
index f7cf15549..60313218a 100644
--- a/net/ghttp/ghttp_server_admin_process.go
+++ b/net/ghttp/ghttp_server_admin_process.go
@@ -190,9 +190,9 @@ func forkRestartProcess(ctx context.Context, newExeFilePath ...string) error {
 // getServerFdMap returns all the servers name to file descriptor mapping as map.
 func getServerFdMap() map[string]listenerFdMap {
 	sfm := make(map[string]listenerFdMap)
-	serverMapping.RLockFunc(func(m map[string]any) {
+	serverMapping.RLockFunc(func(m map[string]*Server) {
 		for k, v := range m {
-			sfm[k] = v.(*Server).getListenerFdMap()
+			sfm[k] = v.getListenerFdMap()
 		}
 	})
 	return sfm
@@ -263,11 +263,10 @@ func shutdownWebServersGracefully(ctx context.Context, signal os.Signal) {
 	} else {
 		glog.Printf(ctx, "pid[%d]: server gracefully shutting down by api", gproc.Pid())
 	}
-	serverMapping.RLockFunc(func(m map[string]any) {
+	serverMapping.RLockFunc(func(m map[string]*Server) {
 		for _, v := range m {
-			server := v.(*Server)
-			server.doServiceDeregister()
-			for _, s := range server.servers {
+			v.doServiceDeregister()
+			for _, s := range v.servers {
 				s.Shutdown(ctx)
 			}
 		}
@@ -276,9 +275,9 @@ func shutdownWebServersGracefully(ctx context.Context, signal os.Signal) {
 
 // forceCloseWebServers forced shuts down all servers.
 func forceCloseWebServers(ctx context.Context) {
-	serverMapping.RLockFunc(func(m map[string]any) {
+	serverMapping.RLockFunc(func(m map[string]*Server) {
 		for _, v := range m {
-			for _, s := range v.(*Server).servers {
+			for _, s := range v.servers {
 				s.Close(ctx)
 			}
 		}
diff --git a/net/ghttp/ghttp_server_domain.go b/net/ghttp/ghttp_server_domain.go
index 10a98d780..1e49a4529 100644
--- a/net/ghttp/ghttp_server_domain.go
+++ b/net/ghttp/ghttp_server_domain.go
@@ -32,7 +32,7 @@ func (s *Server) Domain(domains string) *Domain {
 // BindHandler binds the handler for the specified pattern.
 func (d *Domain) BindHandler(pattern string, handler any) {
 	for domain := range d.domains {
-		d.server.BindHandler(pattern+"@"+domain, handler)
+		d.server.BindHandler(patternBindDomain(pattern, domain), handler)
 	}
 }
 
@@ -40,7 +40,7 @@ func (d *Domain) doBindHandler(ctx context.Context, in doBindHandlerInput) {
 	for domain := range d.domains {
 		d.server.doBindHandler(ctx, doBindHandlerInput{
 			Prefix:     in.Prefix,
-			Pattern:    in.Pattern + "@" + domain,
+			Pattern:    patternBindDomain(in.Pattern, domain),
 			FuncInfo:   in.FuncInfo,
 			Middleware: in.Middleware,
 			Source:     in.Source,
@@ -51,7 +51,7 @@ func (d *Domain) doBindHandler(ctx context.Context, in doBindHandlerInput) {
 // BindObject binds the object for the specified pattern.
 func (d *Domain) BindObject(pattern string, obj any, methods ...string) {
 	for domain := range d.domains {
-		d.server.BindObject(pattern+"@"+domain, obj, methods...)
+		d.server.BindObject(patternBindDomain(pattern, domain), obj, methods...)
 	}
 }
 
@@ -59,7 +59,7 @@ func (d *Domain) doBindObject(ctx context.Context, in doBindObjectInput) {
 	for domain := range d.domains {
 		d.server.doBindObject(ctx, doBindObjectInput{
 			Prefix:     in.Prefix,
-			Pattern:    in.Pattern + "@" + domain,
+			Pattern:    patternBindDomain(in.Pattern, domain),
 			Object:     in.Object,
 			Method:     in.Method,
 			Middleware: in.Middleware,
@@ -71,7 +71,7 @@ func (d *Domain) doBindObject(ctx context.Context, in doBindObjectInput) {
 // BindObjectMethod binds the method for the specified pattern.
 func (d *Domain) BindObjectMethod(pattern string, obj any, method string) {
 	for domain := range d.domains {
-		d.server.BindObjectMethod(pattern+"@"+domain, obj, method)
+		d.server.BindObjectMethod(patternBindDomain(pattern, domain), obj, method)
 	}
 }
 
@@ -79,7 +79,7 @@ func (d *Domain) doBindObjectMethod(ctx context.Context, in doBindObjectMethodIn
 	for domain := range d.domains {
 		d.server.doBindObjectMethod(ctx, doBindObjectMethodInput{
 			Prefix:     in.Prefix,
-			Pattern:    in.Pattern + "@" + domain,
+			Pattern:    patternBindDomain(in.Pattern, domain),
 			Object:     in.Object,
 			Method:     in.Method,
 			Middleware: in.Middleware,
@@ -91,7 +91,7 @@ func (d *Domain) doBindObjectMethod(ctx context.Context, in doBindObjectMethodIn
 // BindObjectRest binds the RESTful API for the specified pattern.
 func (d *Domain) BindObjectRest(pattern string, obj any) {
 	for domain := range d.domains {
-		d.server.BindObjectRest(pattern+"@"+domain, obj)
+		d.server.BindObjectRest(patternBindDomain(pattern, domain), obj)
 	}
 }
 
@@ -99,7 +99,7 @@ func (d *Domain) doBindObjectRest(ctx context.Context, in doBindObjectInput) {
 	for domain := range d.domains {
 		d.server.doBindObjectRest(ctx, doBindObjectInput{
 			Prefix:     in.Prefix,
-			Pattern:    in.Pattern + "@" + domain,
+			Pattern:    patternBindDomain(in.Pattern, domain),
 			Object:     in.Object,
 			Method:     in.Method,
 			Middleware: in.Middleware,
@@ -111,7 +111,7 @@ func (d *Domain) doBindObjectRest(ctx context.Context, in doBindObjectInput) {
 // BindHookHandler binds the hook handler for the specified pattern.
 func (d *Domain) BindHookHandler(pattern string, hook HookName, handler HandlerFunc) {
 	for domain := range d.domains {
-		d.server.BindHookHandler(pattern+"@"+domain, hook, handler)
+		d.server.BindHookHandler(patternBindDomain(pattern, domain), hook, handler)
 	}
 }
 
@@ -119,7 +119,7 @@ func (d *Domain) doBindHookHandler(ctx context.Context, in doBindHookHandlerInpu
 	for domain := range d.domains {
 		d.server.doBindHookHandler(ctx, doBindHookHandlerInput{
 			Prefix:   in.Prefix,
-			Pattern:  in.Pattern + "@" + domain,
+			Pattern:  patternBindDomain(in.Pattern, domain),
 			HookName: in.HookName,
 			Handler:  in.Handler,
 			Source:   in.Source,
@@ -130,7 +130,7 @@ func (d *Domain) doBindHookHandler(ctx context.Context, in doBindHookHandlerInpu
 // BindHookHandlerByMap binds the hook handler for the specified pattern.
 func (d *Domain) BindHookHandlerByMap(pattern string, hookMap map[HookName]HandlerFunc) {
 	for domain := range d.domains {
-		d.server.BindHookHandlerByMap(pattern+"@"+domain, hookMap)
+		d.server.BindHookHandlerByMap(patternBindDomain(pattern, domain), hookMap)
 	}
 }
 
@@ -151,14 +151,14 @@ func (d *Domain) BindStatusHandlerByMap(handlerMap map[int]HandlerFunc) {
 // BindMiddleware binds the middleware for the specified pattern.
 func (d *Domain) BindMiddleware(pattern string, handlers ...HandlerFunc) {
 	for domain := range d.domains {
-		d.server.BindMiddleware(pattern+"@"+domain, handlers...)
+		d.server.BindMiddleware(patternBindDomain(pattern, domain), handlers...)
 	}
 }
 
 // BindMiddlewareDefault binds the default middleware for the specified pattern.
 func (d *Domain) BindMiddlewareDefault(handlers ...HandlerFunc) {
 	for domain := range d.domains {
-		d.server.BindMiddleware(defaultMiddlewarePattern+"@"+domain, handlers...)
+		d.server.BindMiddleware(patternBindDomain(defaultMiddlewarePattern, domain), handlers...)
 	}
 }
 
@@ -166,3 +166,10 @@ func (d *Domain) BindMiddlewareDefault(handlers ...HandlerFunc) {
 func (d *Domain) Use(handlers ...HandlerFunc) {
 	d.BindMiddlewareDefault(handlers...)
 }
+
+func patternBindDomain(pattern, domain string) string {
+	if domain != "" {
+		return pattern + "@" + domain
+	}
+	return pattern
+}
diff --git a/net/ghttp/ghttp_server_log.go b/net/ghttp/ghttp_server_log.go
index 73dc7c64d..c2d003657 100644
--- a/net/ghttp/ghttp_server_log.go
+++ b/net/ghttp/ghttp_server_log.go
@@ -31,7 +31,7 @@ func (s *Server) handleAccessLog(r *Request) {
 		r.GetClientIp(), r.Referer(), r.UserAgent(),
 	)
 	logger := instance.GetOrSetFuncLock(loggerInstanceKey, func() any {
-		l := s.Logger()
+		l := s.Logger().Clone()
 		l.SetFile(s.config.AccessLogPattern)
 		l.SetStdoutPrint(s.config.LogStdout)
 		l.SetLevelPrint(false)
@@ -73,7 +73,7 @@ func (s *Server) handleErrorLog(err error, r *Request) {
 		content += ", " + err.Error()
 	}
 	logger := instance.GetOrSetFuncLock(loggerInstanceKey, func() any {
-		l := s.Logger()
+		l := s.Logger().Clone()
 		l.SetStack(false)
 		l.SetFile(s.config.ErrorLogPattern)
 		l.SetStdoutPrint(s.config.LogStdout)
diff --git a/net/ghttp/ghttp_server_router_serve.go b/net/ghttp/ghttp_server_router_serve.go
index b5c03fe25..63cd8b2ef 100644
--- a/net/ghttp/ghttp_server_router_serve.go
+++ b/net/ghttp/ghttp_server_router_serve.go
@@ -119,8 +119,8 @@ func (s *Server) searchHandlers(method, path, domain string) (parsedItems []*Han
 		array = strings.Split(path[1:], "/")
 	}
 	var (
-		lastMiddlewareElem    *glist.Element
-		parsedItemList        = glist.New()
+		lastMiddlewareElem    *glist.TElement[*HandlerItemParsed]
+		parsedItemList        = glist.NewT[*HandlerItemParsed]()
 		repeatHandlerCheckMap = make(map[int]struct{}, 16)
 	)
 
@@ -245,7 +245,7 @@ func (s *Server) searchHandlers(method, path, domain string) (parsedItems []*Han
 		var index = 0
 		parsedItems = make([]*HandlerItemParsed, parsedItemList.Len())
 		for e := parsedItemList.Front(); e != nil; e = e.Next() {
-			parsedItems[index] = e.Value.(*HandlerItemParsed)
+			parsedItems[index] = e.Value
 			index++
 		}
 	}
diff --git a/net/ghttp/ghttp_z_unit_feature_middleware_basic_test.go b/net/ghttp/ghttp_z_unit_feature_middleware_basic_test.go
index 67c5d2749..07c68e9b3 100644
--- a/net/ghttp/ghttp_z_unit_feature_middleware_basic_test.go
+++ b/net/ghttp/ghttp_z_unit_feature_middleware_basic_test.go
@@ -821,7 +821,7 @@ type testTracerProvider struct {
 	noop.TracerProvider
 }
 
-var _ trace.TracerProvider = &testTracerProvider{}
+var _ trace.TracerProvider = (*testTracerProvider)(nil)
 
 func (*testTracerProvider) Tracer(_ string, _ ...trace.TracerOption) trace.Tracer {
 	return noop.NewTracerProvider().Tracer("")
diff --git a/net/ghttp/ghttp_z_unit_feature_request_param_test.go b/net/ghttp/ghttp_z_unit_feature_request_param_test.go
index 041886225..9495b6e19 100644
--- a/net/ghttp/ghttp_z_unit_feature_request_param_test.go
+++ b/net/ghttp/ghttp_z_unit_feature_request_param_test.go
@@ -174,3 +174,49 @@ func Benchmark_ParamTagIn(b *testing.B) {
 		client.PostContent(ctx, "/user", "id="+strconv.Itoa(i))
 	}
 }
+
+type UserValidReq struct {
+	g.Meta   `path:"/user" method:"get" tags:"XXX" summary:"XXX"`
+	Query    string `p:"query" dc:"查询参数"`
+	Page     int    `p:"page_index" v:"min:1" dc:"页码，从1开始" d:"1"`
+	PageSize int    `p:"size" v:"between:1,50" dc:"每页大小，最大50" d:"20"`
+}
+
+type UserValidRes struct {
+	g.Meta `mime:"application/json"`
+}
+
+var (
+	UserValid = cUserValid{}
+)
+
+type cUserValid struct{}
+
+func (c *cUserValid) User(ctx context.Context, req *UserValidReq) (res *UserValidRes, err error) {
+	g.RequestFromCtx(ctx).Response.WriteJson(req)
+	return
+}
+
+// Test_Params_Valid for #4442
+func Test_Params_Valid(t *testing.T) {
+	s := g.Server(guid.S())
+	s.Group("/", func(group *ghttp.RouterGroup) {
+		group.Middleware(ghttp.MiddlewareHandlerResponse)
+		group.Bind(UserValid)
+	})
+	s.SetDumpRouterMap(false)
+	s.Start()
+	defer s.Shutdown()
+
+	time.Sleep(100 * time.Millisecond)
+
+	gtest.C(t, func(t *gtest.T) {
+		prefix := fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())
+		client := g.Client()
+		client.SetPrefix(prefix)
+
+		t.Assert(client.GetContent(ctx, "/user"), `{"Query":"","Page":1,"PageSize":20}`)
+		t.Assert(client.GetContent(ctx, "/user?page_index=0"), `{"code":51,"message":"The page_index value `+"`0`"+` must be equal or greater than 1","data":null}`)
+		t.Assert(client.GetContent(ctx, "/user?size=100"), `{"code":51,"message":"The size value `+"`100`"+` must be between 1 and 50","data":null}`)
+	})
+}
diff --git a/net/ghttp/ghttp_z_unit_feature_response_test.go b/net/ghttp/ghttp_z_unit_feature_response_test.go
index e97c5ba9a..35097351b 100644
--- a/net/ghttp/ghttp_z_unit_feature_response_test.go
+++ b/net/ghttp/ghttp_z_unit_feature_response_test.go
@@ -9,6 +9,7 @@ package ghttp_test
 import (
 	"fmt"
 	"net/http"
+	"net/url"
 	"strings"
 	"testing"
 	"time"
@@ -81,6 +82,17 @@ func Test_Response_ServeFileDownload(t *testing.T) {
 				client.GetContent(ctx, "/ServeFileDownload", "filePath=files/server.key"),
 				"BEGIN RSA PRIVATE KEY"),
 			true)
+
+		resp, err := client.Get(ctx, "/ServeFileDownload", "filePath="+srcPath)
+		t.AssertNil(err)
+		t.Assert(resp.ReadAllString(), "file1.txt: This file is for uploading unit test case.")
+		t.Assert(resp.Header.Get("Content-Disposition"), "attachment;filename=file1.txt")
+
+		srcPath = gtest.DataPath("upload", "中文.txt")
+		resp, err = client.Get(ctx, "/ServeFileDownload", "filePath="+srcPath)
+		t.AssertNil(err)
+		t.Assert(resp.ReadAllString(), "中文.txt: This file is for uploading unit test case.")
+		t.Assert(resp.Header.Get("Content-Disposition"), "attachment;filename*=UTF-8''"+url.QueryEscape("中文.txt"))
 	})
 }
 
diff --git a/net/ghttp/ghttp_z_unit_feature_router_domain_basic_test.go b/net/ghttp/ghttp_z_unit_feature_router_domain_basic_test.go
index d9c91428f..f0c1f36b3 100644
--- a/net/ghttp/ghttp_z_unit_feature_router_domain_basic_test.go
+++ b/net/ghttp/ghttp_z_unit_feature_router_domain_basic_test.go
@@ -363,3 +363,37 @@ func Test_Router_DomainGroup(t *testing.T) {
 		t.Assert(client2.DeleteContent(ctx, "/app/comment/20"), "Not Found")
 	})
 }
+
+// issue#4100
+func TestIssue4100(t *testing.T) {
+	s := g.Server(guid.S())
+	d := s.Domain("")
+	d.BindHandler("/:name", func(r *ghttp.Request) {
+		r.Response.Write("/:name")
+	})
+	d.BindHandler("/:name/update", func(r *ghttp.Request) {
+		r.Response.Write(r.Get("name"))
+	})
+	d.BindHandler("/:name/:action", func(r *ghttp.Request) {
+		r.Response.Write(r.Get("action"))
+	})
+	d.BindHandler("/:name/*any", func(r *ghttp.Request) {
+		r.Response.Write(r.Get("any"))
+	})
+	d.BindHandler("/user/list/{field}.html", func(r *ghttp.Request) {
+		r.Response.Write(r.Get("field"))
+	})
+	s.SetDumpRouterMap(false)
+	s.Start()
+	defer s.Shutdown()
+
+	time.Sleep(100 * time.Millisecond)
+	gtest.C(t, func(t *gtest.T) {
+		client := g.Client()
+		client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort()))
+		t.Assert(client.GetContent(ctx, "/john"), "")
+		t.Assert(client.GetContent(ctx, "/john/update"), "john")
+		t.Assert(client.GetContent(ctx, "/john/edit"), "edit")
+		t.Assert(client.GetContent(ctx, "/user/list/100.html"), "100")
+	})
+}
diff --git a/net/ghttp/testdata/upload/中文.txt b/net/ghttp/testdata/upload/中文.txt
new file mode 100644
index 000000000..e4a17e8fe
--- /dev/null
+++ b/net/ghttp/testdata/upload/中文.txt
@@ -0,0 +1 @@
+中文.txt: This file is for uploading unit test case.
\ No newline at end of file
diff --git a/net/gipv4/gipv4_convert.go b/net/gipv4/gipv4_convert.go
index 30d2e9392..df39a2f56 100644
--- a/net/gipv4/gipv4_convert.go
+++ b/net/gipv4/gipv4_convert.go
@@ -47,12 +47,14 @@ func LongToIpLittleEndian(long uint32) string {
 }
 
 // Ip2long converts ip address to an uint32 integer.
+//
 // Deprecated: Use IpToLongBigEndian instead.
 func Ip2long(ip string) uint32 {
 	return IpToLongBigEndian(ip)
 }
 
 // Long2ip converts an uint32 integer ip address to its string type address.
+//
 // Deprecated: Use LongToIpBigEndian instead.
 func Long2ip(long uint32) string {
 	return LongToIpBigEndian(long)
diff --git a/net/goai/goai.go b/net/goai/goai.go
index 51f8f53f4..c27152e10 100644
--- a/net/goai/goai.go
+++ b/net/goai/goai.go
@@ -144,24 +144,26 @@ func (oai *OpenApiV3) golangTypeToOAIType(t reflect.Type) string {
 	for t.Kind() == reflect.Pointer {
 		t = t.Elem()
 	}
+
+	switch t.String() {
+	case `time.Time`, `gtime.Time`:
+		return TypeString
+	case `ghttp.UploadFile`:
+		return TypeFile
+	case `[]uint8`:
+		return TypeString
+	case `uuid.UUID`:
+		return TypeString
+	}
+
 	switch t.Kind() {
 	case reflect.String:
 		return TypeString
 
 	case reflect.Struct:
-		switch t.String() {
-		case `time.Time`, `gtime.Time`:
-			return TypeString
-		case `ghttp.UploadFile`:
-			return TypeFile
-		}
 		return TypeObject
 
 	case reflect.Slice, reflect.Array:
-		switch t.String() {
-		case `[]uint8`:
-			return TypeString
-		}
 		return TypeArray
 
 	case reflect.Bool:
@@ -207,6 +209,7 @@ func (oai *OpenApiV3) golangTypeToSchemaName(t reflect.Type) string {
 	for t.Kind() == reflect.Pointer {
 		t = t.Elem()
 	}
+	schemaName = gstr.Replace(schemaName, `/`, `.`)
 	if pkgPath = t.PkgPath(); pkgPath != "" && pkgPath != "." {
 		if !oai.Config.IgnorePkgPath {
 			schemaName = gstr.Replace(pkgPath, `/`, `.`) + gstr.SubStrFrom(schemaName, ".")
@@ -216,6 +219,8 @@ func (oai *OpenApiV3) golangTypeToSchemaName(t reflect.Type) string {
 		` `: ``,
 		`{`: ``,
 		`}`: ``,
+		`[`: `.`,
+		`]`: `.`,
 	})
 	return schemaName
 }
diff --git a/net/goai/goai_z_unit_generic_type_test.go b/net/goai/goai_z_unit_generic_type_test.go
new file mode 100644
index 000000000..5371da9a7
--- /dev/null
+++ b/net/goai/goai_z_unit_generic_type_test.go
@@ -0,0 +1,244 @@
+// 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 goai_test
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/gogf/gf/v2/net/goai"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gmeta"
+)
+
+// TestOpenApiV3_GenericType tests the schema name generation for generic types
+// This test validates the PR fix for swagger $ref replace that handles Go generics
+// Specifically testing that [ and ] characters in type names are replaced with dots
+func TestOpenApiV3_GenericType(t *testing.T) {
+	// Define a generic type wrapper
+	type GenericItem[T any] struct {
+		Value T `dc:"Generic value"`
+	}
+
+	type StringItem = GenericItem[string]
+
+	type IntItem = GenericItem[int]
+
+	type Req struct {
+		gmeta.Meta `path:"/generic" method:"POST" tags:"default"`
+		StringData StringItem `dc:"String generic type"`
+		IntData    IntItem    `dc:"Int generic type"`
+	}
+
+	type Res struct {
+		gmeta.Meta `description:"Generic Response"`
+		Data       string `dc:"Response data"`
+	}
+
+	f := func(ctx context.Context, req *Req) (res *Res, err error) {
+		return
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err error
+			oai = goai.New()
+		)
+		err = oai.Add(goai.AddInput{
+			Path:   "/generic",
+			Object: f,
+		})
+		t.AssertNil(err)
+
+		// Verify that schema names are properly generated without special characters
+		schemas := oai.Components.Schemas.Map()
+		t.AssertGT(len(schemas), 0)
+
+		// Check that bracket characters [ and ] have been replaced with dots
+		// According to PR fix: `[`: `.`, `]`: `.`
+		for schemaName := range schemas {
+			// Should not contain [ or ] characters after replacement
+			t.Assert(!strings.Contains(schemaName, "["), true)
+			t.Assert(!strings.Contains(schemaName, "]"), true)
+		}
+	})
+}
+
+// TestOpenApiV3_SchemaNameReplacement tests the special character replacement in schema names
+// This verifies the core PR change which replaces:
+// - [ with .
+// - ] with .
+// - { with empty string
+// - } with empty string
+// - spaces with empty string
+func TestOpenApiV3_SchemaNameReplacement(t *testing.T) {
+	type SimpleReq struct {
+		gmeta.Meta `path:"/test" method:"POST"`
+		Name       string `dc:"Name field"`
+	}
+
+	type SimpleRes struct {
+		gmeta.Meta `description:"Simple Response"`
+		Status     string `dc:"Status field"`
+	}
+
+	f := func(ctx context.Context, req *SimpleReq) (res *SimpleRes, err error) {
+		return
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err error
+			oai = goai.New()
+		)
+		err = oai.Add(goai.AddInput{
+			Path:   "/test",
+			Object: f,
+		})
+		t.AssertNil(err)
+
+		// Get schema names and verify they are properly formatted
+		schemas := oai.Components.Schemas.Map()
+		for schemaName := range schemas {
+			// Verify special characters have been replaced:
+			// - [ should be replaced with .
+			// - ] should be replaced with .
+			// - { should be replaced with empty
+			// - } should be replaced with empty
+			// - spaces should be replaced with empty
+			t.Assert(!strings.Contains(schemaName, "["), true)
+			t.Assert(!strings.Contains(schemaName, "]"), true)
+			t.Assert(!strings.Contains(schemaName, "{"), true)
+			t.Assert(!strings.Contains(schemaName, "}"), true)
+		}
+	})
+}
+
+// TestOpenApiV3_ComplexGenericType tests more complex generic types
+// This specifically tests handling of map types and nested generic structures
+func TestOpenApiV3_ComplexGenericType(t *testing.T) {
+	type MapWrapper struct {
+		gmeta.Meta `path:"/mapwrapper" method:"POST"`
+		Data       map[string]string `dc:"Map data"`
+	}
+
+	type Res struct {
+		gmeta.Meta `description:"Map Response"`
+		Result     string `dc:"Result"`
+	}
+
+	f := func(ctx context.Context, req *MapWrapper) (res *Res, err error) {
+		return
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err error
+			oai = goai.New()
+		)
+		err = oai.Add(goai.AddInput{
+			Path:   "/mapwrapper",
+			Object: f,
+		})
+		t.AssertNil(err)
+
+		// Verify schema generation completes without errors
+		schemas := oai.Components.Schemas.Map()
+		t.AssertGT(len(schemas), 0)
+
+		// All schema names should be valid (no bracket characters)
+		for schemaName := range schemas {
+			t.Assert(!strings.Contains(schemaName, "["), true)
+			t.Assert(!strings.Contains(schemaName, "]"), true)
+		}
+	})
+}
+
+// TestOpenApiV3_PathWithSpecialChars tests path parameters with special handling
+// This ensures the PR changes don't affect regular parameter handling
+func TestOpenApiV3_PathWithSpecialChars(t *testing.T) {
+	type GetDetailReq struct {
+		gmeta.Meta `path:"/detail" method:"GET"`
+		ResourceId string `json:"resourceId" in:"query" dc:"Resource identifier"`
+		Type       string `json:"type" in:"query" dc:"Resource type"`
+	}
+
+	type DetailRes struct {
+		gmeta.Meta `description:"Detail Response"`
+		Content    string `dc:"Detail content"`
+	}
+
+	f := func(ctx context.Context, req *GetDetailReq) (res *DetailRes, err error) {
+		return
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err error
+			oai = goai.New()
+		)
+		err = oai.Add(goai.AddInput{
+			Path:   "/detail",
+			Object: f,
+		})
+		t.AssertNil(err)
+
+		// Verify all schemas are properly named
+		schemas := oai.Components.Schemas.Map()
+		for schemaName := range schemas {
+			// Should not contain special characters that were supposed to be replaced
+			t.Assert(!strings.Contains(schemaName, "["), true)
+			t.Assert(!strings.Contains(schemaName, "]"), true)
+		}
+	})
+}
+
+// TestOpenApiV3_SliceOfGenericTypes tests slice of generic types
+// This validates that slices containing generics are properly handled
+func TestOpenApiV3_SliceOfGenericTypes(t *testing.T) {
+	type Item[T any] struct {
+		Value T `dc:"Item value"`
+	}
+
+	type StringItem = Item[string]
+
+	type SliceReq struct {
+		gmeta.Meta `path:"/slice" method:"POST"`
+		Items      []StringItem `dc:"Slice of generic items"`
+	}
+
+	type SliceRes struct {
+		gmeta.Meta `description:"Slice Response"`
+		Count      int `dc:"Item count"`
+	}
+
+	f := func(ctx context.Context, req *SliceReq) (res *SliceRes, err error) {
+		return
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			err error
+			oai = goai.New()
+		)
+		err = oai.Add(goai.AddInput{
+			Path:   "/slice",
+			Object: f,
+		})
+		t.AssertNil(err)
+
+		schemas := oai.Components.Schemas.Map()
+		t.AssertGT(len(schemas), 0)
+
+		// Verify no bracket characters in schema names
+		for schemaName := range schemas {
+			t.Assert(!strings.Contains(schemaName, "["), true)
+			t.Assert(!strings.Contains(schemaName, "]"), true)
+		}
+	})
+}
diff --git a/net/gtcp/gtcp_pool.go b/net/gtcp/gtcp_pool.go
index 70b6ae735..6bccbdf68 100644
--- a/net/gtcp/gtcp_pool.go
+++ b/net/gtcp/gtcp_pool.go
@@ -30,13 +30,14 @@ const (
 )
 
 var (
+	poolChecker = func(v *gpool.Pool) bool { return v == nil }
 	// addressPoolMap is a mapping for address to its pool object.
-	addressPoolMap = gmap.NewStrAnyMap(true)
+	addressPoolMap = gmap.NewKVMapWithChecker[string, *gpool.Pool](poolChecker, true)
 )
 
 // NewPoolConn creates and returns a connection with pool feature.
 func NewPoolConn(addr string, timeout ...time.Duration) (*PoolConn, error) {
-	v := addressPoolMap.GetOrSetFuncLock(addr, func() any {
+	v := addressPoolMap.GetOrSetFuncLock(addr, func() *gpool.Pool {
 		var pool *gpool.Pool
 		pool = gpool.New(defaultPoolExpire, func() (any, error) {
 			if conn, err := NewConn(addr, timeout...); err == nil {
@@ -47,7 +48,7 @@ func NewPoolConn(addr string, timeout ...time.Duration) (*PoolConn, error) {
 		})
 		return pool
 	})
-	value, err := v.(*gpool.Pool).Get()
+	value, err := v.Get()
 	if err != nil {
 		return nil, err
 	}
diff --git a/net/gtcp/gtcp_server.go b/net/gtcp/gtcp_server.go
index e3d8ae77b..5b1c252c1 100644
--- a/net/gtcp/gtcp_server.go
+++ b/net/gtcp/gtcp_server.go
@@ -38,7 +38,12 @@ type Server struct {
 }
 
 // Map for name to server, for singleton purpose.
-var serverMapping = gmap.NewStrAnyMap(true)
+var (
+	// checker is used for checking whether the value is nil.
+	checker = func(v *Server) bool { return v == nil }
+	// serverMapping is the map for name to server.
+	serverMapping = gmap.NewKVMapWithChecker[any, *Server](checker, true)
+)
 
 // GetServer returns the TCP server with specified `name`,
 // or it returns a new normal TCP server named `name` if it does not exist.
@@ -48,9 +53,9 @@ func GetServer(name ...any) *Server {
 	if len(name) > 0 && name[0] != "" {
 		serverName = gconv.String(name[0])
 	}
-	return serverMapping.GetOrSetFuncLock(serverName, func() any {
+	return serverMapping.GetOrSetFuncLock(serverName, func() *Server {
 		return NewServer("", nil)
-	}).(*Server)
+	})
 }
 
 // NewServer creates and returns a new normal TCP server.
diff --git a/net/gudp/gudp_func.go b/net/gudp/gudp_func.go
index 32e4e8a05..b289dd7bb 100644
--- a/net/gudp/gudp_func.go
+++ b/net/gudp/gudp_func.go
@@ -72,6 +72,7 @@ func SendRecv(address string, data []byte, receive int, retry ...Retry) ([]byte,
 }
 
 // MustGetFreePort performs as GetFreePort, but it panics if any error occurs.
+//
 // Deprecated: the port might be used soon after they were returned, please use `:0` as the listening
 // address which asks system to assign a free port instead.
 func MustGetFreePort() (port int) {
@@ -83,6 +84,7 @@ func MustGetFreePort() (port int) {
 }
 
 // GetFreePort retrieves and returns a port that is free.
+//
 // Deprecated: the port might be used soon after they were returned, please use `:0` as the listening
 // address which asks system to assign a free port instead.
 func GetFreePort() (port int, err error) {
@@ -112,6 +114,7 @@ func GetFreePort() (port int, err error) {
 }
 
 // GetFreePorts retrieves and returns specified number of ports that are free.
+//
 // Deprecated: the ports might be used soon after they were returned, please use `:0` as the listening
 // address which asks system to assign a free port instead.
 func GetFreePorts(count int) (ports []int, err error) {
diff --git a/net/gudp/gudp_server.go b/net/gudp/gudp_server.go
index 9a23e2772..5444ed801 100644
--- a/net/gudp/gudp_server.go
+++ b/net/gudp/gudp_server.go
@@ -47,8 +47,10 @@ type Server struct {
 type ServerHandler func(conn *ServerConn)
 
 var (
+	// checker is used for checking whether the value is nil.
+	checker = func(v *Server) bool { return v == nil }
 	// serverMapping is used for instance name to its UDP server mappings.
-	serverMapping = gmap.NewStrAnyMap(true)
+	serverMapping = gmap.NewKVMapWithChecker[string, *Server](checker, true)
 )
 
 // GetServer creates and returns an udp server instance with given name.
@@ -57,12 +59,9 @@ func GetServer(name ...any) *Server {
 	if len(name) > 0 && name[0] != "" {
 		serverName = gconv.String(name[0])
 	}
-	if s := serverMapping.Get(serverName); s != nil {
-		return s.(*Server)
-	}
-	s := NewServer("", nil)
-	serverMapping.Set(serverName, s)
-	return s
+	return serverMapping.GetOrSetFuncLock(serverName, func() *Server {
+		return NewServer("", nil)
+	})
 }
 
 // NewServer creates and returns an udp server.
diff --git a/os/gcache/gcache.go b/os/gcache/gcache.go
index 51a4b411e..9412838a8 100644
--- a/os/gcache/gcache.go
+++ b/os/gcache/gcache.go
@@ -11,6 +11,7 @@ package gcache
 
 import (
 	"context"
+	"sync"
 	"time"
 
 	"github.com/gogf/gf/v2/container/gvar"
@@ -22,15 +23,17 @@ type Func = func(ctx context.Context) (value any, err error)
 // DurationNoExpire represents the cache key-value pair that never expires.
 const DurationNoExpire = time.Duration(0)
 
-// Default cache object.
-var defaultCache = New()
+// defaultCache returns the lazily-initialized default cache instance using sync.OnceValue.
+var defaultCache = sync.OnceValue(func() *Cache {
+	return New()
+})
 
 // Set sets cache with `key`-`value` pair, which is expired after `duration`.
 //
 // It does not expire if `duration` == 0.
 // It deletes the keys of `data` if `duration` < 0 or given `value` is nil.
 func Set(ctx context.Context, key any, value any, duration time.Duration) error {
-	return defaultCache.Set(ctx, key, value, duration)
+	return defaultCache().Set(ctx, key, value, duration)
 }
 
 // SetMap batch sets cache with key-value pairs by `data` map, which is expired after `duration`.
@@ -38,7 +41,7 @@ func Set(ctx context.Context, key any, value any, duration time.Duration) error
 // It does not expire if `duration` == 0.
 // It deletes the keys of `data` if `duration` < 0 or given `value` is nil.
 func SetMap(ctx context.Context, data map[any]any, duration time.Duration) error {
-	return defaultCache.SetMap(ctx, data, duration)
+	return defaultCache().SetMap(ctx, data, duration)
 }
 
 // SetIfNotExist sets cache with `key`-`value` pair which is expired after `duration`
@@ -48,7 +51,7 @@ func SetMap(ctx context.Context, data map[any]any, duration time.Duration) error
 // It does not expire if `duration` == 0.
 // It deletes the `key` if `duration` < 0 or given `value` is nil.
 func SetIfNotExist(ctx context.Context, key any, value any, duration time.Duration) (bool, error) {
-	return defaultCache.SetIfNotExist(ctx, key, value, duration)
+	return defaultCache().SetIfNotExist(ctx, key, value, duration)
 }
 
 // SetIfNotExistFunc sets `key` with result of function `f` and returns true
@@ -60,7 +63,7 @@ func SetIfNotExist(ctx context.Context, key any, value any, duration time.Durati
 // It does not expire if `duration` == 0.
 // It deletes the `key` if `duration` < 0 or given `value` is nil.
 func SetIfNotExistFunc(ctx context.Context, key any, f Func, duration time.Duration) (bool, error) {
-	return defaultCache.SetIfNotExistFunc(ctx, key, f, duration)
+	return defaultCache().SetIfNotExistFunc(ctx, key, f, duration)
 }
 
 // SetIfNotExistFuncLock sets `key` with result of function `f` and returns true
@@ -72,14 +75,14 @@ func SetIfNotExistFunc(ctx context.Context, key any, f Func, duration time.Durat
 // Note that it differs from function `SetIfNotExistFunc` is that the function `f` is executed within
 // writing mutex lock for concurrent safety purpose.
 func SetIfNotExistFuncLock(ctx context.Context, key any, f Func, duration time.Duration) (bool, error) {
-	return defaultCache.SetIfNotExistFuncLock(ctx, key, f, duration)
+	return defaultCache().SetIfNotExistFuncLock(ctx, key, f, duration)
 }
 
 // Get retrieves and returns the associated value of given `key`.
 // It returns nil if it does not exist, or its value is nil, or it's expired.
 // If you would like to check if the `key` exists in the cache, it's better using function Contains.
 func Get(ctx context.Context, key any) (*gvar.Var, error) {
-	return defaultCache.Get(ctx, key)
+	return defaultCache().Get(ctx, key)
 }
 
 // GetOrSet retrieves and returns the value of `key`, or sets `key`-`value` pair and
@@ -90,7 +93,7 @@ func Get(ctx context.Context, key any) (*gvar.Var, error) {
 // It deletes the `key` if `duration` < 0 or given `value` is nil, but it does nothing
 // if `value` is a function and the function result is nil.
 func GetOrSet(ctx context.Context, key any, value any, duration time.Duration) (*gvar.Var, error) {
-	return defaultCache.GetOrSet(ctx, key, value, duration)
+	return defaultCache().GetOrSet(ctx, key, value, duration)
 }
 
 // GetOrSetFunc retrieves and returns the value of `key`, or sets `key` with result of
@@ -101,7 +104,7 @@ func GetOrSet(ctx context.Context, key any, value any, duration time.Duration) (
 // It deletes the `key` if `duration` < 0 or given `value` is nil, but it does nothing
 // if `value` is a function and the function result is nil.
 func GetOrSetFunc(ctx context.Context, key any, f Func, duration time.Duration) (*gvar.Var, error) {
-	return defaultCache.GetOrSetFunc(ctx, key, f, duration)
+	return defaultCache().GetOrSetFunc(ctx, key, f, duration)
 }
 
 // GetOrSetFuncLock retrieves and returns the value of `key`, or sets `key` with result of
@@ -115,12 +118,12 @@ func GetOrSetFunc(ctx context.Context, key any, f Func, duration time.Duration)
 // Note that it differs from function `GetOrSetFunc` is that the function `f` is executed within
 // writing mutex lock for concurrent safety purpose.
 func GetOrSetFuncLock(ctx context.Context, key any, f Func, duration time.Duration) (*gvar.Var, error) {
-	return defaultCache.GetOrSetFuncLock(ctx, key, f, duration)
+	return defaultCache().GetOrSetFuncLock(ctx, key, f, duration)
 }
 
 // Contains checks and returns true if `key` exists in the cache, or else returns false.
 func Contains(ctx context.Context, key any) (bool, error) {
-	return defaultCache.Contains(ctx, key)
+	return defaultCache().Contains(ctx, key)
 }
 
 // GetExpire retrieves and returns the expiration of `key` in the cache.
@@ -129,18 +132,18 @@ func Contains(ctx context.Context, key any) (bool, error) {
 // It returns 0 if the `key` does not expire.
 // It returns -1 if the `key` does not exist in the cache.
 func GetExpire(ctx context.Context, key any) (time.Duration, error) {
-	return defaultCache.GetExpire(ctx, key)
+	return defaultCache().GetExpire(ctx, key)
 }
 
 // Remove deletes one or more keys from cache, and returns its value.
 // If multiple keys are given, it returns the value of the last deleted item.
 func Remove(ctx context.Context, keys ...any) (value *gvar.Var, err error) {
-	return defaultCache.Remove(ctx, keys...)
+	return defaultCache().Remove(ctx, keys...)
 }
 
 // Removes deletes `keys` in the cache.
 func Removes(ctx context.Context, keys []any) error {
-	return defaultCache.Removes(ctx, keys)
+	return defaultCache().Removes(ctx, keys)
 }
 
 // Update updates the value of `key` without changing its expiration and returns the old value.
@@ -149,7 +152,7 @@ func Removes(ctx context.Context, keys []any) error {
 // It deletes the `key` if given `value` is nil.
 // It does nothing if `key` does not exist in the cache.
 func Update(ctx context.Context, key any, value any) (oldValue *gvar.Var, exist bool, err error) {
-	return defaultCache.Update(ctx, key, value)
+	return defaultCache().Update(ctx, key, value)
 }
 
 // UpdateExpire updates the expiration of `key` and returns the old expiration duration value.
@@ -157,87 +160,87 @@ func Update(ctx context.Context, key any, value any) (oldValue *gvar.Var, exist
 // It returns -1 and does nothing if the `key` does not exist in the cache.
 // It deletes the `key` if `duration` < 0.
 func UpdateExpire(ctx context.Context, key any, duration time.Duration) (oldDuration time.Duration, err error) {
-	return defaultCache.UpdateExpire(ctx, key, duration)
+	return defaultCache().UpdateExpire(ctx, key, duration)
 }
 
 // Size returns the number of items in the cache.
 func Size(ctx context.Context) (int, error) {
-	return defaultCache.Size(ctx)
+	return defaultCache().Size(ctx)
 }
 
 // Data returns a copy of all key-value pairs in the cache as map type.
 // Note that this function may lead lots of memory usage, you can implement this function
 // if necessary.
 func Data(ctx context.Context) (map[any]any, error) {
-	return defaultCache.Data(ctx)
+	return defaultCache().Data(ctx)
 }
 
 // Keys returns all keys in the cache as slice.
 func Keys(ctx context.Context) ([]any, error) {
-	return defaultCache.Keys(ctx)
+	return defaultCache().Keys(ctx)
 }
 
 // KeyStrings returns all keys in the cache as string slice.
 func KeyStrings(ctx context.Context) ([]string, error) {
-	return defaultCache.KeyStrings(ctx)
+	return defaultCache().KeyStrings(ctx)
 }
 
 // Values returns all values in the cache as slice.
 func Values(ctx context.Context) ([]any, error) {
-	return defaultCache.Values(ctx)
+	return defaultCache().Values(ctx)
 }
 
 // MustGet acts like Get, but it panics if any error occurs.
 func MustGet(ctx context.Context, key any) *gvar.Var {
-	return defaultCache.MustGet(ctx, key)
+	return defaultCache().MustGet(ctx, key)
 }
 
 // MustGetOrSet acts like GetOrSet, but it panics if any error occurs.
 func MustGetOrSet(ctx context.Context, key any, value any, duration time.Duration) *gvar.Var {
-	return defaultCache.MustGetOrSet(ctx, key, value, duration)
+	return defaultCache().MustGetOrSet(ctx, key, value, duration)
 }
 
 // MustGetOrSetFunc acts like GetOrSetFunc, but it panics if any error occurs.
 func MustGetOrSetFunc(ctx context.Context, key any, f Func, duration time.Duration) *gvar.Var {
-	return defaultCache.MustGetOrSetFunc(ctx, key, f, duration)
+	return defaultCache().MustGetOrSetFunc(ctx, key, f, duration)
 }
 
 // MustGetOrSetFuncLock acts like GetOrSetFuncLock, but it panics if any error occurs.
 func MustGetOrSetFuncLock(ctx context.Context, key any, f Func, duration time.Duration) *gvar.Var {
-	return defaultCache.MustGetOrSetFuncLock(ctx, key, f, duration)
+	return defaultCache().MustGetOrSetFuncLock(ctx, key, f, duration)
 }
 
 // MustContains acts like Contains, but it panics if any error occurs.
 func MustContains(ctx context.Context, key any) bool {
-	return defaultCache.MustContains(ctx, key)
+	return defaultCache().MustContains(ctx, key)
 }
 
 // MustGetExpire acts like GetExpire, but it panics if any error occurs.
 func MustGetExpire(ctx context.Context, key any) time.Duration {
-	return defaultCache.MustGetExpire(ctx, key)
+	return defaultCache().MustGetExpire(ctx, key)
 }
 
 // MustSize acts like Size, but it panics if any error occurs.
 func MustSize(ctx context.Context) int {
-	return defaultCache.MustSize(ctx)
+	return defaultCache().MustSize(ctx)
 }
 
 // MustData acts like Data, but it panics if any error occurs.
 func MustData(ctx context.Context) map[any]any {
-	return defaultCache.MustData(ctx)
+	return defaultCache().MustData(ctx)
 }
 
 // MustKeys acts like Keys, but it panics if any error occurs.
 func MustKeys(ctx context.Context) []any {
-	return defaultCache.MustKeys(ctx)
+	return defaultCache().MustKeys(ctx)
 }
 
 // MustKeyStrings acts like KeyStrings, but it panics if any error occurs.
 func MustKeyStrings(ctx context.Context) []string {
-	return defaultCache.MustKeyStrings(ctx)
+	return defaultCache().MustKeyStrings(ctx)
 }
 
 // MustValues acts like Values, but it panics if any error occurs.
 func MustValues(ctx context.Context) []any {
-	return defaultCache.MustValues(ctx)
+	return defaultCache().MustValues(ctx)
 }
diff --git a/os/gcache/gcache_adapter_memory.go b/os/gcache/gcache_adapter_memory.go
index a205c5220..baf4ec922 100644
--- a/os/gcache/gcache_adapter_memory.go
+++ b/os/gcache/gcache_adapter_memory.go
@@ -21,14 +21,16 @@ import (
 
 // AdapterMemory is an adapter implements using memory.
 type AdapterMemory struct {
-	data        *memoryData        // data is the underlying cache data which is stored in a hash table.
-	expireTimes *memoryExpireTimes // expireTimes is the expiring key to its timestamp mapping, which is used for quick indexing and deleting.
-	expireSets  *memoryExpireSets  // expireSets is the expiring timestamp to its key set mapping, which is used for quick indexing and deleting.
-	lru         *memoryLru         // lru is the LRU manager, which is enabled when attribute cap > 0.
-	eventList   *glist.List        // eventList is the asynchronous event list for internal data synchronization.
-	closed      *gtype.Bool        // closed controls the cache closed or not.
+	data        *memoryData                       // data is the underlying cache data which is stored in a hash table.
+	expireTimes *memoryExpireTimes                // expireTimes is the expiring key to its timestamp mapping, which is used for quick indexing and deleting.
+	expireSets  *memoryExpireSets                 // expireSets is the expiring timestamp to its key set mapping, which is used for quick indexing and deleting.
+	lru         *memoryLru                        // lru is the LRU manager, which is enabled when attribute cap > 0.
+	eventList   *glist.TList[*adapterMemoryEvent] // eventList is the asynchronous event list for internal data synchronization.
+	closed      *gtype.Bool                       // closed controls the cache closed or not.
 }
 
+var _ Adapter = (*AdapterMemory)(nil)
+
 // Internal event item.
 type adapterMemoryEvent struct {
 	k any   // Key.
@@ -59,7 +61,7 @@ func doNewAdapterMemory() *AdapterMemory {
 		data:        newMemoryData(),
 		expireTimes: newMemoryExpireTimes(),
 		expireSets:  newMemoryExpireSets(),
-		eventList:   glist.New(true),
+		eventList:   glist.NewT[*adapterMemoryEvent](true),
 		closed:      gtype.NewBool(),
 	}
 	// Here may be a "timer leak" if adapter is manually changed from adapter_memory adapter.
@@ -412,7 +414,6 @@ func (c *AdapterMemory) syncEventAndClearExpired(ctx context.Context) {
 		return
 	}
 	var (
-		event         *adapterMemoryEvent
 		oldExpireTime int64
 		newExpireTime int64
 	)
@@ -420,11 +421,10 @@ func (c *AdapterMemory) syncEventAndClearExpired(ctx context.Context) {
 	// Data expiration synchronization.
 	// ================================
 	for {
-		v := c.eventList.PopFront()
-		if v == nil {
+		event := c.eventList.PopFront()
+		if event == nil {
 			break
 		}
-		event = v.(*adapterMemoryEvent)
 		// Fetching the old expire set.
 		oldExpireTime = c.expireTimes.Get(event.k)
 		// Calculating the new expiration time set.
diff --git a/os/gcache/gcache_adapter_memory_lru.go b/os/gcache/gcache_adapter_memory_lru.go
index 8473a88c4..d72817ad0 100644
--- a/os/gcache/gcache_adapter_memory_lru.go
+++ b/os/gcache/gcache_adapter_memory_lru.go
@@ -13,20 +13,23 @@ import (
 	"github.com/gogf/gf/v2/container/gmap"
 )
 
+// checker is used to check if the value is nil.
+var checker = func(v *glist.Element) bool { return v == nil }
+
 // memoryLru holds LRU info.
 // It uses list.List from stdlib for its underlying doubly linked list.
 type memoryLru struct {
-	mu   sync.RWMutex // Mutex to guarantee concurrent safety.
-	cap  int          // LRU cap.
-	data *gmap.Map    // Key mapping to the item of the list.
-	list *glist.List  // Key list.
+	mu   sync.RWMutex                     // Mutex to guarantee concurrent safety.
+	cap  int                              // LRU cap.
+	data *gmap.KVMap[any, *glist.Element] // Key mapping to the item of the list.
+	list *glist.List                      // Key list.
 }
 
 // newMemoryLru creates and returns a new LRU manager.
 func newMemoryLru(cap int) *memoryLru {
 	lru := &memoryLru{
 		cap:  cap,
-		data: gmap.New(false),
+		data: gmap.NewKVMapWithChecker[any, *glist.Element](checker, false),
 		list: glist.New(false),
 	}
 	return lru
@@ -41,7 +44,7 @@ func (l *memoryLru) Remove(keys ...any) {
 	defer l.mu.Unlock()
 	for _, key := range keys {
 		if v := l.data.Remove(key); v != nil {
-			l.list.Remove(v.(*glist.Element))
+			l.list.Remove(v)
 		}
 	}
 }
@@ -63,9 +66,8 @@ func (l *memoryLru) SaveAndEvict(keys ...any) (evictedKeys []any) {
 }
 
 func (l *memoryLru) doSaveAndEvict(key any) (evictedKey any) {
-	var element *glist.Element
-	if v := l.data.Get(key); v != nil {
-		element = v.(*glist.Element)
+	element := l.data.Get(key)
+	if element != nil {
 		if element.Prev() == nil {
 			// It this element is already on top of list,
 			// it ignores the element moving.
diff --git a/os/gcache/gcache_adapter_redis.go b/os/gcache/gcache_adapter_redis.go
index e0b876912..0669c5072 100644
--- a/os/gcache/gcache_adapter_redis.go
+++ b/os/gcache/gcache_adapter_redis.go
@@ -20,7 +20,9 @@ type AdapterRedis struct {
 	redis *gredis.Redis
 }
 
-// NewAdapterRedis creates and returns a new memory cache object.
+var _ Adapter = (*AdapterRedis)(nil)
+
+// NewAdapterRedis creates and returns a new Redis cache adapter.
 func NewAdapterRedis(redis *gredis.Redis) *AdapterRedis {
 	return &AdapterRedis{
 		redis: redis,
diff --git a/os/gcache/gcache_z_bench_test.go b/os/gcache/gcache_z_bench_test.go
index 3ab6b9b4f..00f6e68af 100644
--- a/os/gcache/gcache_z_bench_test.go
+++ b/os/gcache/gcache_z_bench_test.go
@@ -10,7 +10,9 @@ package gcache_test
 
 import (
 	"context"
+	"sync"
 	"testing"
+	"time"
 
 	"github.com/gogf/gf/v2/os/gcache"
 )
@@ -79,3 +81,65 @@ func Benchmark_CacheLruRemove(b *testing.B) {
 		}
 	})
 }
+
+var oldDefaultCache = gcache.New()
+var newDefaultCache = sync.OnceValue(func() *gcache.Cache {
+	return gcache.New()
+})
+
+func BenchmarkOldImplementation(b *testing.B) {
+	ctx := context.Background()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = oldDefaultCache.Set(ctx, "key", "value", time.Minute)
+	}
+}
+
+func BenchmarkNewImplementation(b *testing.B) {
+	ctx := context.Background()
+	newDefaultCache()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = newDefaultCache().Set(ctx, "key", "value", time.Minute)
+	}
+}
+
+func BenchmarkOldGet(b *testing.B) {
+	ctx := context.Background()
+	oldDefaultCache.Set(ctx, "test_key", "test_value", time.Minute)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = oldDefaultCache.Get(ctx, "test_key")
+	}
+}
+
+func BenchmarkNewGet(b *testing.B) {
+	ctx := context.Background()
+	newDefaultCache().Set(ctx, "test_key", "test_value", time.Minute)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = newDefaultCache().Get(ctx, "test_key")
+	}
+}
+
+func BenchmarkOldConcurrent(b *testing.B) {
+	ctx := context.Background()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_ = oldDefaultCache.Set(ctx, "key", "value", time.Minute)
+		}
+	})
+}
+
+func BenchmarkNewConcurrent(b *testing.B) {
+	ctx := context.Background()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_ = newDefaultCache().Set(ctx, "key", "value", time.Minute)
+		}
+	})
+}
diff --git a/os/gcache/gcache_z_unit_test.go b/os/gcache/gcache_z_unit_test.go
index 55a3e48c5..24d14cbdc 100644
--- a/os/gcache/gcache_z_unit_test.go
+++ b/os/gcache/gcache_z_unit_test.go
@@ -453,11 +453,7 @@ func TestCache_SetConcurrency(t *testing.T) {
 				})
 			}
 		}()
-		select {
-		case <-time.After(2 * time.Second):
-			// t.Log("first part end")
-		}
-
+		time.Sleep(2 * time.Second)
 		go func() {
 			for {
 				pool.Add(ctx, func(ctx context.Context) {
@@ -465,10 +461,7 @@ func TestCache_SetConcurrency(t *testing.T) {
 				})
 			}
 		}()
-		select {
-		case <-time.After(2 * time.Second):
-			// t.Log("second part end")
-		}
+		time.Sleep(2 * time.Second)
 	})
 }
 
diff --git a/os/gcfg/gcfg.go b/os/gcfg/gcfg.go
index 0768f8d5a..d41f8a187 100644
--- a/os/gcfg/gcfg.go
+++ b/os/gcfg/gcfg.go
@@ -58,7 +58,7 @@ func Instance(name ...string) *Config {
 	if len(name) > 0 && name[0] != "" {
 		instanceName = name[0]
 	}
-	return localInstances.GetOrSetFuncLock(instanceName, func() any {
+	return localInstances.GetOrSetFuncLock(instanceName, func() *Config {
 		adapterFile, err := NewAdapterFile()
 		if err != nil {
 			intlog.Errorf(context.Background(), `%+v`, err)
@@ -68,7 +68,7 @@ func Instance(name ...string) *Config {
 			adapterFile.SetFileName(instanceName)
 		}
 		return NewWithAdapter(adapterFile)
-	}).(*Config)
+	})
 }
 
 // SetAdapter sets the adapter of the current Config object.
diff --git a/os/gcfg/gcfg_adaper.go b/os/gcfg/gcfg_adaper.go
index a73afc7a0..667c0209a 100644
--- a/os/gcfg/gcfg_adaper.go
+++ b/os/gcfg/gcfg_adaper.go
@@ -28,3 +28,18 @@ type Adapter interface {
 	// you can implement this function if necessary.
 	Data(ctx context.Context) (data map[string]any, err error)
 }
+
+// WatcherFunc is the callback function type for configuration watchers.
+type WatcherFunc = func(context.Context)
+
+// WatcherAdapter is the interface for configuration watcher.
+type WatcherAdapter interface {
+	// AddWatcher adds a watcher function for specified `pattern` and `resource`.
+	AddWatcher(name string, fn WatcherFunc)
+	// RemoveWatcher removes the watcher function for specified `pattern` and `resource`.
+	RemoveWatcher(name string)
+	// GetWatcherNames returns all watcher names.
+	GetWatcherNames() []string
+	// IsWatching checks and returns whether the specified `pattern` is watching.
+	IsWatching(name string) bool
+}
diff --git a/os/gcfg/gcfg_adapter_content.go b/os/gcfg/gcfg_adapter_content.go
index 166c27374..e793c1839 100644
--- a/os/gcfg/gcfg_adapter_content.go
+++ b/os/gcfg/gcfg_adapter_content.go
@@ -14,17 +14,25 @@ import (
 	"github.com/gogf/gf/v2/errors/gerror"
 )
 
+var (
+	// Compile-time checking for interface implementation.
+	_ Adapter        = (*AdapterContent)(nil)
+	_ WatcherAdapter = (*AdapterContent)(nil)
+)
+
 // AdapterContent implements interface Adapter using content.
 // The configuration content supports the coding types as package `gjson`.
 type AdapterContent struct {
-	jsonVar *gvar.Var // The pared JSON object for configuration content, type: *gjson.Json.
+	jsonVar  *gvar.Var        // The pared JSON object for configuration content, type: *gjson.Json.
+	watchers *WatcherRegistry // Watchers for watching file changes.
 }
 
 // NewAdapterContent returns a new configuration management object using custom content.
 // The parameter `content` specifies the default configuration content for reading.
 func NewAdapterContent(content ...string) (*AdapterContent, error) {
 	a := &AdapterContent{
-		jsonVar: gvar.New(nil, true),
+		jsonVar:  gvar.New(nil, true),
+		watchers: NewWatcherRegistry(),
 	}
 	if len(content) > 0 {
 		if err := a.SetContent(content[0]); err != nil {
@@ -42,6 +50,8 @@ func (a *AdapterContent) SetContent(content string) error {
 		return gerror.Wrap(err, `load configuration content failed`)
 	}
 	a.jsonVar.Set(j)
+	adapterCtx := NewAdapterContentCtx().WithOperation(OperationSet).WithContent(content)
+	a.notifyWatchers(adapterCtx.Ctx)
 	return nil
 }
 
@@ -74,3 +84,28 @@ func (a *AdapterContent) Data(ctx context.Context) (data map[string]any, err err
 	}
 	return a.jsonVar.Val().(*gjson.Json).Var().Map(), nil
 }
+
+// AddWatcher adds a watcher for the specified configuration file.
+func (a *AdapterContent) AddWatcher(name string, fn WatcherFunc) {
+	a.watchers.Add(name, fn)
+}
+
+// RemoveWatcher removes the watcher for the specified configuration file.
+func (a *AdapterContent) RemoveWatcher(name string) {
+	a.watchers.Remove(name)
+}
+
+// GetWatcherNames returns all watcher names.
+func (a *AdapterContent) GetWatcherNames() []string {
+	return a.watchers.GetNames()
+}
+
+// IsWatching checks and returns whether the specified `name` is watching.
+func (a *AdapterContent) IsWatching(name string) bool {
+	return a.watchers.IsWatching(name)
+}
+
+// notifyWatchers notifies all watchers.
+func (a *AdapterContent) notifyWatchers(ctx context.Context) {
+	a.watchers.Notify(ctx)
+}
diff --git a/os/gcfg/gcfg_adapter_content_ctx.go b/os/gcfg/gcfg_adapter_content_ctx.go
new file mode 100644
index 000000000..c263a396a
--- /dev/null
+++ b/os/gcfg/gcfg_adapter_content_ctx.go
@@ -0,0 +1,74 @@
+// 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 gcfg provides reading, caching and managing for configuration.
+package gcfg
+
+import (
+	"context"
+)
+
+// AdapterContentCtx is the context for AdapterContent.
+type AdapterContentCtx struct {
+	// Ctx is the context with configuration values
+	Ctx context.Context
+}
+
+// NewAdapterContentCtxWithCtx creates and returns a new AdapterContentCtx with the given context.
+func NewAdapterContentCtxWithCtx(ctx context.Context) *AdapterContentCtx {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return &AdapterContentCtx{Ctx: ctx}
+}
+
+// NewAdapterContentCtx creates and returns a new AdapterContentCtx.
+// If ctx is provided, it uses that context, otherwise it creates a background context.
+func NewAdapterContentCtx(ctx ...context.Context) *AdapterContentCtx {
+	if len(ctx) > 0 {
+		return NewAdapterContentCtxWithCtx(ctx[0])
+	}
+	return NewAdapterContentCtxWithCtx(context.Background())
+}
+
+// GetAdapterContentCtx creates and returns an AdapterContentCtx with the given context.
+func GetAdapterContentCtx(ctx context.Context) *AdapterContentCtx {
+	return NewAdapterContentCtxWithCtx(ctx)
+}
+
+// WithOperation sets the operation in the context and returns the updated AdapterContentCtx.
+func (a *AdapterContentCtx) WithOperation(operation OperationType) *AdapterContentCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyOperation, operation)
+	return a
+}
+
+// WithContent sets the content in the context and returns the updated AdapterContentCtx.
+func (a *AdapterContentCtx) WithContent(content string) *AdapterContentCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyContent, content)
+	return a
+}
+
+// GetOperation retrieves the operation from the context.
+// Returns empty string if not found.
+func (a *AdapterContentCtx) GetOperation() OperationType {
+	if v := a.Ctx.Value(ContextKeyOperation); v != nil {
+		if s, ok := v.(OperationType); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetContent retrieves the content from the context.
+// Returns empty string if not found.
+func (a *AdapterContentCtx) GetContent() string {
+	if v := a.Ctx.Value(ContextKeyContent); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
diff --git a/os/gcfg/gcfg_adapter_file.go b/os/gcfg/gcfg_adapter_file.go
index 2114bb7dd..5b4f08e60 100644
--- a/os/gcfg/gcfg_adapter_file.go
+++ b/os/gcfg/gcfg_adapter_file.go
@@ -11,6 +11,7 @@ import (
 
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/errors/gerror"
@@ -23,12 +24,19 @@ import (
 	"github.com/gogf/gf/v2/util/gutil"
 )
 
+var (
+	// Compile-time checking for interface implementation.
+	_ Adapter        = (*AdapterFile)(nil)
+	_ WatcherAdapter = (*AdapterFile)(nil)
+)
+
 // AdapterFile implements interface Adapter using file.
 type AdapterFile struct {
-	defaultFileNameOrPath string           // Default configuration file name or file path.
-	searchPaths           *garray.StrArray // Searching the path array.
-	jsonMap               *gmap.StrAnyMap  // The pared JSON objects for configuration files.
-	violenceCheck         bool             // Whether it does violence check in value index searching. It affects the performance when set true(false in default).
+	defaultFileNameOrPath *gtype.String                    // Default configuration file name or file path.
+	searchPaths           *garray.StrArray                 // Searching the path array.
+	jsonMap               *gmap.KVMap[string, *gjson.Json] // The parsed JSON objects for configuration files.
+	violenceCheck         bool                             // Whether it does violence check in value index searching. It affects the performance when set true(false in default).
+	watchers              *WatcherRegistry                 // Watchers for watching file changes.
 }
 
 const (
@@ -38,8 +46,9 @@ const (
 
 var (
 	supportedFileTypes     = []string{"toml", "yaml", "yml", "json", "ini", "xml", "properties"} // All supported file types suffixes.
-	localInstances         = gmap.NewStrAnyMap(true)                                             // Instances map containing configuration instances.
-	customConfigContentMap = gmap.NewStrStrMap(true)                                             // Customized configuration content.
+	checker                = func(v *Config) bool { return v == nil }
+	localInstances         = gmap.NewKVMapWithChecker[string, *Config](checker, true) // Instances map containing configuration instances.
+	customConfigContentMap = gmap.NewStrStrMap(true)                                  // Customized configuration content.
 
 	// Prefix array for trying searching in resource manager.
 	resourceTryFolders = []string{
@@ -49,6 +58,9 @@ var (
 
 	// Prefix array for trying searching in the local system.
 	localSystemTryFolders = []string{"", "config/", "manifest/config"}
+
+	// jsonMapChecker is the checker for JSON map.
+	jsonMapChecker = func(v *gjson.Json) bool { return v == nil }
 )
 
 // NewAdapterFile returns a new configuration management object.
@@ -67,9 +79,10 @@ func NewAdapterFile(fileNameOrPath ...string) (*AdapterFile, error) {
 		}
 	}
 	config := &AdapterFile{
-		defaultFileNameOrPath: usedFileNameOrPath,
+		defaultFileNameOrPath: gtype.NewString(usedFileNameOrPath),
 		searchPaths:           garray.NewStrArray(true),
-		jsonMap:               gmap.NewStrAnyMap(true),
+		jsonMap:               gmap.NewKVMapWithChecker[string, *gjson.Json](jsonMapChecker, true),
+		watchers:              NewWatcherRegistry(),
 	}
 	// Customized dir path from env/cmd.
 	if customPath := command.GetOptWithEnv(commandEnvKeyForPath); customPath != "" {
@@ -121,12 +134,12 @@ func (a *AdapterFile) SetViolenceCheck(check bool) {
 
 // SetFileName sets the default configuration file name.
 func (a *AdapterFile) SetFileName(fileNameOrPath string) {
-	a.defaultFileNameOrPath = fileNameOrPath
+	a.defaultFileNameOrPath.Set(fileNameOrPath)
 }
 
 // GetFileName returns the default configuration file name.
 func (a *AdapterFile) GetFileName() string {
-	return a.defaultFileNameOrPath
+	return a.defaultFileNameOrPath.String()
 }
 
 // Get retrieves and returns value by specified `pattern`.
@@ -159,8 +172,17 @@ func (a *AdapterFile) Set(pattern string, value any) error {
 		return err
 	}
 	if j != nil {
-		return j.Set(pattern, value)
+		err = j.Set(pattern, value)
+		if err != nil {
+			return err
+		}
 	}
+	fileName := a.GetFileName()
+	filePath, _ := a.GetFilePath(fileName)
+	fileType := gfile.ExtName(fileName)
+	adapterCtx := NewAdapterFileCtx().WithOperation(OperationSet).WithKey(pattern).WithValue(value).
+		WithFileName(fileName).WithFilePath(filePath).WithFileType(fileType)
+	a.notifyWatchers(adapterCtx.Ctx)
 	return nil
 }
 
@@ -189,6 +211,11 @@ func (a *AdapterFile) MustGet(ctx context.Context, pattern string) *gvar.Var {
 // which will force reload configuration content from the file.
 func (a *AdapterFile) Clear() {
 	a.jsonMap.Clear()
+	fileName := a.GetFileName()
+	filePath, _ := a.GetFilePath(fileName)
+	fileType := gfile.ExtName(fileName)
+	adapterFileCtx := NewAdapterFileCtx().WithOperation(OperationClear).WithFileName(fileName).WithFilePath(filePath).WithFileType(fileType)
+	a.notifyWatchers(adapterFileCtx.Ctx)
 }
 
 // Dump prints current JSON object with more manually readable.
@@ -200,7 +227,7 @@ func (a *AdapterFile) Dump() {
 
 // Available checks and returns whether configuration of given `file` is available.
 func (a *AdapterFile) Available(ctx context.Context, fileName ...string) bool {
-	checkFileName := gutil.GetOrDefaultStr(a.defaultFileNameOrPath, fileName...)
+	checkFileName := gutil.GetOrDefaultStr(a.defaultFileNameOrPath.String(), fileName...)
 	// Custom configuration content exists.
 	if a.GetContent(checkFileName) != "" {
 		return true
@@ -228,16 +255,12 @@ func (a *AdapterFile) autoCheckAndAddMainPkgPathToSearchPaths() {
 // getJson returns a *gjson.Json object for the specified `file` content.
 // It would print error if file reading fails. It returns nil if any error occurs.
 func (a *AdapterFile) getJson(fileNameOrPath ...string) (configJson *gjson.Json, err error) {
-	var (
-		usedFileNameOrPath = a.defaultFileNameOrPath
-	)
+	usedFileNameOrPath := a.GetFileName()
 	if len(fileNameOrPath) > 0 && fileNameOrPath[0] != "" {
 		usedFileNameOrPath = fileNameOrPath[0]
-	} else {
-		usedFileNameOrPath = a.defaultFileNameOrPath
 	}
 	// It uses JSON map to cache specified configuration file content.
-	result := a.jsonMap.GetOrSetFuncLock(usedFileNameOrPath, func() any {
+	result := a.jsonMap.GetOrSetFuncLock(usedFileNameOrPath, func() *gjson.Json {
 		var (
 			content  string
 			filePath string
@@ -278,17 +301,60 @@ func (a *AdapterFile) getJson(fileNameOrPath ...string) (configJson *gjson.Json,
 		// Add monitor for this configuration file,
 		// any changes of this file will refresh its cache in the Config object.
 		if filePath != "" && !gres.Contains(filePath) {
-			_, err = gfsnotify.Add(filePath, func(event *gfsnotify.Event) {
+			_, err := gfsnotify.Add(filePath, func(event *gfsnotify.Event) {
 				a.jsonMap.Remove(usedFileNameOrPath)
+				if event.IsWrite() || event.IsRemove() || event.IsCreate() || event.IsRename() || event.IsChmod() {
+					fileType := gfile.ExtName(usedFileNameOrPath)
+					adapterCtx := NewAdapterFileCtx().WithFileName(usedFileNameOrPath).WithFilePath(filePath).WithFileType(fileType)
+					switch {
+					case event.IsWrite():
+						adapterCtx.WithOperation(OperationWrite)
+					case event.IsRemove():
+						adapterCtx.WithOperation(OperationRemove)
+					case event.IsCreate():
+						adapterCtx.WithOperation(OperationCreate)
+					case event.IsRename():
+						adapterCtx.WithOperation(OperationRename)
+					case event.IsChmod():
+						adapterCtx.WithOperation(OperationChmod)
+					}
+					a.notifyWatchers(adapterCtx.Ctx)
+				}
+				_ = event.Watcher.Remove(filePath)
 			})
 			if err != nil {
-				return nil
+				intlog.Errorf(context.TODO(), "failed listen config file event[%s]: %v", filePath, err)
 			}
 		}
 		return configJson
 	})
 	if result != nil {
-		return result.(*gjson.Json), err
+		return result, err
 	}
 	return
 }
+
+// AddWatcher adds a watcher for the specified configuration file.
+func (a *AdapterFile) AddWatcher(name string, fn WatcherFunc) {
+	a.watchers.Add(name, fn)
+}
+
+// RemoveWatcher removes the watcher for the specified configuration file.
+func (a *AdapterFile) RemoveWatcher(name string) {
+	a.watchers.Remove(name)
+}
+
+// GetWatcherNames returns all watcher names.
+func (a *AdapterFile) GetWatcherNames() []string {
+	return a.watchers.GetNames()
+}
+
+// IsWatching checks and returns whether the specified `name` is watching.
+func (a *AdapterFile) IsWatching(name string) bool {
+	return a.watchers.IsWatching(name)
+}
+
+// notifyWatchers notifies all watchers.
+func (a *AdapterFile) notifyWatchers(ctx context.Context) {
+	a.watchers.Notify(ctx)
+}
diff --git a/os/gcfg/gcfg_adapter_file_content.go b/os/gcfg/gcfg_adapter_file_content.go
index 834d7a197..c3bd240ff 100644
--- a/os/gcfg/gcfg_adapter_file_content.go
+++ b/os/gcfg/gcfg_adapter_file_content.go
@@ -20,18 +20,18 @@ func (a *AdapterFile) SetContent(content string, fileNameOrPath ...string) {
 		usedFileNameOrPath = fileNameOrPath[0]
 	}
 	// Clear file cache for instances which cached `name`.
-	localInstances.LockFunc(func(m map[string]any) {
+	localInstances.LockFunc(func(m map[string]*Config) {
 		if customConfigContentMap.Contains(usedFileNameOrPath) {
 			for _, v := range m {
-				if configInstance, ok := v.(*Config); ok {
-					if fileConfig, ok := configInstance.GetAdapter().(*AdapterFile); ok {
-						fileConfig.jsonMap.Remove(usedFileNameOrPath)
-					}
+				if fileConfig, ok := v.GetAdapter().(*AdapterFile); ok {
+					fileConfig.jsonMap.Remove(usedFileNameOrPath)
 				}
 			}
 		}
 		customConfigContentMap.Set(usedFileNameOrPath, content)
 	})
+	adapterCtx := NewAdapterFileCtx().WithFileName(usedFileNameOrPath).WithOperation(OperationSet).WithContent(content)
+	a.notifyWatchers(adapterCtx.Ctx)
 }
 
 // GetContent returns customized configuration content for specified `file`.
@@ -52,19 +52,18 @@ func (a *AdapterFile) RemoveContent(fileNameOrPath ...string) {
 		usedFileNameOrPath = fileNameOrPath[0]
 	}
 	// Clear file cache for instances which cached `name`.
-	localInstances.LockFunc(func(m map[string]any) {
+	localInstances.LockFunc(func(m map[string]*Config) {
 		if customConfigContentMap.Contains(usedFileNameOrPath) {
 			for _, v := range m {
-				if configInstance, ok := v.(*Config); ok {
-					if fileConfig, ok := configInstance.GetAdapter().(*AdapterFile); ok {
-						fileConfig.jsonMap.Remove(usedFileNameOrPath)
-					}
+				if fileConfig, ok := v.GetAdapter().(*AdapterFile); ok {
+					fileConfig.jsonMap.Remove(usedFileNameOrPath)
 				}
 			}
 			customConfigContentMap.Remove(usedFileNameOrPath)
 		}
 	})
-
+	adapterCtx := NewAdapterFileCtx().WithFileName(usedFileNameOrPath).WithOperation(OperationRemove)
+	a.notifyWatchers(adapterCtx.Ctx)
 	intlog.Printf(context.TODO(), `RemoveContent: %s`, usedFileNameOrPath)
 }
 
@@ -72,14 +71,14 @@ func (a *AdapterFile) RemoveContent(fileNameOrPath ...string) {
 func (a *AdapterFile) ClearContent() {
 	customConfigContentMap.Clear()
 	// Clear cache for all instances.
-	localInstances.LockFunc(func(m map[string]any) {
+	localInstances.LockFunc(func(m map[string]*Config) {
 		for _, v := range m {
-			if configInstance, ok := v.(*Config); ok {
-				if fileConfig, ok := configInstance.GetAdapter().(*AdapterFile); ok {
-					fileConfig.jsonMap.Clear()
-				}
+			if fileConfig, ok := v.GetAdapter().(*AdapterFile); ok {
+				fileConfig.jsonMap.Clear()
 			}
 		}
 	})
+	adapterCtx := NewAdapterFileCtx().WithOperation(OperationClear)
+	a.notifyWatchers(adapterCtx.Ctx)
 	intlog.Print(context.TODO(), `RemoveConfig`)
 }
diff --git a/os/gcfg/gcfg_adapter_file_ctx.go b/os/gcfg/gcfg_adapter_file_ctx.go
new file mode 100644
index 000000000..202205b6c
--- /dev/null
+++ b/os/gcfg/gcfg_adapter_file_ctx.go
@@ -0,0 +1,157 @@
+// 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 gcfg provides reading, caching and managing for configuration.
+package gcfg
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/container/gvar"
+)
+
+// AdapterFileCtx is the context for AdapterFile.
+type AdapterFileCtx struct {
+	// Ctx is the context with configuration values
+	Ctx context.Context
+}
+
+// NewAdapterFileCtxWithCtx creates and returns a new AdapterFileCtx with the given context.
+func NewAdapterFileCtxWithCtx(ctx context.Context) *AdapterFileCtx {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return &AdapterFileCtx{Ctx: ctx}
+}
+
+// NewAdapterFileCtx creates and returns a new AdapterFileCtx.
+// If ctx is provided, it uses that context, otherwise it creates a background context.
+func NewAdapterFileCtx(ctx ...context.Context) *AdapterFileCtx {
+	if len(ctx) > 0 {
+		return NewAdapterFileCtxWithCtx(ctx[0])
+	}
+	return NewAdapterFileCtxWithCtx(context.Background())
+}
+
+// GetAdapterFileCtx creates and returns an AdapterFileCtx with the given context.
+func GetAdapterFileCtx(ctx context.Context) *AdapterFileCtx {
+	return NewAdapterFileCtxWithCtx(ctx)
+}
+
+// WithFileName sets the file name in the context and returns the updated AdapterFileCtx.
+func (a *AdapterFileCtx) WithFileName(fileName string) *AdapterFileCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyFileName, fileName)
+	return a
+}
+
+// WithFilePath sets the file path in the context and returns the updated AdapterFileCtx.
+func (a *AdapterFileCtx) WithFilePath(filePath string) *AdapterFileCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyFilePath, filePath)
+	return a
+}
+
+// WithFileType sets the file type in the context and returns the updated AdapterFileCtx.
+func (a *AdapterFileCtx) WithFileType(fileType string) *AdapterFileCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyFileType, fileType)
+	return a
+}
+
+// WithOperation sets the operation in the context and returns the updated AdapterFileCtx.
+func (a *AdapterFileCtx) WithOperation(operation OperationType) *AdapterFileCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyOperation, operation)
+	return a
+}
+
+// WithKey sets the key in the context and returns the updated AdapterFileCtx.
+func (a *AdapterFileCtx) WithKey(key string) *AdapterFileCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyKey, key)
+	return a
+}
+
+// WithValue sets the value in the context and returns the updated AdapterFileCtx.
+func (a *AdapterFileCtx) WithValue(value any) *AdapterFileCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyValue, value)
+	return a
+}
+
+// WithContent sets the content in the context and returns the updated AdapterFileCtx.
+func (a *AdapterFileCtx) WithContent(content any) *AdapterFileCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyContent, content)
+	return a
+}
+
+// GetFileName retrieves the file name from the context.
+// Returns empty string if not found.
+func (a *AdapterFileCtx) GetFileName() string {
+	if v := a.Ctx.Value(ContextKeyFileName); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetFilePath retrieves the file path from the context.
+// Returns empty string if not found.
+func (a *AdapterFileCtx) GetFilePath() string {
+	if v := a.Ctx.Value(ContextKeyFilePath); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetFileType retrieves the file type from the context.
+// Returns empty string if not found.
+func (a *AdapterFileCtx) GetFileType() string {
+	if v := a.Ctx.Value(ContextKeyFileType); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetOperation retrieves the operation from the context.
+// Returns empty string if not found.
+func (a *AdapterFileCtx) GetOperation() OperationType {
+	if v := a.Ctx.Value(ContextKeyOperation); v != nil {
+		if s, ok := v.(OperationType); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetKey retrieves the key from the context.
+// Returns empty string if not found.
+func (a *AdapterFileCtx) GetKey() string {
+	if v := a.Ctx.Value(ContextKeyKey); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetValue retrieves the value from the context.
+// Returns nil if not found.
+func (a *AdapterFileCtx) GetValue() *gvar.Var {
+	if v := a.Ctx.Value(ContextKeyValue); v != nil {
+		return gvar.New(v)
+	}
+	return nil
+}
+
+// GetContent retrieves the set content from the context.
+// Returns nil if not found.
+func (a *AdapterFileCtx) GetContent() *gvar.Var {
+	if v := a.Ctx.Value(ContextKeyContent); v != nil {
+		return gvar.New(v)
+	}
+	return nil
+}
diff --git a/os/gcfg/gcfg_adapter_file_path.go b/os/gcfg/gcfg_adapter_file_path.go
index 0044072ef..3125b8baa 100644
--- a/os/gcfg/gcfg_adapter_file_path.go
+++ b/os/gcfg/gcfg_adapter_file_path.go
@@ -244,7 +244,7 @@ func (a *AdapterFile) GetFilePath(fileNameOrPath ...string) (filePath string, er
 	var (
 		fileExtName        string
 		tempFileNameOrPath string
-		usedFileNameOrPath = a.defaultFileNameOrPath
+		usedFileNameOrPath = a.defaultFileNameOrPath.String()
 	)
 	if len(fileNameOrPath) > 0 {
 		usedFileNameOrPath = fileNameOrPath[0]
diff --git a/os/gcfg/gcfg_ctx_keys.go b/os/gcfg/gcfg_ctx_keys.go
new file mode 100644
index 000000000..9d3976655
--- /dev/null
+++ b/os/gcfg/gcfg_ctx_keys.go
@@ -0,0 +1,51 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+// Package gcfg provides reading, caching and managing for configuration.
+package gcfg
+
+import "github.com/gogf/gf/v2/os/gctx"
+
+// Context key constants for configuration operations.
+const (
+	// ContextKeyFileName is the context key for file name
+	ContextKeyFileName gctx.StrKey = "fileName"
+	// ContextKeyFilePath is the context key for file path
+	ContextKeyFilePath gctx.StrKey = "filePath"
+	// ContextKeyFileType is the context key for file type
+	ContextKeyFileType gctx.StrKey = "fileType"
+	// ContextKeyOperation is the context key for operation type
+	ContextKeyOperation gctx.StrKey = "operation"
+	// ContextKeyKey is the context key for key
+	ContextKeyKey gctx.StrKey = "key"
+	// ContextKeyValue is the context key for value
+	ContextKeyValue gctx.StrKey = "value"
+	// ContextKeyContent is the context key for set content
+	ContextKeyContent gctx.StrKey = "content"
+)
+
+// OperationType defines the type for configuration operation.
+type OperationType string
+
+// Operation constants for configuration operations.
+const (
+	// OperationSet represents set operation
+	OperationSet OperationType = "set"
+	// OperationWrite represents write operation
+	OperationWrite OperationType = "write"
+	// OperationRename represents rename operation
+	OperationRename OperationType = "rename"
+	// OperationRemove represents remove operation
+	OperationRemove OperationType = "remove"
+	// OperationCreate represents create operation
+	OperationCreate OperationType = "create"
+	// OperationChmod represents chmod operation
+	OperationChmod OperationType = "chmod"
+	// OperationClear represents clear operation
+	OperationClear OperationType = "clear"
+	// OperationUpdate represents update operation
+	OperationUpdate OperationType = "update"
+)
diff --git a/os/gcfg/gcfg_loader.go b/os/gcfg/gcfg_loader.go
new file mode 100644
index 000000000..bf1b9130c
--- /dev/null
+++ b/os/gcfg/gcfg_loader.go
@@ -0,0 +1,253 @@
+// 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 gcfg
+
+import (
+	"context"
+	"sync"
+
+	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/intlog"
+)
+
+// Loader is a generic configuration manager that provides
+// configuration loading, watching and management similar to Spring Boot's @ConfigurationProperties
+type Loader[T any] struct {
+	config         *Config                              // The configuration instance to watch
+	propertyKey    string                               // The property key pattern to watch
+	targetStruct   *T                                   // The target struct pointer to bind configuration to
+	mutex          sync.RWMutex                         // Mutex for thread-safe operations
+	onChange       func(T) error                        // Callback function when configuration changes
+	converter      func(data any, target *T) error      // Optional custom converter function
+	watchErrorFunc func(ctx context.Context, err error) // Optional error handling function for watch operations
+	reuse          bool                                 // reuse the same target struct, default is false to avoid data race
+	watcherName    string                               // watcher name
+}
+
+// NewLoader creates a new Loader instance
+// config: the configuration instance to watch for changes
+// propertyKey: the property key pattern to watch (use "" or "." to watch all configuration)
+// targetStruct: pointer to the struct that will receive the configuration values
+func NewLoader[T any](config *Config, propertyKey string, targetStruct ...*T) *Loader[T] {
+	if len(targetStruct) > 0 {
+		return &Loader[T]{
+			config:       config,
+			propertyKey:  propertyKey,
+			targetStruct: targetStruct[0],
+			reuse:        false,
+		}
+	}
+	return &Loader[T]{
+		config:       config,
+		propertyKey:  propertyKey,
+		targetStruct: new(T),
+		reuse:        false,
+	}
+}
+
+// NewLoaderWithAdapter creates a new Loader instance
+// adapter: the adapter instance to use for loading and watching configuration
+// propertyKey: the property key pattern to watch (use "" or "." to watch all configuration)
+// targetStruct: pointer to the struct that will receive the configuration values
+func NewLoaderWithAdapter[T any](adapter Adapter, propertyKey string, targetStruct ...*T) *Loader[T] {
+	return NewLoader(NewWithAdapter(adapter), propertyKey, targetStruct...)
+}
+
+// OnChange sets the callback function that will be called when configuration changes
+// The callback function receives the updated configuration struct and can return an error
+func (l *Loader[T]) OnChange(fn func(updated T) error) *Loader[T] {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+	l.onChange = fn
+	return l
+}
+
+// Load loads configuration from the config instance and binds it to the target struct
+// The context is passed to the underlying configuration adapter
+func (l *Loader[T]) Load(ctx context.Context) error {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+
+	// Get configuration data
+	var data *gvar.Var
+	if l.propertyKey == "" || l.propertyKey == "." {
+		// Get all configuration data
+		configData, err := l.config.Data(ctx)
+		if err != nil {
+			return err
+		}
+		data = gvar.New(configData)
+	} else {
+		// Get specific property
+		configValue, err := l.config.Get(ctx, l.propertyKey)
+		if err != nil {
+			return err
+		}
+		if configValue != nil {
+			data = configValue
+		} else {
+			data = gvar.New(nil)
+		}
+	}
+
+	// Use custom converter if provided, otherwise use default gconv.Scan
+	if l.converter != nil && data != nil {
+		if l.reuse {
+			if err := l.converter(data.Val(), l.targetStruct); err != nil {
+				return err
+			}
+		} else {
+			var newConfig T
+			if err := l.converter(data.Val(), &newConfig); err != nil {
+				return err
+			}
+			l.targetStruct = &newConfig
+		}
+	} else {
+		if data != nil {
+			if l.reuse {
+				if err := data.Scan(l.targetStruct); err != nil {
+					return err
+				}
+			} else {
+				var newConfig T
+				if err := data.Scan(&newConfig); err != nil {
+					return err
+				}
+				l.targetStruct = &newConfig
+			}
+		}
+	}
+
+	// Call change callback if exists
+	if l.onChange != nil {
+		return l.onChange(*l.targetStruct)
+	}
+
+	return nil
+}
+
+// MustLoad is like Load but panics if there is an error
+func (l *Loader[T]) MustLoad(ctx context.Context) {
+	if err := l.Load(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// Watch starts watching for configuration changes and automatically updates the target struct
+// name: the name of the watcher, which is used to identify this watcher
+// This method sets up a watcher that will call Load() when configuration changes are detected
+func (l *Loader[T]) Watch(ctx context.Context, name string) error {
+	if name == "" {
+		return gerror.New("Watcher name cannot be empty")
+	}
+	adapter := l.config.GetAdapter()
+	if watcherAdapter, ok := adapter.(WatcherAdapter); ok {
+		watcherAdapter.AddWatcher(name, func(ctx context.Context) {
+			// Reload configuration when change is detected
+			if err := l.Load(ctx); err != nil {
+				// Use the configured error handler if available, otherwise execute default logging
+				if l.watchErrorFunc != nil {
+					l.watchErrorFunc(ctx, err)
+				} else {
+					// Default logging using intlog (internal logging for development)
+					intlog.Errorf(ctx, "Configuration load failed in watcher %s: %v", name, err)
+				}
+			}
+		})
+		l.watcherName = name
+		return nil
+	}
+	return gerror.New("Watcher adapter not found")
+}
+
+// MustWatch is like Watch but panics if there is an error
+func (l *Loader[T]) MustWatch(ctx context.Context, name string) {
+	if err := l.Watch(ctx, name); err != nil {
+		panic(err)
+	}
+}
+
+// MustLoadAndWatch is a convenience method that calls MustLoad and MustWatch
+func (l *Loader[T]) MustLoadAndWatch(ctx context.Context, name string) {
+	l.MustLoad(ctx)
+	l.MustWatch(ctx, name)
+}
+
+// Get returns the current configuration struct
+// This method is thread-safe and returns a copy of the current configuration
+func (l *Loader[T]) Get() T {
+	l.mutex.RLock()
+	defer l.mutex.RUnlock()
+	return *l.targetStruct
+}
+
+// GetPointer returns a pointer to the current configuration struct
+// This method is thread-safe and returns a pointer to the current configuration
+// The returned pointer is safe for read operations but should not be modified
+func (l *Loader[T]) GetPointer() *T {
+	l.mutex.RLock()
+	defer l.mutex.RUnlock()
+	return l.targetStruct
+}
+
+// SetConverter sets a custom converter function that will be used during Load operations
+// The converter function receives the source data and the target struct pointer
+func (l *Loader[T]) SetConverter(converter func(data any, target *T) error) *Loader[T] {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+	l.converter = converter
+	return l
+}
+
+// SetWatchErrorHandler sets an error handling function that will be called when Load operations fail during Watch
+func (l *Loader[T]) SetWatchErrorHandler(errorFunc func(ctx context.Context, err error)) *Loader[T] {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+	l.watchErrorFunc = errorFunc
+	return l
+}
+
+// SetReuseTargetStruct sets whether to reuse the same target struct or create a new one on updates
+func (l *Loader[T]) SetReuseTargetStruct(reuse bool) *Loader[T] {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+	l.reuse = reuse
+	return l
+}
+
+// StopWatch stops watching for configuration changes and removes the associated watcher
+func (l *Loader[T]) StopWatch(ctx context.Context) (bool, error) {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+
+	if l.watcherName == "" {
+		return false, gerror.New("No watcher name specified")
+	}
+	adapter := l.config.GetAdapter()
+	if watcherAdapter, ok := adapter.(WatcherAdapter); ok {
+		watcherAdapter.RemoveWatcher(l.watcherName)
+		l.watcherName = ""
+		return true, nil
+	}
+	return false, gerror.New("Watcher adapter not found")
+}
+
+// IsWatching returns true if the loader is currently watching for configuration changes
+func (l *Loader[T]) IsWatching() bool {
+	l.mutex.RLock()
+	defer l.mutex.RUnlock()
+	if l.watcherName == "" {
+		return false
+	}
+	adapter := l.config.GetAdapter()
+	if watcherAdapter, ok := adapter.(WatcherAdapter); ok {
+		return watcherAdapter.IsWatching(l.watcherName)
+	}
+	return false
+}
diff --git a/os/gcfg/gcfg_watcher_registry.go b/os/gcfg/gcfg_watcher_registry.go
new file mode 100644
index 000000000..c9f091ffd
--- /dev/null
+++ b/os/gcfg/gcfg_watcher_registry.go
@@ -0,0 +1,65 @@
+// 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 gcfg
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/internal/intlog"
+)
+
+// WatcherRegistry is a helper type for managing configuration watchers.
+// It provides a unified implementation of watcher management to avoid code duplication
+// across different adapter implementations.
+type WatcherRegistry struct {
+	watchers *gmap.KVMap[string, WatcherFunc] // Watchers map storing watcher callbacks.
+}
+
+// NewWatcherRegistry creates and returns a new WatcherRegistry instance.
+func NewWatcherRegistry() *WatcherRegistry {
+	return &WatcherRegistry{
+		watchers: gmap.NewKVMap[string, WatcherFunc](true),
+	}
+}
+
+// IsWatching checks whether the watcher with the specified name is registered.
+func (r *WatcherRegistry) IsWatching(name string) bool {
+	return r.watchers.Contains(name)
+}
+
+// Add adds a watcher with the specified name and callback function.
+func (r *WatcherRegistry) Add(name string, fn WatcherFunc) {
+	r.watchers.Set(name, fn)
+}
+
+// Remove removes the watcher with the specified name.
+func (r *WatcherRegistry) Remove(name string) {
+	r.watchers.Remove(name)
+}
+
+// GetNames returns all watcher names.
+func (r *WatcherRegistry) GetNames() []string {
+	return r.watchers.Keys()
+}
+
+// Notify notifies all registered watchers by calling their callback functions.
+// Each callback is executed in a separate goroutine with panic recovery to prevent
+// one watcher's panic from affecting others.
+func (r *WatcherRegistry) Notify(ctx context.Context) {
+	r.watchers.Iterator(func(k string, fn WatcherFunc) bool {
+		go func(k string, fn WatcherFunc, ctx context.Context) {
+			defer func() {
+				if r := recover(); r != nil {
+					intlog.Errorf(ctx, "watcher %s panic: %v", k, r)
+				}
+			}()
+			fn(ctx)
+		}(k, fn, ctx)
+		return true
+	})
+}
diff --git a/os/gcfg/gcfg_watcher_registry_test.go b/os/gcfg/gcfg_watcher_registry_test.go
new file mode 100644
index 000000000..a720e6b4b
--- /dev/null
+++ b/os/gcfg/gcfg_watcher_registry_test.go
@@ -0,0 +1,85 @@
+// 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 gcfg_test
+
+import (
+	"context"
+	"sync"
+	"testing"
+
+	"github.com/gogf/gf/v2/os/gcfg"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func TestWatcherRegistry_Basic(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		registry := gcfg.NewWatcherRegistry()
+
+		// Test Add and GetNames
+		var (
+			wg     sync.WaitGroup
+			called bool
+		)
+		wg.Add(1)
+		registry.Add("test-watcher", func(ctx context.Context) {
+			defer wg.Done()
+			called = true
+		})
+
+		names := registry.GetNames()
+		t.AssertEQ(len(names), 1)
+		t.AssertEQ(names[0], "test-watcher")
+
+		// Test Notify
+		registry.Notify(context.Background())
+		wg.Wait()
+		t.AssertEQ(called, true)
+
+		// Test Remove
+		registry.Remove("test-watcher")
+		names = registry.GetNames()
+		t.AssertEQ(len(names), 0)
+	})
+}
+
+func TestWatcherRegistry_MultipleWatchers(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		registry := gcfg.NewWatcherRegistry()
+
+		var (
+			wg                     sync.WaitGroup
+			count1, count2, count3 int
+		)
+		wg.Add(3)
+		registry.Add("watcher1", func(ctx context.Context) {
+			defer wg.Done()
+			count1++
+		})
+		registry.Add("watcher2", func(ctx context.Context) {
+			defer wg.Done()
+			count2++
+		})
+		registry.Add("watcher3", func(ctx context.Context) {
+			defer wg.Done()
+			count3++
+		})
+
+		names := registry.GetNames()
+		t.AssertEQ(len(names), 3)
+
+		registry.Notify(context.Background())
+		wg.Wait()
+		t.AssertEQ(count1, 1)
+		t.AssertEQ(count2, 1)
+		t.AssertEQ(count3, 1)
+
+		// Remove one watcher
+		registry.Remove("watcher2")
+		names = registry.GetNames()
+		t.AssertEQ(len(names), 2)
+	})
+}
diff --git a/os/gcfg/gcfg_z_unit_instance_test.go b/os/gcfg/gcfg_z_unit_instance_test.go
index 47bf3cbda..b286b2cd6 100644
--- a/os/gcfg/gcfg_z_unit_instance_test.go
+++ b/os/gcfg/gcfg_z_unit_instance_test.go
@@ -94,7 +94,7 @@ func Test_Instance_EnvPath(t *testing.T) {
 		t.Assert(Instance("c3") != nil, true)
 		t.Assert(Instance("c3").MustGet(ctx, "my-config"), "3")
 		t.Assert(Instance("c4").MustGet(ctx, "my-config"), "4")
-		localInstances = gmap.NewStrAnyMap(true)
+		localInstances = gmap.NewKVMapWithChecker[string, *Config](checker, true)
 	})
 }
 
@@ -105,6 +105,6 @@ func Test_Instance_EnvFile(t *testing.T) {
 		genv.Set("GF_GCFG_FILE", "c6.json")
 		defer genv.Set("GF_GCFG_FILE", "")
 		t.Assert(Instance().MustGet(ctx, "my-config"), "6")
-		localInstances = gmap.NewStrAnyMap(true)
+		localInstances = gmap.NewKVMapWithChecker[string, *Config](checker, true)
 	})
 }
diff --git a/os/gcfg/gcfg_z_unit_loader_test.go b/os/gcfg/gcfg_z_unit_loader_test.go
new file mode 100644
index 000000000..eb3c51f9c
--- /dev/null
+++ b/os/gcfg/gcfg_z_unit_loader_test.go
@@ -0,0 +1,345 @@
+// 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 gcfg_test
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/os/gcfg"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/guid"
+)
+
+// TestConfig is a test struct for configuration binding
+type TestConfig struct {
+	Name     string       `json:"name" yaml:"name"`
+	Age      int          `json:"age" yaml:"age"`
+	Enabled  bool         `json:"enabled" yaml:"enabled"`
+	Features []string     `json:"features" yaml:"features"`
+	Server   ServerConfig `json:"server" yaml:"server"`
+}
+
+// TestConfig2 is a test struct for configuration binding
+type TestConfig2 struct {
+	Name     string       `json:"name" yaml:"name"`
+	Age      int          `json:"age" yaml:"age"`
+	Enabled  bool         `json:"enabled" yaml:"enabled"`
+	Features string       `json:"features" yaml:"features"`
+	Server   ServerConfig `json:"server" yaml:"server"`
+}
+
+// TestConfig3 is a test struct for configuration binding
+type TestConfig3 struct {
+	Name     string       `json:"name" yaml:"name"`
+	Age      int          `json:"age" yaml:"age"`
+	Enabled  bool         `json:"enabled" yaml:"enabled"`
+	Features []string     `json:"features" yaml:"features"`
+	Server   ServerConfig `json:"server" yaml:"server"`
+	Other    string       `json:"other" yaml:"other"`
+}
+
+type ServerConfig struct {
+	Host string `json:"host" yaml:"host"`
+	Port int    `json:"port" yaml:"port"`
+}
+
+var configContent = `
+name: "test-app"
+age: 25
+enabled: true
+features: ["feature1", "feature2", "feature3"]
+server:
+  host: "localhost"
+  port: 8080
+`
+
+func TestLoader_Load(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			configFile = "./" + guid.S() + ".yaml"
+			err        = gfile.PutContents(configFile, configContent)
+		)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+
+		// Create loader
+		loader := gcfg.NewLoaderWithAdapter[TestConfig](cfg, "")
+
+		// Load configuration
+		err = loader.Load(context.Background())
+		t.AssertNil(err)
+		v := loader.Get()
+
+		// Check loaded values
+		t.Assert(v.Name, "test-app")
+		t.Assert(v.Age, 25)
+		t.Assert(v.Enabled, true)
+		t.Assert(v.Server.Host, "localhost")
+		t.Assert(v.Server.Port, 8080)
+		t.Assert(len(v.Features), 3)
+	})
+}
+
+func TestLoader_LoadWithDefaultValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			configFile = "./" + guid.S() + ".yaml"
+			err        = gfile.PutContents(configFile, configContent)
+		)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+
+		// Create target struct
+		var targetConfig TestConfig3
+		targetConfig.Other = "other"
+
+		// Create loader
+		loader := gcfg.NewLoaderWithAdapter(cfg, "", &targetConfig)
+		loader.SetReuseTargetStruct(true)
+
+		// Load configuration
+		err = loader.Load(context.Background())
+		t.AssertNil(err)
+		v := loader.Get()
+
+		// Check loaded values
+		t.Assert(v.Name, "test-app")
+		t.Assert(v.Age, 25)
+		t.Assert(v.Enabled, true)
+		t.Assert(v.Server.Host, "localhost")
+		t.Assert(v.Server.Port, 8080)
+		t.Assert(len(v.Features), 3)
+		t.Assert(v.Other, "other")
+	})
+}
+
+func TestLoader_LoadWithPropertyKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			configFile = "./" + guid.S() + ".yaml"
+			err        = gfile.PutContents(configFile, configContent)
+		)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+
+		// Create loader with specific property key
+		loader := gcfg.NewLoaderWithAdapter[ServerConfig](cfg, "server")
+
+		// Load configuration
+		err = loader.Load(context.Background())
+		t.AssertNil(err)
+		v := loader.Get()
+
+		// Check loaded values - only the app section should be loaded
+		t.Assert(v.Host, "localhost")
+		t.Assert(v.Port, 8080)
+	})
+}
+
+func TestLoader_WatchAndOnChange(t *testing.T) {
+	var configContent2 = `
+name: test-app-2
+age: 200
+enabled: true
+features: ["feature1", "feature2", "feature3"]
+server:
+  host: localhost
+  port: 8080
+`
+
+	gtest.C(t, func(t *gtest.T) {
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterContent(configContent)
+		t.AssertNil(err)
+
+		// Variable to track if callback was called
+		callbackCalled := gtype.NewBool(false)
+
+		// Create loader
+		loader := gcfg.NewLoaderWithAdapter[TestConfig](cfg, "")
+
+		// Set change callback
+		loader.OnChange(func(updated TestConfig) error {
+			callbackCalled.Set(true)
+			return nil
+		})
+
+		// Load configuration
+		err = loader.Load(context.Background())
+		t.AssertNil(err)
+		err = loader.Watch(context.Background(), "test-watcher")
+		t.AssertNil(err)
+		v := loader.Get()
+		t.Assert(v.Name, "test-app")
+		t.Assert(v.Age, 25)
+		err = cfg.SetContent(configContent2)
+		t.AssertNil(err)
+		time.Sleep(2 * time.Second)
+		v2 := loader.Get()
+		t.Assert(v2.Name, "test-app-2")
+		t.Assert(v2.Age, 200)
+		t.Assert(callbackCalled.Val(), true)
+	})
+}
+
+func TestLoader_SetConverter(t *testing.T) {
+	var configContent2 = `
+name: test-app-2
+age: 200
+enabled: true
+features: ["feature", "feature", "feature"]
+server:
+  host: localhost
+  port: 8080
+`
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			configFile = "./" + guid.S() + ".yaml"
+			err        = gfile.PutContents(configFile, configContent2)
+		)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+
+		// Create loader
+		loader := gcfg.NewLoaderWithAdapter[TestConfig2](cfg, "features")
+
+		// Set custom converter
+		loader.SetConverter(func(data any, target *TestConfig2) error {
+			s := gconv.Strings(data)
+			target.Features = strings.Join(s, ",")
+			return nil
+		})
+
+		// Load configuration
+		err = loader.Load(context.Background())
+		t.AssertNil(err)
+		v := loader.Get()
+
+		// Check converted values
+		t.Assert(v.Features, "feature,feature,feature")
+	})
+}
+
+func TestLoader_SetWatchErrorHandler(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a new config instance with content that will cause converter error
+		cfg, err := gcfg.NewAdapterContent(configContent)
+		t.AssertNil(err)
+
+		// Create loader
+		loader := gcfg.NewLoaderWithAdapter[TestConfig](cfg, "")
+
+		// Set error handler for watch operations
+		errorHandled := gtype.NewBool(false)
+		loader.SetWatchErrorHandler(func(ctx context.Context, err error) {
+			errorHandled.Set(true)
+		})
+
+		// Set a converter that will fail
+		loader.SetConverter(func(data any, target *TestConfig) error {
+			return errors.New("converter error")
+		})
+
+		// Load initially - this should return error without calling error handler
+		err = loader.Load(context.Background())
+		t.AssertNE(err, nil)
+		t.Assert(err.Error(), "converter error")
+		// Error handler should NOT be called during direct Load
+		t.Assert(errorHandled.Val(), false)
+
+		// Start watching - now errors during Load should trigger the error handler
+		err = loader.Watch(context.Background(), "test-error-handler")
+		t.AssertNil(err)
+		// Reset
+		errorHandled.Set(false)
+		// Trigger a config change - this will call Load internally and should trigger error handler
+		err = cfg.SetContent(configContent)
+		t.AssertNil(err)
+
+		// Wait for watcher to process the change
+		time.Sleep(1 * time.Second)
+
+		// Error handler should be called during Watch's Load
+		t.Assert(errorHandled.Val(), true)
+	})
+}
+
+func TestLoader_IsWatchingAndStopWatch(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterContent(configContent)
+		t.AssertNil(err)
+
+		// Create loader
+		loader := gcfg.NewLoaderWithAdapter[TestConfig](cfg, "")
+
+		// Initially, should not be watching
+		t.Assert(loader.IsWatching(), false)
+
+		// Load configuration
+		err = loader.Load(context.Background())
+		t.AssertNil(err)
+
+		// Start watching
+		err = loader.Watch(context.Background(), "test-stopwatch-watcher")
+		t.AssertNil(err)
+
+		// Now should be watching
+		t.Assert(loader.IsWatching(), true)
+
+		// Stop watching
+		stopped, err := loader.StopWatch(context.Background())
+		t.AssertNil(err)
+		t.Assert(stopped, true)
+
+		// Should not be watching anymore
+		t.Assert(loader.IsWatching(), false)
+	})
+}
+
+func TestLoader_StopWatchWithoutWatcher(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterContent(configContent)
+		t.AssertNil(err)
+
+		// Create loader without starting to watch
+		loader := gcfg.NewLoaderWithAdapter[TestConfig](cfg, "")
+
+		// Initially, should not be watching
+		t.Assert(loader.IsWatching(), false)
+
+		// Try to stop watching when not watching
+		stopped, err := loader.StopWatch(context.Background())
+		t.AssertNE(err, nil)
+		t.Assert(stopped, false)
+		t.Assert(err.Error(), "No watcher name specified")
+	})
+}
diff --git a/os/gcfg/gcfg_z_unit_watcher_test.go b/os/gcfg/gcfg_z_unit_watcher_test.go
new file mode 100644
index 000000000..4b6313f58
--- /dev/null
+++ b/os/gcfg/gcfg_z_unit_watcher_test.go
@@ -0,0 +1,273 @@
+// 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 gcfg_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/os/gcfg"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/guid"
+)
+
+func TestWatcher_File_Ctx(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			key1       = "test-ctx"
+			configFile = guid.S() + ".toml"
+			content1   = `key = "value1"`
+			content2   = `key = "value2"`
+		)
+		// Create config file.
+		err := gfile.PutContents(configFile, content1)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create config instance.
+		c, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+		c.Data(context.Background())
+		c.AddWatcher(key1, func(ctx context.Context) {
+			fileCtx := gcfg.GetAdapterFileCtx(ctx)
+			t.Assert(fileCtx.GetOperation(), gcfg.OperationWrite)
+			t.Assert(fileCtx.GetFileName(), configFile)
+			t.Assert(fileCtx.GetFilePath(), gfile.Abs(configFile))
+		})
+		gfile.PutContents(configFile, content2)
+		time.Sleep(1 * time.Second)
+		c.AddWatcher(key1, func(ctx context.Context) {
+			fileCtx := gcfg.GetAdapterFileCtx(ctx)
+			t.Assert(fileCtx.GetOperation(), gcfg.OperationSet)
+			t.Assert(fileCtx.GetKey(), "key")
+			t.Assert(fileCtx.GetValue().String(), "value2")
+		})
+		c.Set("key", "value2")
+		time.Sleep(1 * time.Second)
+		c.RemoveWatcher(key1)
+	})
+}
+
+func TestWatcher_AddWatcherAndNotify(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			m          = gmap.NewStrAnyMap(true)
+			key1       = "test-watcher1"
+			key2       = "test-watcher2"
+			configFile = guid.S() + ".toml"
+			content1   = `key = "value1"`
+			content2   = `key = "value2"`
+		)
+
+		// Create config file.
+		err := gfile.PutContents(configFile, content1)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create config instance.
+		c, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+		m.Set(key1, true)
+		m.Set(key2, true)
+
+		// Add watchers.
+		c.AddWatcher(key1, func(ctx context.Context) {
+			m.Set(key1, false)
+		})
+		c.AddWatcher(key2, func(ctx context.Context) {
+			m.Set(key2, false)
+		})
+
+		// Check initial values.
+		t.Assert(c.MustGet(ctx, "key").String(), "value1")
+		t.Assert(m.Get(key1), true)
+		t.Assert(m.Get(key2), true)
+
+		// Update config file content.
+		err = gfile.PutContents(configFile, content2)
+		t.AssertNil(err)
+
+		// Wait for watching notification.
+		time.Sleep(1 * time.Second)
+
+		// Check updated values.
+		t.Assert(c.MustGet(ctx, "key").String(), "value2")
+		t.AssertEQ(m.Get(key1), false)
+		t.AssertEQ(m.Get(key2), false)
+	})
+}
+
+func TestWatcher_RemoveWatcher(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			m          = gmap.NewStrAnyMap(true)
+			key1       = "test-watcher1"
+			key2       = "test-watcher2"
+			configFile = guid.S() + ".toml"
+			content1   = `key = "value1"`
+			content2   = `key = "value2"`
+		)
+		err := gfile.PutContents(configFile, content1)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create config instance.
+		c, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+		m.Set(key1, true)
+		m.Set(key2, true)
+
+		// Add watchers.
+		c.AddWatcher(key1, func(ctx context.Context) {
+			m.Set(key1, false)
+		})
+		c.AddWatcher(key2, func(ctx context.Context) {
+			m.Set(key2, false)
+		})
+
+		// Check initial values.
+		t.Assert(c.MustGet(ctx, "key").String(), "value1")
+		t.Assert(m.Get(key1), true)
+		t.Assert(m.Get(key2), true)
+
+		// Remove one watcher.
+		c.RemoveWatcher(key2)
+
+		// Update config file content.
+		err = gfile.PutContents(configFile, content2)
+		t.AssertNil(err)
+
+		// Wait for watching notification.
+		time.Sleep(1 * time.Second)
+
+		// Check updated values.
+		t.Assert(c.MustGet(ctx, "key").String(), "value2")
+		t.AssertEQ(m.Get(key1), false)
+		// watcherName2 should not be notified as it was removed
+		t.AssertEQ(m.Get(key2), true)
+	})
+}
+
+func TestWatcher_SetContentNotify(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			count    = gtype.NewInt(0)
+			key      = "test-watcher"
+			content1 = `key = "value1"`
+			content2 = `key = "value2"`
+		)
+
+		// Create config instance.
+		c, err := gcfg.NewAdapterContent(content1)
+		t.AssertNil(err)
+
+		// Add watcher.
+		c.AddWatcher(key, func(ctx context.Context) {
+			count.Add(1)
+		})
+
+		// Check initial values.
+		value, err := c.Get(ctx, "key")
+		t.AssertNil(err)
+		t.Assert(value, "value1")
+		t.Assert(count.Val(), 0)
+
+		// Set custom content.
+		c.SetContent(content2)
+
+		// Wait for watching notification.
+		time.Sleep(2 * time.Second)
+
+		// Check that watcher was notified
+		t.Assert(count.Val(), 1)
+		value2, err := c.Get(ctx, "key")
+		t.AssertNil(err)
+		t.Assert(value2, "value2")
+	})
+}
+
+func TestWatcher_RemoveContentNotify(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			count      = gtype.NewInt(0)
+			key        = "test-watcher"
+			configFile = guid.S() + ".toml"
+			content    = `key = "value1"`
+		)
+
+		// Create config file.
+		err := gfile.PutContents(configFile, content)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create config instance.
+		c, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+
+		// Add watcher.
+		c.AddWatcher(key, func(ctx context.Context) {
+			count.Add(1)
+		})
+
+		// Check initial values.
+		t.Assert(c.MustGet(ctx, "key").String(), "value1")
+		t.Assert(count.Val(), 0)
+
+		// Remove custom content.
+		c.RemoveContent(configFile)
+
+		// Wait for watching notification.
+		time.Sleep(1 * time.Second)
+
+		// Check that watcher was notified again
+		t.Assert(count.Val(), 1)
+		t.Assert(c.MustGet(ctx, "key").String(), "value1") // Back to file content
+	})
+}
+
+func TestWatcher_ClearContentNotify(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			count      = gtype.NewInt(0)
+			key        = "test-watcher"
+			configFile = guid.S() + ".toml"
+			content    = `key = "value1"`
+		)
+
+		// Create config file.
+		err := gfile.PutContents(configFile, content)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create config instance.
+		c, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+
+		// Add watcher.
+		c.AddWatcher(key, func(ctx context.Context) {
+			count.Add(1)
+		})
+
+		// Check initial values.
+		t.Assert(c.MustGet(ctx, "key").String(), "value1")
+		t.Assert(count.Val(), 0)
+
+		// Clear all custom content.
+		c.ClearContent()
+
+		// Wait for watching notification.
+		time.Sleep(1 * time.Second)
+
+		// Check that watcher was notified again
+		t.Assert(count.Val(), 1)
+		t.Assert(c.MustGet(ctx, "key").String(), "value1") // Back to file content
+	})
+}
diff --git a/os/gcron/gcron.go b/os/gcron/gcron.go
index 0e375185c..787bc85c5 100644
--- a/os/gcron/gcron.go
+++ b/os/gcron/gcron.go
@@ -125,3 +125,9 @@ func Stop(name ...string) {
 func StopGracefully() {
 	defaultCron.StopGracefully()
 }
+
+// StopGracefullyNonBlocking stops all running tasks gracefully without blocking,
+// returning a context that callers can use to wait for completion.
+func StopGracefullyNonBlocking() context.Context {
+	return defaultCron.StopGracefullyNonBlocking()
+}
diff --git a/os/gcron/gcron_cron.go b/os/gcron/gcron_cron.go
index c9bd97cdf..b8accf31f 100644
--- a/os/gcron/gcron_cron.go
+++ b/os/gcron/gcron_cron.go
@@ -20,11 +20,14 @@ import (
 
 // Cron stores all the cron job entries.
 type Cron struct {
-	idGen     *gtype.Int64    // Used for unique name generation.
-	status    *gtype.Int      // Timed task status(0: Not Start; 1: Running; 2: Stopped; -1: Closed)
-	entries   *gmap.StrAnyMap // All timed task entries.
-	logger    glog.ILogger    // Logger, it is nil in default.
-	jobWaiter sync.WaitGroup  // Graceful shutdown when cron jobs are stopped.
+	idGen       *gtype.Int64    // Used for unique name generation.
+	status      *gtype.Int      // Timed task status(0: Not Start; 1: Running; 2: Stopped; -1: Closed)
+	entries     *gmap.StrAnyMap // All timed task entries.
+	logger      glog.ILogger    // Logger, it is nil in default.
+	loggerMu    sync.RWMutex
+	jobWaiter   sync.WaitGroup // Graceful shutdown when cron jobs are stopped.
+	running     bool
+	runningLock sync.Mutex
 }
 
 // New returns a new Cron object with default settings.
@@ -33,16 +36,21 @@ func New() *Cron {
 		idGen:   gtype.NewInt64(),
 		status:  gtype.NewInt(StatusRunning),
 		entries: gmap.NewStrAnyMap(true),
+		running: true,
 	}
 }
 
 // SetLogger sets the logger for cron.
 func (c *Cron) SetLogger(logger glog.ILogger) {
+	c.loggerMu.Lock()
+	defer c.loggerMu.Unlock()
 	c.logger = logger
 }
 
 // GetLogger returns the logger in the cron.
 func (c *Cron) GetLogger() glog.ILogger {
+	c.loggerMu.RLock()
+	defer c.loggerMu.RUnlock()
 	return c.logger
 }
 
@@ -171,7 +179,10 @@ func (c *Cron) Start(name ...string) {
 			}
 		}
 	} else {
+		c.runningLock.Lock()
 		c.status.Set(StatusReady)
+		c.running = true
+		c.runningLock.Unlock()
 	}
 }
 
@@ -185,14 +196,32 @@ func (c *Cron) Stop(name ...string) {
 			}
 		}
 	} else {
+		c.runningLock.Lock()
 		c.status.Set(StatusStopped)
+		c.running = false
+		c.runningLock.Unlock()
 	}
 }
 
 // StopGracefully Blocks and waits all current running jobs done.
 func (c *Cron) StopGracefully() {
-	c.status.Set(StatusStopped)
-	c.jobWaiter.Wait()
+	ctx := c.StopGracefullyNonBlocking()
+	<-ctx.Done()
+}
+
+// StopGracefullyNonBlocking stops all running tasks gracefully without blocking,
+// returning a context that callers can use to wait for completion.
+func (c *Cron) StopGracefullyNonBlocking() context.Context {
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() {
+		c.runningLock.Lock()
+		defer c.runningLock.Unlock()
+		c.status.Set(StatusStopped)
+		c.running = false
+		c.jobWaiter.Wait()
+		cancel()
+	}()
+	return ctx
 }
 
 // Remove deletes scheduled task which named `name`.
@@ -204,7 +233,10 @@ func (c *Cron) Remove(name string) {
 
 // Close stops and closes current cron.
 func (c *Cron) Close() {
+	c.runningLock.Lock()
+	defer c.runningLock.Unlock()
 	c.status.Set(StatusClosed)
+	c.running = false
 }
 
 // Size returns the size of the timed tasks.
diff --git a/os/gcron/gcron_entry.go b/os/gcron/gcron_entry.go
index dd3ed72e6..842edfbf2 100644
--- a/os/gcron/gcron_entry.go
+++ b/os/gcron/gcron_entry.go
@@ -152,7 +152,15 @@ func (e *Entry) checkAndRun(ctx context.Context) {
 		e.Close()
 
 	case StatusReady, StatusRunning:
-		e.cron.jobWaiter.Add(1)
+		e.cron.runningLock.Lock()
+		if e.cron.running {
+			e.cron.jobWaiter.Add(1)
+		} else {
+			e.cron.runningLock.Unlock()
+			e.logDebugf(ctx, `cron job "%s" stoped or closed`, e.getJobNameWithPattern())
+			return
+		}
+		e.cron.runningLock.Unlock()
 		defer func() {
 			e.cron.jobWaiter.Done()
 			if exception := recover(); exception != nil {
diff --git a/os/gcron/gcron_z_example_1_test.go b/os/gcron/gcron_z_example_1_test.go
index 5aa635acc..538be7c35 100644
--- a/os/gcron/gcron_z_example_1_test.go
+++ b/os/gcron/gcron_z_example_1_test.go
@@ -31,7 +31,7 @@ func ExampleCron_gracefulShutdown() {
 		g.Log().Debug(ctx, "Every 2s job start")
 		time.Sleep(5 * time.Second)
 		g.Log().Debug(ctx, "Every 2s job after 5 second end")
-	}, "MyCronJob")
+	}, "MyCronJob1")
 	if err != nil {
 		panic(err)
 	}
@@ -46,3 +46,25 @@ func ExampleCron_gracefulShutdown() {
 	gcron.StopGracefully()
 	glog.Print(ctx, "All cron jobs completed")
 }
+
+func ExampleCron_StopGracefullyNonBlocking() {
+	_, err := gcron.Add(ctx, "*/2 * * * * *", func(ctx context.Context) {
+		g.Log().Debug(ctx, "Every 2s job start")
+		time.Sleep(5 * time.Second)
+		g.Log().Debug(ctx, "Every 2s job after 5 second end")
+	}, "MyCronJob2")
+	if err != nil {
+		panic(err)
+	}
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	sig := <-quit
+	glog.Printf(ctx, "Signal received: %s, stopping cron", sig)
+
+	glog.Print(ctx, "Waiting for all cron jobs to complete...")
+	ctx := gcron.StopGracefullyNonBlocking()
+	<-ctx.Done()
+	glog.Print(ctx, "All cron jobs completed")
+}
diff --git a/os/gcron/gcron_z_unit_entry_test.go b/os/gcron/gcron_z_unit_entry_test.go
index 62fa361ac..7a77df70c 100644
--- a/os/gcron/gcron_z_unit_entry_test.go
+++ b/os/gcron/gcron_z_unit_entry_test.go
@@ -22,10 +22,12 @@ func TestCron_Entry_Operations(t *testing.T) {
 			cron  = gcron.New()
 			array = garray.New(true)
 		)
-		cron.DelayAddTimes(ctx, 500*time.Millisecond, "* * * * * *", 2, func(ctx context.Context) {
-			array.Append(1)
-		})
-		t.Assert(cron.Size(), 0)
+		go func() {
+			cron.DelayAddTimes(ctx, 500*time.Millisecond, "* * * * * *", 2, func(ctx context.Context) {
+				array.Append(1)
+			})
+			t.Assert(cron.Size(), 0)
+		}()
 		time.Sleep(800 * time.Millisecond)
 		t.Assert(array.Len(), 0)
 		t.Assert(cron.Size(), 1)
@@ -39,12 +41,16 @@ func TestCron_Entry_Operations(t *testing.T) {
 			cron  = gcron.New()
 			array = garray.New(true)
 		)
-		entry, err1 := cron.Add(ctx, "* * * * * *", func(ctx context.Context) {
-			array.Append(1)
-		})
-		t.Assert(err1, nil)
-		t.Assert(array.Len(), 0)
-		t.Assert(cron.Size(), 1)
+		var entry *gcron.Entry
+		go func() {
+			var err error
+			entry, err = cron.Add(ctx, "* * * * * *", func(ctx context.Context) {
+				array.Append(1)
+			})
+			t.Assert(err, nil)
+			t.Assert(array.Len(), 0)
+			t.Assert(cron.Size(), 1)
+		}()
 		time.Sleep(1300 * time.Millisecond)
 		t.Assert(array.Len(), 1)
 		t.Assert(cron.Size(), 1)
diff --git a/os/gcron/gcron_z_unit_test.go b/os/gcron/gcron_z_unit_test.go
index 1f162d560..4d514b818 100644
--- a/os/gcron/gcron_z_unit_test.go
+++ b/os/gcron/gcron_z_unit_test.go
@@ -30,18 +30,23 @@ func TestCron_Add_Close(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		cron := gcron.New()
 		array := garray.New(true)
-		_, err1 := cron.Add(ctx, "* * * * * *", func(ctx context.Context) {
-			g.Log().Print(ctx, "cron1")
-			array.Append(1)
-		})
-		_, err2 := cron.Add(ctx, "* * * * * *", func(ctx context.Context) {
-			g.Log().Print(ctx, "cron2")
-			array.Append(1)
-		}, "test")
-		t.Assert(err1, nil)
-		t.Assert(err2, nil)
-		t.Assert(cron.Size(), 2)
+		g.Log().Debugf(ctx, "TestCron_Add_Close Add begin  Start time %v ", time.Now().UnixMilli())
+		go func() {
+			_, err1 := cron.Add(ctx, "* * * * * *", func(ctx context.Context) {
+				g.Log().Print(ctx, "cron1")
+				array.Append(1)
+			})
+			t.Assert(err1, nil)
+		}()
+		go func() {
+			_, err2 := cron.Add(ctx, "* * * * * *", func(ctx context.Context) {
+				g.Log().Print(ctx, "cron2")
+				array.Append(1)
+			}, "test")
+			t.Assert(err2, nil)
+		}()
 		time.Sleep(1300 * time.Millisecond)
+		t.Assert(cron.Size(), 2)
 		t.Assert(array.Len(), 2)
 		time.Sleep(1300 * time.Millisecond)
 		t.Assert(array.Len(), 4)
@@ -56,8 +61,8 @@ func TestCron_Add_Close(t *testing.T) {
 func TestCron_Basic(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		cron := gcron.New()
+		defer cron.Close()
 		cron.Add(ctx, "* * * * * *", func(ctx context.Context) {}, "add")
-		// fmt.Println("start", time.Now())
 		cron.DelayAdd(ctx, time.Second, "* * * * * *", func(ctx context.Context) {}, "delay_add")
 		t.Assert(cron.Size(), 1)
 		time.Sleep(1200 * time.Millisecond)
@@ -93,17 +98,25 @@ func TestCron_Remove(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		cron := gcron.New()
 		array := garray.New(true)
-		cron.Add(ctx, "* * * * * *", func(ctx context.Context) {
-			array.Append(1)
-		}, "add")
-		t.Assert(array.Len(), 0)
+		go func() {
+			cron.Add(ctx, "* * * * * *", func(ctx context.Context) {
+				array.Append(1)
+			}, "add")
+			t.Assert(array.Len(), 0)
+		}()
 		time.Sleep(1200 * time.Millisecond)
 		t.Assert(array.Len(), 1)
-
 		cron.Remove("add")
 		t.Assert(array.Len(), 1)
 		time.Sleep(1200 * time.Millisecond)
 		t.Assert(array.Len(), 1)
+		time.Sleep(1200 * time.Millisecond)
+		t.Assert(array.Len(), 1)
+		time.Sleep(1200 * time.Millisecond)
+		t.Assert(array.Len(), 1)
+		time.Sleep(1200 * time.Millisecond)
+		t.Assert(array.Len(), 1)
+
 	})
 }
 
@@ -122,17 +135,19 @@ func doTestCronAddFixedPattern(t *testing.T) {
 			expect = now.Add(time.Second * 2)
 		)
 		defer cron.Close()
-
 		var pattern = fmt.Sprintf(
 			`%d %d %d %d %d %s`,
 			expect.Second(), expect.Minute(), expect.Hour(), expect.Day(), expect.Month(), expect.Weekday().String(),
 		)
 		cron.SetLogger(g.Log())
-		g.Log().Debugf(ctx, `pattern: %s`, pattern)
-		_, err := cron.Add(ctx, pattern, func(ctx context.Context) {
-			array.Append(1)
-		})
-		t.AssertNil(err)
+		go func() {
+			g.Log().Debugf(ctx, `pattern: %s`, pattern)
+			_, err := cron.Add(ctx, pattern, func(ctx context.Context) {
+				g.Log().Debugf(ctx, `receive job`)
+				array.Append(1)
+			})
+			t.AssertNil(err)
+		}()
 		time.Sleep(3500 * time.Millisecond)
 		g.Log().Debug(ctx, `current time`)
 		t.Assert(array.Len(), 1)
@@ -143,9 +158,12 @@ func TestCron_AddSingleton(t *testing.T) {
 	// un used, can be removed
 	gtest.C(t, func(t *gtest.T) {
 		cron := gcron.New()
-		cron.Add(ctx, "* * * * * *", func(ctx context.Context) {}, "add")
-		cron.DelayAdd(ctx, time.Second, "* * * * * *", func(ctx context.Context) {}, "delay_add")
-		t.Assert(cron.Size(), 1)
+		defer cron.Close()
+		go func() {
+			cron.Add(ctx, "* * * * * *", func(ctx context.Context) {}, "add")
+			cron.DelayAdd(ctx, time.Second, "* * * * * *", func(ctx context.Context) {}, "delay_add")
+			t.Assert(cron.Size(), 1)
+		}()
 		time.Sleep(1200 * time.Millisecond)
 		t.Assert(cron.Size(), 2)
 
@@ -160,12 +178,15 @@ func TestCron_AddSingleton(t *testing.T) {
 	// keep this
 	gtest.C(t, func(t *gtest.T) {
 		cron := gcron.New()
+		defer cron.Close()
 		array := garray.New(true)
-		cron.AddSingleton(ctx, "* * * * * *", func(ctx context.Context) {
-			array.Append(1)
-			time.Sleep(50 * time.Second)
-		})
-		t.Assert(cron.Size(), 1)
+		go func() {
+			cron.AddSingleton(ctx, "* * * * * *", func(ctx context.Context) {
+				array.Append(1)
+				time.Sleep(50 * time.Second)
+			})
+			t.Assert(cron.Size(), 1)
+		}()
 		time.Sleep(3500 * time.Millisecond)
 		t.Assert(array.Len(), 1)
 	})
@@ -175,14 +196,17 @@ func TestCron_AddSingleton(t *testing.T) {
 func TestCron_AddOnce1(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		cron := gcron.New()
+		defer cron.Close()
 		array := garray.New(true)
-		cron.AddOnce(ctx, "* * * * * *", func(ctx context.Context) {
-			array.Append(1)
-		})
-		cron.AddOnce(ctx, "* * * * * *", func(ctx context.Context) {
-			array.Append(1)
-		})
-		t.Assert(cron.Size(), 2)
+		go func() {
+			cron.AddOnce(ctx, "* * * * * *", func(ctx context.Context) {
+				array.Append(1)
+			})
+			cron.AddOnce(ctx, "* * * * * *", func(ctx context.Context) {
+				array.Append(1)
+			})
+			t.Assert(cron.Size(), 2)
+		}()
 		time.Sleep(2500 * time.Millisecond)
 		t.Assert(array.Len(), 2)
 		t.Assert(cron.Size(), 0)
@@ -192,11 +216,14 @@ func TestCron_AddOnce1(t *testing.T) {
 func TestCron_AddOnce2(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		cron := gcron.New()
+		defer cron.Close()
 		array := garray.New(true)
-		cron.AddOnce(ctx, "@every 2s", func(ctx context.Context) {
-			array.Append(1)
-		})
-		t.Assert(cron.Size(), 1)
+		go func() {
+			cron.AddOnce(ctx, "@every 2s", func(ctx context.Context) {
+				array.Append(1)
+			})
+			t.Assert(cron.Size(), 1)
+		}()
 		time.Sleep(3000 * time.Millisecond)
 		t.Assert(array.Len(), 1)
 		t.Assert(cron.Size(), 0)
@@ -206,10 +233,13 @@ func TestCron_AddOnce2(t *testing.T) {
 func TestCron_AddTimes(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		cron := gcron.New()
+		defer cron.Close()
 		array := garray.New(true)
-		_, _ = cron.AddTimes(ctx, "* * * * * *", 2, func(ctx context.Context) {
-			array.Append(1)
-		})
+		go func() {
+			_, _ = cron.AddTimes(ctx, "* * * * * *", 2, func(ctx context.Context) {
+				array.Append(1)
+			})
+		}()
 		time.Sleep(3500 * time.Millisecond)
 		t.Assert(array.Len(), 2)
 		t.Assert(cron.Size(), 0)
@@ -219,11 +249,14 @@ func TestCron_AddTimes(t *testing.T) {
 func TestCron_DelayAdd(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		cron := gcron.New()
+		defer cron.Close()
 		array := garray.New(true)
-		cron.DelayAdd(ctx, 500*time.Millisecond, "* * * * * *", func(ctx context.Context) {
-			array.Append(1)
-		})
-		t.Assert(cron.Size(), 0)
+		go func() {
+			cron.DelayAdd(ctx, 500*time.Millisecond, "* * * * * *", func(ctx context.Context) {
+				array.Append(1)
+			})
+			t.Assert(cron.Size(), 0)
+		}()
 		time.Sleep(800 * time.Millisecond)
 		t.Assert(array.Len(), 0)
 		t.Assert(cron.Size(), 1)
@@ -236,12 +269,15 @@ func TestCron_DelayAdd(t *testing.T) {
 func TestCron_DelayAddSingleton(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		cron := gcron.New()
+		defer cron.Close()
 		array := garray.New(true)
-		cron.DelayAddSingleton(ctx, 500*time.Millisecond, "* * * * * *", func(ctx context.Context) {
-			array.Append(1)
-			time.Sleep(10 * time.Second)
-		})
-		t.Assert(cron.Size(), 0)
+		go func() {
+			cron.DelayAddSingleton(ctx, 500*time.Millisecond, "* * * * * *", func(ctx context.Context) {
+				array.Append(1)
+				time.Sleep(10 * time.Second)
+			})
+			t.Assert(cron.Size(), 0)
+		}()
 		time.Sleep(2200 * time.Millisecond)
 		t.Assert(array.Len(), 1)
 		t.Assert(cron.Size(), 1)
@@ -251,11 +287,14 @@ func TestCron_DelayAddSingleton(t *testing.T) {
 func TestCron_DelayAddOnce(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		cron := gcron.New()
+		defer cron.Close()
 		array := garray.New(true)
-		cron.DelayAddOnce(ctx, 500*time.Millisecond, "* * * * * *", func(ctx context.Context) {
-			array.Append(1)
-		})
-		t.Assert(cron.Size(), 0)
+		go func() {
+			cron.DelayAddOnce(ctx, 500*time.Millisecond, "* * * * * *", func(ctx context.Context) {
+				array.Append(1)
+			})
+			t.Assert(cron.Size(), 0)
+		}()
 		time.Sleep(800 * time.Millisecond)
 		t.Assert(array.Len(), 0)
 		t.Assert(cron.Size(), 1)
@@ -268,11 +307,14 @@ func TestCron_DelayAddOnce(t *testing.T) {
 func TestCron_DelayAddTimes(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		cron := gcron.New()
+		defer cron.Close()
 		array := garray.New(true)
-		cron.DelayAddTimes(ctx, 500*time.Millisecond, "* * * * * *", 2, func(ctx context.Context) {
-			array.Append(1)
-		})
-		t.Assert(cron.Size(), 0)
+		go func() {
+			cron.DelayAddTimes(ctx, 500*time.Millisecond, "* * * * * *", 2, func(ctx context.Context) {
+				array.Append(1)
+			})
+			t.Assert(cron.Size(), 0)
+		}()
 		time.Sleep(800 * time.Millisecond)
 		t.Assert(array.Len(), 0)
 		t.Assert(cron.Size(), 1)
@@ -284,27 +326,30 @@ func TestCron_DelayAddTimes(t *testing.T) {
 
 func TestCron_JobWaiter(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		var err error
 		s1 := garray.New(true)
 		s2 := garray.New(true)
-		_, err = gcron.Add(ctx, "* * * * * *", func(ctx context.Context) {
-			g.Log().Debug(ctx, "Every second")
-			s1.Append(struct{}{})
-		}, "MyFirstCronJob")
-		t.Assert(err, nil)
-		_, err = gcron.Add(ctx, "*/2 * * * * *", func(ctx context.Context) {
-			g.Log().Debug(ctx, "Every 2s job start")
-			time.Sleep(3 * time.Second)
-			s2.Append(struct{}{})
-			g.Log().Debug(ctx, "Every 2s job after 3 second end")
-		}, "MySecondCronJob")
-		t.Assert(err, nil)
-
 		quit := make(chan os.Signal, 1)
 		signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
-
+		cron := gcron.New()
+		defer cron.Close()
 		go func() {
-			time.Sleep(4 * time.Second) // Ensure that the job is triggered twice
+			_, err := cron.Add(ctx, "* * * * * *", func(ctx context.Context) {
+				g.Log().Debug(ctx, "Every second")
+				s1.Append(struct{}{})
+			}, "TestCronJobWaiterMyFirstCronJob")
+			t.Assert(err, nil)
+		}()
+		go func() {
+			_, err := cron.Add(ctx, "*/2 * * * * *", func(ctx context.Context) {
+				g.Log().Debug(ctx, "Every 2s job start")
+				time.Sleep(3 * time.Second)
+				s2.Append(struct{}{})
+				g.Log().Debug(ctx, "Every 2s job after 3 second end")
+			}, "TestCronJobMySecondCronJob")
+			t.Assert(err, nil)
+		}()
+		go func() {
+			time.Sleep(4300 * time.Millisecond) // Ensure that the job is triggered twice
 			glog.Print(ctx, "Sending SIGINT")
 			quit <- syscall.SIGINT // Send SIGINT
 		}()
@@ -312,10 +357,136 @@ func TestCron_JobWaiter(t *testing.T) {
 		sig := <-quit
 		glog.Printf(ctx, "Signal received: %s, stopping cron", sig)
 
-		glog.Print(ctx, "Waiting for all cron jobs to complete...")
-		gcron.StopGracefully()
+		glog.Print(ctx, "TestCron_JobWaiter Waiting for all cron jobs to complete...")
+		cron.StopGracefully()
 		glog.Print(ctx, "All cron jobs completed")
 		t.Assert(s1.Len(), 4)
 		t.Assert(s2.Len(), 2)
 	})
 }
+
+func TestCron_JobWaiterNonBlocking(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := garray.New(true)
+		s2 := garray.New(true)
+		quit := make(chan os.Signal, 1)
+		signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+		cron := gcron.New()
+		defer cron.Close()
+		go func() {
+			_, err := cron.Add(ctx, "* * * * * *", func(ctx context.Context) {
+				g.Log().Debug(ctx, "Every second start")
+				s1.Append(struct{}{})
+				g.Log().Debug(ctx, "Every second end ")
+			})
+			t.Assert(err, nil)
+		}()
+		go func() {
+			_, err := cron.Add(ctx, "*/2 * * * * *", func(ctx context.Context) {
+				g.Log().Debug(ctx, "Every 2s job start ")
+				time.Sleep(3 * time.Second)
+				s2.Append(struct{}{})
+				g.Log().Debug(ctx, "Every 2s job after 3 second end ")
+			})
+			t.Assert(err, nil)
+
+		}()
+		go func() {
+			time.Sleep(4300 * time.Millisecond) // Ensure that the job is triggered twice
+			glog.Print(ctx, "Sending SIGINT")
+			quit <- syscall.SIGINT // Send SIGINT
+		}()
+
+		sig := <-quit
+		glog.Printf(ctx, "Signal received: %s, stopping cron", sig)
+		glog.Print(ctx, "TestCron_JobWaiterNonBlocking Waiting for all cron jobs to complete...")
+		ctx := cron.StopGracefullyNonBlocking()
+		<-ctx.Done()
+		glog.Print(ctx, "All cron jobs completed")
+		t.Assert(s1.Len(), 4)
+		t.Assert(s2.Len(), 2)
+	})
+}
+
+func TestCron_NoneJobsDoneImmediately(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		cron := gcron.New()
+		defer cron.Close()
+
+		ctx := cron.StopGracefullyNonBlocking()
+		select {
+		case <-ctx.Done():
+		case <-time.After(110 * time.Millisecond):
+			t.Error("context was not done immediately")
+		}
+	})
+}
+
+func TestCron_RepeatedCallsStopGracefullyNonBlocking(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		cron := gcron.New()
+		defer cron.Close()
+
+		_ = cron.StopGracefullyNonBlocking()
+		ctx := cron.StopGracefullyNonBlocking()
+		select {
+		case <-ctx.Done():
+		case <-time.After(110 * time.Millisecond):
+			t.Error("context was not done immediately")
+		}
+	})
+}
+
+func TestCron_RepeatedCallsStopGracefullyNonBlocking2(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := garray.New(true)
+		s2 := garray.New(true)
+		cron := gcron.New()
+		defer cron.Close()
+		g.Log().Debugf(ctx, "TestCron_RepeatedCallsStopGracefullyNonBlocking2 Add begin  Start time %v ", time.Now().UnixMilli())
+		go func() {
+			_, err := cron.Add(ctx, "* * * * * *", func(ctx context.Context) {
+				g.Log().Debug(ctx, "Every second")
+				s1.Append(struct{}{})
+			})
+			t.Assert(err, nil)
+
+		}()
+		go func() {
+			_, err := cron.Add(ctx, "*/2 * * * * *", func(ctx context.Context) {
+				g.Log().Debug(ctx, "Every 2s job start")
+				time.Sleep(3 * time.Second)
+				s2.Append(struct{}{})
+				g.Log().Debug(ctx, "Every 2s job after 3 second end")
+			})
+			t.Assert(err, nil)
+		}()
+		time.Sleep(4300 * time.Millisecond)
+		g.Log().Debugf(ctx, "TestCron_RepeatedCallsStopGracefullyNonBlocking2 end time %v ", time.Now().UnixMilli())
+		glog.Print(ctx, "Waiting for all cron jobs to complete...")
+		_ = cron.StopGracefullyNonBlocking()
+		ctx := cron.StopGracefullyNonBlocking()
+		<-ctx.Done()
+		glog.Print(ctx, "All cron jobs completed")
+		t.Assert(s1.Len(), 4)
+		t.Assert(s2.Len(), 2)
+	})
+}
+
+func TestCron_StopGracefullyWithStopStart(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		cron := gcron.New()
+		defer cron.Close()
+		go func() {
+			_, err := cron.Add(ctx, "* * * * * *", func(ctx context.Context) {
+				g.Log().Debug(ctx, "Every second")
+			})
+			t.Assert(err, nil)
+		}()
+		time.Sleep(1300 * time.Millisecond)
+		cron.Stop()
+		cron.Start()
+		ctx := cron.StopGracefullyNonBlocking()
+		<-ctx.Done()
+	})
+}
diff --git a/os/gctx/gctx.go b/os/gctx/gctx.go
index 2a7e71113..1316c5452 100644
--- a/os/gctx/gctx.go
+++ b/os/gctx/gctx.go
@@ -52,6 +52,7 @@ func New() context.Context {
 }
 
 // WithCtx creates and returns a context containing context id upon given parent context `ctx`.
+//
 // Deprecated: use WithSpan instead.
 func WithCtx(ctx context.Context) context.Context {
 	if CtxId(ctx) != "" {
diff --git a/os/gfile/gfile_match.go b/os/gfile/gfile_match.go
new file mode 100644
index 000000000..c0f995703
--- /dev/null
+++ b/os/gfile/gfile_match.go
@@ -0,0 +1,266 @@
+// 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 gfile
+
+import (
+	"path"
+	"path/filepath"
+	"strings"
+)
+
+// MatchGlob reports whether name matches the shell pattern.
+// It extends filepath.Match (https://pkg.go.dev/path/filepath#Match)
+// with support for "**" (globstar) pattern, similar to bash's globstar
+// (https://www.gnu.org/software/bash/manual/html_node/The-Shopt-Builtin.html)
+// and gitignore patterns (https://git-scm.com/docs/gitignore#_pattern_format).
+//
+// Pattern syntax:
+//   - '*'         matches any sequence of non-separator characters
+//   - '**'        matches any sequence of characters including separators (globstar)
+//   - '?'         matches any single non-separator character
+//   - '[abc]'     matches any character in the bracket
+//   - '[a-z]'     matches any character in the range
+//   - '[^abc]'    matches any character not in the bracket (negation)
+//   - '[^a-z]'    matches any character not in the range (negation)
+//
+// Globstar rules:
+//   - "**" only has globstar semantics when it appears as a complete path component
+//     (e.g., "a/**/b", "**/a", "a/**", "**").
+//   - Patterns like "a**b" or "**a" treat "**" as two regular "*" wildcards,
+//     matching only within a single path component.
+//   - Both "/" and "\" are treated as path separators (cross-platform support).
+//
+// Error handling:
+//   - Returns an error for malformed patterns (e.g., unclosed brackets "[abc").
+//   - Errors from filepath.Match are propagated.
+//
+// Example:
+//
+//	MatchGlob("src/**/*.go", "src/foo/bar/main.go")  => true, nil
+//	MatchGlob("*.go", "main.go")                     => true, nil
+//	MatchGlob("**", "any/path/file.go")              => true, nil
+//	MatchGlob("a**b", "axxb")                        => true, nil  (** as two *)
+//	MatchGlob("a**b", "a/b")                         => false, nil (no separator match)
+//	MatchGlob("[abc]", "a")                          => true, nil
+//	MatchGlob("[", "a")                              => false, error (malformed)
+func MatchGlob(pattern, name string) (bool, error) {
+	// If no **, use standard filepath.Match
+	if !strings.Contains(pattern, "**") {
+		return filepath.Match(pattern, name)
+	}
+	return matchGlobstar(pattern, name)
+}
+
+// matchGlobstar handles patterns containing "**".
+func matchGlobstar(pattern, name string) (bool, error) {
+	// Normalize path separators to / (handle both Windows and Unix)
+	pattern = strings.ReplaceAll(pattern, "\\", "/")
+	name = strings.ReplaceAll(name, "\\", "/")
+
+	// Clean up paths (handles multiple slashes, . and ..)
+	// Using path.Clean for consistent cross-platform behavior with forward slashes
+	pattern = path.Clean(pattern)
+	name = path.Clean(name)
+
+	// Check if "**" appears as a valid globstar (complete path component).
+	// If not, treat "**" as two regular "*" wildcards.
+	if !hasValidGlobstar(pattern) {
+		// Replace "**" with a placeholder, then use filepath.Match
+		// Since filepath.Match treats "*" as matching non-separator chars,
+		// "**" is equivalent to "*" in terms of matching (both match any
+		// sequence of non-separator characters).
+		normalizedPattern := strings.ReplaceAll(pattern, "**", "*")
+		return filepath.Match(normalizedPattern, name)
+	}
+
+	return doMatchGlobstar(pattern, name)
+}
+
+// hasValidGlobstar checks if the pattern contains "**" as a valid globstar
+// (i.e., as a complete path component). Valid globstar patterns:
+//   - "**" (the entire pattern)
+//   - "**/" (at the start)
+//   - "/**" (at the end)
+//   - "/**/" (in the middle)
+func hasValidGlobstar(pattern string) bool {
+	// Check each occurrence of "**"
+	idx := 0
+	for {
+		pos := strings.Index(pattern[idx:], "**")
+		if pos == -1 {
+			return false
+		}
+		pos += idx
+
+		// Check if this "**" is a valid globstar
+		if isValidGlobstarAt(pattern, pos) {
+			return true
+		}
+
+		idx = pos + 2
+		if idx >= len(pattern) {
+			break
+		}
+	}
+	return false
+}
+
+// isValidGlobstarAt checks if the "**" at position pos is a valid globstar.
+// A valid globstar must be a complete path component:
+//   - At start: "**" or "**/"
+//   - At end: "/**"
+//   - In middle: "/**/"
+func isValidGlobstarAt(pattern string, pos int) bool {
+	// Check character before "**"
+	if pos > 0 && pattern[pos-1] != '/' {
+		return false
+	}
+
+	// Check character after "**"
+	endPos := pos + 2
+	if endPos < len(pattern) && pattern[endPos] != '/' {
+		return false
+	}
+
+	return true
+}
+
+// findValidGlobstar finds the first valid globstar in the pattern.
+// Returns the position or -1 if not found.
+func findValidGlobstar(pattern string) int {
+	idx := 0
+	for {
+		pos := strings.Index(pattern[idx:], "**")
+		if pos == -1 {
+			return -1
+		}
+		pos += idx
+
+		if isValidGlobstarAt(pattern, pos) {
+			return pos
+		}
+
+		idx = pos + 2
+		if idx >= len(pattern) {
+			break
+		}
+	}
+	return -1
+}
+
+// doMatchGlobstar recursively matches pattern with globstar support.
+// Uses memoization to avoid exponential time complexity with multiple "**" operators.
+func doMatchGlobstar(pattern, name string) (bool, error) {
+	memo := make(map[string]bool)
+	return doMatchGlobstarMemo(pattern, name, memo)
+}
+
+// doMatchGlobstarMemo is the memoized implementation of globstar matching.
+func doMatchGlobstarMemo(pattern, name string, memo map[string]bool) (bool, error) {
+	// Create cache key
+	cacheKey := pattern + "\x00" + name
+	if cached, ok := memo[cacheKey]; ok {
+		return cached, nil
+	}
+
+	result, err := doMatchGlobstarCore(pattern, name, memo)
+	if err != nil {
+		return false, err
+	}
+
+	memo[cacheKey] = result
+	return result, nil
+}
+
+// doMatchGlobstarCore contains the core matching logic.
+func doMatchGlobstarCore(pattern, name string, memo map[string]bool) (bool, error) {
+	// Find the first valid globstar
+	pos := findValidGlobstar(pattern)
+	if pos == -1 {
+		// No valid globstar, use standard match
+		// Replace any "**" with "*" since they're not valid globstars
+		normalizedPattern := strings.ReplaceAll(pattern, "**", "*")
+		return filepath.Match(normalizedPattern, name)
+	}
+
+	// Split pattern at the valid globstar position
+	prefix := pattern[:pos]
+	suffix := pattern[pos+2:]
+
+	// Remove trailing slash from prefix
+	prefix = strings.TrimSuffix(prefix, "/")
+	// Remove leading slash from suffix
+	suffix = strings.TrimPrefix(suffix, "/")
+
+	// Match prefix
+	if prefix != "" {
+		// Check if name starts with prefix pattern
+		if !strings.Contains(prefix, "*") && !strings.Contains(prefix, "?") && !strings.Contains(prefix, "[") {
+			// Prefix is literal, check directly against full path component
+			if !strings.HasPrefix(name, prefix) {
+				return false, nil
+			}
+			if len(name) == len(prefix) {
+				// Name is exactly the prefix
+				name = ""
+			} else {
+				// Ensure the prefix ends at a path separator boundary
+				if name[len(prefix)] != '/' {
+					return false, nil
+				}
+				// Skip the separator as well
+				name = name[len(prefix)+1:]
+			}
+		} else {
+			// Prefix contains wildcards, need to match each segment
+			prefixParts := strings.Split(prefix, "/")
+			nameParts := strings.Split(name, "/")
+
+			if len(nameParts) < len(prefixParts) {
+				return false, nil
+			}
+
+			for i, pp := range prefixParts {
+				matched, err := filepath.Match(pp, nameParts[i])
+				if err != nil {
+					return false, err
+				}
+				if !matched {
+					return false, nil
+				}
+			}
+			name = strings.Join(nameParts[len(prefixParts):], "/")
+		}
+	}
+
+	// If suffix is empty, "**" matches everything remaining
+	if suffix == "" {
+		return true, nil
+	}
+
+	// Try matching "**" with 0 to N path segments
+	if name == "" {
+		// No remaining name, check if suffix can match empty
+		return doMatchGlobstarMemo(suffix, "", memo)
+	}
+
+	nameParts := strings.Split(name, "/")
+
+	// Try "**" matching 0, 1, 2, ... N segments
+	for i := 0; i <= len(nameParts); i++ {
+		remaining := strings.Join(nameParts[i:], "/")
+		matched, err := doMatchGlobstarMemo(suffix, remaining, memo)
+		if err != nil {
+			return false, err
+		}
+		if matched {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
diff --git a/os/gfile/gfile_z_unit_cache_test.go b/os/gfile/gfile_z_unit_cache_test.go
index b77b8610b..eebebc98c 100644
--- a/os/gfile/gfile_z_unit_cache_test.go
+++ b/os/gfile/gfile_z_unit_cache_test.go
@@ -84,3 +84,62 @@ func Test_GetContentsWithCache(t *testing.T) {
 		}
 	})
 }
+
+func Test_GetBytesWithCache(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var f *os.File
+		var err error
+		fileName := "test_bytes"
+		byteContent := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f} // "Hello"
+
+		if !gfile.Exists(fileName) {
+			f, err = os.CreateTemp("", fileName)
+			if err != nil {
+				t.Error("create file fail")
+			}
+		}
+
+		defer f.Close()
+		defer os.Remove(f.Name())
+
+		if gfile.Exists(f.Name()) {
+			err = gfile.PutBytes(f.Name(), byteContent)
+			if err != nil {
+				t.Error("write error", err)
+			}
+
+			// Test GetBytesWithCache with custom duration
+			cache := gfile.GetBytesWithCache(f.Name(), time.Second*1)
+			t.Assert(cache, byteContent)
+
+			// Test cache hit - should return same content
+			cache2 := gfile.GetBytesWithCache(f.Name(), time.Second*1)
+			t.Assert(cache2, byteContent)
+		}
+	})
+
+	// Test with non-existent file
+	gtest.C(t, func(t *gtest.T) {
+		cache := gfile.GetBytesWithCache("/nonexistent_file_12345.txt")
+		t.Assert(cache, nil)
+	})
+
+	// Test with empty file
+	gtest.C(t, func(t *gtest.T) {
+		var f *os.File
+		var err error
+		fileName := "test_bytes_empty"
+
+		f, err = os.CreateTemp("", fileName)
+		if err != nil {
+			t.Error("create file fail")
+		}
+
+		defer f.Close()
+		defer os.Remove(f.Name())
+
+		// Read empty file
+		cache := gfile.GetBytesWithCache(f.Name(), time.Second*1)
+		t.Assert(len(cache), 0)
+	})
+}
diff --git a/os/gfile/gfile_z_unit_match_test.go b/os/gfile/gfile_z_unit_match_test.go
new file mode 100644
index 000000000..02d9d800e
--- /dev/null
+++ b/os/gfile/gfile_z_unit_match_test.go
@@ -0,0 +1,600 @@
+// 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 gfile_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_MatchGlob_Basic(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Basic glob patterns (no **)
+		matched, err := gfile.MatchGlob("*.go", "main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("*.go", "main.txt")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		matched, err = gfile.MatchGlob("test_*.go", "test_main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("?est.go", "test.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("[abc].go", "a.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("[a-z].go", "x.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_Globstar(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// ** matches everything
+		matched, err := gfile.MatchGlob("**", "any/path/to/file.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("**", "file.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("**", "")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_GlobstarWithSuffix(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// **/*.go - matches .go files in any directory
+		matched, err := gfile.MatchGlob("**/*.go", "main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("**/*.go", "src/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("**/*.go", "src/foo/bar/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("**/*.go", "src/main.txt")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+	})
+}
+
+func Test_MatchGlob_GlobstarWithPrefix(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// src/** - matches everything under src/
+		matched, err := gfile.MatchGlob("src/**", "src/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("src/**", "src/foo/bar/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("src/**", "other/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+	})
+}
+
+func Test_MatchGlob_GlobstarWithPrefixAndSuffix(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// src/**/*.go - matches .go files under src/
+		matched, err := gfile.MatchGlob("src/**/*.go", "src/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("src/**/*.go", "src/foo/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("src/**/*.go", "src/foo/bar/baz/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("src/**/*.go", "src/main.txt")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		matched, err = gfile.MatchGlob("src/**/*.go", "other/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+	})
+}
+
+func Test_MatchGlob_GlobstarMultiple(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Multiple ** in pattern
+		matched, err := gfile.MatchGlob("src/**/test/**/*.go", "src/foo/test/bar/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("src/**/test/**/*.go", "src/test/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("src/**/test/**/*.go", "src/a/b/test/c/d/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_GlobstarEdgeCases(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// ** at the beginning
+		matched, err := gfile.MatchGlob("**/main.go", "main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("**/main.go", "src/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("**/main.go", "src/foo/bar/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// Hidden directories
+		matched, err = gfile.MatchGlob(".*", ".git")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob(".*", ".vscode")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("_*", "_test")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_WindowsPath(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Windows-style paths should also work
+		matched, err := gfile.MatchGlob("src/**/*.go", "src\\foo\\main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("src\\**\\*.go", "src/foo/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_InvalidGlobstar(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// "**" not as complete path component should be treated as two "*"
+		// "a**b" should match "ab", "axb", "axxb", etc. (but not "a/b")
+		matched, err := gfile.MatchGlob("a**b", "ab")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("a**b", "axb")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("a**b", "axxb")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("a**b", "axxxb")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// "a**b" should NOT match paths with separators
+		matched, err = gfile.MatchGlob("a**b", "a/b")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		matched, err = gfile.MatchGlob("a**b", "ax/yb")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		// "**a" at start (not valid globstar)
+		matched, err = gfile.MatchGlob("**a", "a")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("**a", "xa")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("**a", "xxa")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// "a**" at end (not valid globstar)
+		matched, err = gfile.MatchGlob("a**", "a")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("a**", "ax")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("a**", "axx")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// Mixed valid and invalid globstars
+		// "src/**a" - "**" is valid globstar, "a" is suffix
+		matched, err = gfile.MatchGlob("src/**/a", "src/foo/a")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("src/**/a", "src/a")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_PrefixBoundary(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// "abc/**" should NOT match "abcdef/file.go" (prefix must be complete path component)
+		matched, err := gfile.MatchGlob("abc/**", "abcdef/file.go")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		// "abc/**" should match "abc/file.go"
+		matched, err = gfile.MatchGlob("abc/**", "abc/file.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// "abc/**" should match "abc/def/file.go"
+		matched, err = gfile.MatchGlob("abc/**", "abc/def/file.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// "abc/**" should match "abc" (prefix equals name)
+		matched, err = gfile.MatchGlob("abc/**", "abc")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// "src/foo/**" should NOT match "src/foobar/file.go"
+		matched, err = gfile.MatchGlob("src/foo/**", "src/foobar/file.go")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		// "src/foo/**" should match "src/foo/bar/file.go"
+		matched, err = gfile.MatchGlob("src/foo/**", "src/foo/bar/file.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_MultipleGlobstars(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test with multiple ** operators - this would be slow without memoization
+		matched, err := gfile.MatchGlob("a/**/b/**/c/**/d.go", "a/x/y/b/z/c/w/d.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("a/**/b/**/c/**/d.go", "a/b/c/d.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("a/**/b/**/c/**/d.go", "a/1/2/3/b/4/5/c/6/d.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("a/**/b/**/c/**/d.go", "a/b/c/e.go")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		// Deep nesting test
+		matched, err = gfile.MatchGlob("**/*.go", "a/b/c/d/e/f/g/h/i/j/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_MalformedPatterns(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Unclosed bracket - should return error
+		_, err := gfile.MatchGlob("[", "a")
+		t.AssertNE(err, nil)
+
+		_, err = gfile.MatchGlob("[abc", "a")
+		t.AssertNE(err, nil)
+
+		_, err = gfile.MatchGlob("[[", "a")
+		t.AssertNE(err, nil)
+
+		// Malformed patterns with globstar - errors should propagate
+		_, err = gfile.MatchGlob("**/[", "a/b")
+		t.AssertNE(err, nil)
+
+		_, err = gfile.MatchGlob("[/**", "a/b")
+		t.AssertNE(err, nil)
+
+		_, err = gfile.MatchGlob("a/**/[abc", "a/b/c")
+		t.AssertNE(err, nil)
+
+		// Malformed pattern in prefix with wildcards
+		_, err = gfile.MatchGlob("[a/**/b", "a/x/b")
+		t.AssertNE(err, nil)
+
+		// Invalid escape sequence on non-Windows (backslash at end)
+		// Note: behavior may vary by platform
+		_, err = gfile.MatchGlob("test\\", "test")
+		// On Unix, this might not error but won't match
+		// The key is it shouldn't panic
+
+		// Valid patterns should still work
+		matched, err := gfile.MatchGlob("[abc]", "a")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("[a-z]", "m")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// Note: filepath.Match uses [^...] for negation, not [!...]
+		matched, err = gfile.MatchGlob("[^abc]", "d")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("[^a-z]", "1")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_MemoizationCache(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test cases that exercise memoization cache hits
+		// Multiple ** with same suffix patterns will trigger cache reuse
+		matched, err := gfile.MatchGlob("a/**/b/**/c", "a/x/b/y/c")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// This pattern creates multiple paths that converge to same subproblems
+		matched, err = gfile.MatchGlob("**/a/**/a", "x/a/y/a")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// Deep recursion with cache hits
+		matched, err = gfile.MatchGlob("**/**/**", "a/b/c")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_InvalidGlobstarAtEnd(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Pattern where "**" appears at the very end of string (idx >= len(pattern) after pos+2)
+		// "x**" - invalid globstar at end, should be treated as two "*"
+		matched, err := gfile.MatchGlob("x**", "x")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("x**", "xyz")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// Pattern ending with invalid globstar that exhausts the string
+		matched, err = gfile.MatchGlob("abc**", "abc")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("abc**", "abcdef")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_PrefixWithWildcards(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Prefix contains wildcards - tests lines 220-236
+		// Pattern: "s*c/**/file.go" - prefix "s*c" contains wildcard
+		matched, err := gfile.MatchGlob("s*c/**/*.go", "src/foo/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("s?c/**/*.go", "src/foo/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// Test line 223-225: name has fewer segments than prefix
+		matched, err = gfile.MatchGlob("a/b/c/**", "a/b")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		matched, err = gfile.MatchGlob("a/b/c/**/d", "a")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		// Test line 232-234: wildcard prefix doesn't match
+		matched, err = gfile.MatchGlob("x*c/**/*.go", "src/foo/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		matched, err = gfile.MatchGlob("s?x/**/*.go", "src/foo/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		// Test line 236: name update after prefix match
+		matched, err = gfile.MatchGlob("a*/b*/**/*.go", "abc/bcd/efg/main.go")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_EmptyNameWithSuffix(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test line 246-249: name becomes empty after prefix match, check if suffix can match empty
+		// "abc/**" with name "abc" - after prefix match, name is empty
+		matched, err := gfile.MatchGlob("abc/**/", "abc")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// "abc/**/d" with name "abc" - after prefix match, name is empty but suffix is "d"
+		matched, err = gfile.MatchGlob("abc/**/d", "abc")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		// Test with wildcard prefix that exactly matches
+		matched, err = gfile.MatchGlob("a*c/**/x", "abc")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+	})
+}
+
+func Test_MatchGlob_FindValidGlobstarExhaust(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test lines 147-152: findValidGlobstar exhausts pattern without finding valid globstar
+		// Pattern with multiple invalid "**" that ends exactly at pattern length
+		matched, err := gfile.MatchGlob("a**b**", "ab")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("x**y**z", "xyz")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// Pattern where last "**" is at the very end but invalid
+		matched, err = gfile.MatchGlob("test**", "test")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("test**", "testing")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_CacheHit(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test line 166-168: cache hit scenario
+		// Pattern that creates overlapping subproblems triggering cache hits
+		// "**/**" with multiple segments will have cache hits
+		matched, err := gfile.MatchGlob("**/x/**/x", "a/x/b/x")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// This pattern specifically creates cache hits due to overlapping subproblems
+		// when trying different combinations of ** matching
+		matched, err = gfile.MatchGlob("**/a/**/b/**/a", "x/a/y/b/z/a")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// Pattern with repeated suffix that will be checked multiple times
+		matched, err = gfile.MatchGlob("**/**/test", "a/b/c/test")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// Pattern that will cause same subproblem to be solved multiple times
+		// "**/**/**" matching "a/b/c/d" will have many overlapping subproblems
+		matched, err = gfile.MatchGlob("**/**/**/**", "a/b/c/d/e")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_WildcardPrefixShortName(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test line 223-225: prefix with wildcards, name has fewer segments
+		// Pattern: "a*/b*/**/c" - prefix "a*/b*" has 2 segments
+		// Name: "ax" - only 1 segment
+		matched, err := gfile.MatchGlob("a*/b*/**/c", "ax")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		// Pattern: "?/b/c/**/d" - prefix "?/b/c" has 3 segments
+		// Name: "x/y" - only 2 segments
+		matched, err = gfile.MatchGlob("?/b/c/**/d", "x/y")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		// Pattern: "[abc]/[def]/**/x" - prefix has 2 segments with brackets
+		// Name: "a" - only 1 segment
+		matched, err = gfile.MatchGlob("[abc]/[def]/**/x", "a")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+	})
+}
+
+func Test_MatchGlob_InvalidGlobstarInSuffix(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test lines 147-152: findValidGlobstar exhausts pattern in recursive call
+		// Pattern "a/**/b**" - first "**" is valid, suffix "b**" has invalid "**" at end
+		// When matching suffix "b**", findValidGlobstar will iterate and find "**" is invalid,
+		// then idx = pos + 2 = 3, len("b**") = 3, so idx >= len(pattern) triggers break
+		matched, err := gfile.MatchGlob("a/**/b**", "a/x/bcd")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		matched, err = gfile.MatchGlob("a/**/b**", "a/x/b")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// Pattern with valid globstar followed by suffix with invalid globstar at end
+		matched, err = gfile.MatchGlob("x/**/y**z", "x/a/yabcz")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+
+		// Multiple invalid globstars in suffix
+		matched, err = gfile.MatchGlob("a/**/x**y**", "a/b/xcy")
+		t.AssertNil(err)
+		t.Assert(matched, true)
+	})
+}
+
+func Test_MatchGlob_MemoizationCacheHit(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test line 166-168: cache hit scenario
+		// To trigger cache hit, we need:
+		// 1. Same (pattern, name) pair called twice
+		// 2. First call must complete (not return early)
+		// 3. This happens when matching FAILS and we try all combinations
+
+		// Pattern "**/**/z" with name "a/b/c/d" (no match)
+		// First ** tries 0,1,2,3,4 segments
+		// For each, second ** tries all remaining combinations
+		// This creates overlapping subproblems that fail:
+		// - ("**/z", "a/b/c/d"), ("**/z", "b/c/d"), ("**/z", "c/d"), ("**/z", "d"), ("**/z", "")
+		// - ("z", "a/b/c/d"), ("z", "b/c/d"), ("z", "c/d"), ("z", "d"), ("z", "")
+		// When first ** matches 0: check ("**/z", "a/b/c/d")
+		//   -> second ** matches 0: check ("z", "a/b/c/d") - false, cached
+		//   -> second ** matches 1: check ("z", "b/c/d") - false, cached
+		//   -> second ** matches 2: check ("z", "c/d") - false, cached
+		//   -> second ** matches 3: check ("z", "d") - false, cached
+		//   -> second ** matches 4: check ("z", "") - false, cached
+		// When first ** matches 1: check ("**/z", "b/c/d")
+		//   -> second ** matches 0: check ("z", "b/c/d") - CACHE HIT!
+		matched, err := gfile.MatchGlob("**/**/z", "a/b/c/d")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		// Another failing pattern that creates cache hits
+		matched, err = gfile.MatchGlob("**/**/**/notexist", "a/b/c/d/e")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+
+		// Pattern with same suffix appearing multiple times in recursion (failing case)
+		matched, err = gfile.MatchGlob("**/x/**/x/**/x", "a/b/c/d/e/f")
+		t.AssertNil(err)
+		t.Assert(matched, false)
+	})
+}
diff --git a/os/gfile/gfile_z_unit_replace_test.go b/os/gfile/gfile_z_unit_replace_test.go
new file mode 100644
index 000000000..d3877970a
--- /dev/null
+++ b/os/gfile/gfile_z_unit_replace_test.go
@@ -0,0 +1,246 @@
+// 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 gfile_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+func Test_ReplaceFile(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			fileName = "/testfile_replace_" + gconv.String(gtime.TimestampNano()) + ".txt"
+			content  = "hello world"
+		)
+		createTestFile(fileName, content)
+		defer delTestFiles(fileName)
+
+		// Test basic replacement
+		err := gfile.ReplaceFile("world", "gf", testpath()+fileName)
+		t.AssertNil(err)
+		t.Assert(gfile.GetContents(testpath()+fileName), "hello gf")
+
+		// Test replacement with non-existent search string
+		err = gfile.ReplaceFile("notexist", "replaced", testpath()+fileName)
+		t.AssertNil(err)
+		t.Assert(gfile.GetContents(testpath()+fileName), "hello gf")
+
+		// Test multiple occurrences replacement
+		err = gfile.PutContents(testpath()+fileName, "hello hello hello")
+		t.AssertNil(err)
+		err = gfile.ReplaceFile("hello", "hi", testpath()+fileName)
+		t.AssertNil(err)
+		t.Assert(gfile.GetContents(testpath()+fileName), "hi hi hi")
+	})
+}
+
+func Test_ReplaceFileFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			fileName = "/testfile_replacefunc_" + gconv.String(gtime.TimestampNano()) + ".txt"
+			content  = "hello world"
+		)
+		createTestFile(fileName, content)
+		defer delTestFiles(fileName)
+
+		// Test replacement with callback function
+		err := gfile.ReplaceFileFunc(func(path, content string) string {
+			t.Assert(gfile.Basename(path), gfile.Basename(fileName))
+			return content + " - modified"
+		}, testpath()+fileName)
+		t.AssertNil(err)
+		t.Assert(gfile.GetContents(testpath()+fileName), "hello world - modified")
+	})
+
+	// Test when callback returns same content (no write should happen)
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			fileName = "/testfile_replacefunc2_" + gconv.String(gtime.TimestampNano()) + ".txt"
+			content  = "unchanged content"
+		)
+		createTestFile(fileName, content)
+		defer delTestFiles(fileName)
+
+		err := gfile.ReplaceFileFunc(func(path, content string) string {
+			return content // Return same content
+		}, testpath()+fileName)
+		t.AssertNil(err)
+		t.Assert(gfile.GetContents(testpath()+fileName), "unchanged content")
+	})
+
+	// Test callback with path parameter
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			fileName = "/testfile_replacefunc3_" + gconv.String(gtime.TimestampNano()) + ".txt"
+			content  = "test content"
+		)
+		createTestFile(fileName, content)
+		defer delTestFiles(fileName)
+
+		var receivedPath string
+		err := gfile.ReplaceFileFunc(func(path, content string) string {
+			receivedPath = path
+			return "new content"
+		}, testpath()+fileName)
+		t.AssertNil(err)
+		t.Assert(receivedPath, testpath()+fileName)
+		t.Assert(gfile.GetContents(testpath()+fileName), "new content")
+	})
+}
+
+func Test_ReplaceDir(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			dirName  = "/testdir_replace_" + gconv.String(gtime.TimestampNano())
+			fileName = dirName + "/test.txt"
+			content  = "hello world"
+		)
+		createDir(dirName)
+		createTestFile(fileName, content)
+		defer delTestFiles(dirName)
+
+		// Test directory replacement with pattern
+		err := gfile.ReplaceDir("world", "gf", testpath()+dirName, "*.txt")
+		t.AssertNil(err)
+		t.Assert(gfile.GetContents(testpath()+fileName), "hello gf")
+	})
+
+	// Test recursive replacement
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			dirName    = "/testdir_replace_recursive_" + gconv.String(gtime.TimestampNano())
+			subDirName = dirName + "/subdir"
+			fileName1  = dirName + "/test1.txt"
+			fileName2  = subDirName + "/test2.txt"
+			content    = "hello world"
+		)
+		createDir(dirName)
+		createDir(subDirName)
+		createTestFile(fileName1, content)
+		createTestFile(fileName2, content)
+		defer delTestFiles(dirName)
+
+		// Non-recursive replacement
+		err := gfile.ReplaceDir("world", "gf", testpath()+dirName, "*.txt", false)
+		t.AssertNil(err)
+		t.Assert(gfile.GetContents(testpath()+fileName1), "hello gf")
+		t.Assert(gfile.GetContents(testpath()+fileName2), "hello world") // Should not be changed
+
+		// Reset content
+		err = gfile.PutContents(testpath()+fileName1, content)
+		t.AssertNil(err)
+
+		// Recursive replacement
+		err = gfile.ReplaceDir("world", "gf", testpath()+dirName, "*.txt", true)
+		t.AssertNil(err)
+		t.Assert(gfile.GetContents(testpath()+fileName1), "hello gf")
+		t.Assert(gfile.GetContents(testpath()+fileName2), "hello gf")
+	})
+
+	// Test with pattern matching
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			dirName   = "/testdir_replace_pattern_" + gconv.String(gtime.TimestampNano())
+			fileName1 = dirName + "/test.txt"
+			fileName2 = dirName + "/test.log"
+			content   = "hello world"
+		)
+		createDir(dirName)
+		createTestFile(fileName1, content)
+		createTestFile(fileName2, content)
+		defer delTestFiles(dirName)
+
+		// Only replace in .txt files
+		err := gfile.ReplaceDir("world", "gf", testpath()+dirName, "*.txt")
+		t.AssertNil(err)
+		t.Assert(gfile.GetContents(testpath()+fileName1), "hello gf")
+		t.Assert(gfile.GetContents(testpath()+fileName2), "hello world") // .log should not be changed
+	})
+
+	// Test with non-existent directory
+	gtest.C(t, func(t *gtest.T) {
+		err := gfile.ReplaceDir("search", "replace", "/nonexistent_dir_12345", "*.txt")
+		t.AssertNE(err, nil)
+	})
+}
+
+func Test_ReplaceDirFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			dirName   = "/testdir_replacefunc_" + gconv.String(gtime.TimestampNano())
+			fileName1 = dirName + "/test1.txt"
+			fileName2 = dirName + "/test2.txt"
+			content1  = "content1"
+			content2  = "content2"
+		)
+		createDir(dirName)
+		createTestFile(fileName1, content1)
+		createTestFile(fileName2, content2)
+		defer delTestFiles(dirName)
+
+		// Test directory replacement with callback function
+		processedFiles := make(map[string]bool)
+		err := gfile.ReplaceDirFunc(func(path, content string) string {
+			processedFiles[gfile.Basename(path)] = true
+			return content + " - modified"
+		}, testpath()+dirName, "*.txt")
+		t.AssertNil(err)
+		t.Assert(gfile.GetContents(testpath()+fileName1), "content1 - modified")
+		t.Assert(gfile.GetContents(testpath()+fileName2), "content2 - modified")
+		t.Assert(processedFiles["test1.txt"], true)
+		t.Assert(processedFiles["test2.txt"], true)
+	})
+
+	// Test recursive replacement with callback
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			dirName    = "/testdir_replacefunc_recursive_" + gconv.String(gtime.TimestampNano())
+			subDirName = dirName + "/subdir"
+			fileName1  = dirName + "/test1.txt"
+			fileName2  = subDirName + "/test2.txt"
+			content    = "original"
+		)
+		createDir(dirName)
+		createDir(subDirName)
+		createTestFile(fileName1, content)
+		createTestFile(fileName2, content)
+		defer delTestFiles(dirName)
+
+		// Non-recursive
+		err := gfile.ReplaceDirFunc(func(path, content string) string {
+			return "changed"
+		}, testpath()+dirName, "*.txt", false)
+		t.AssertNil(err)
+		t.Assert(gfile.GetContents(testpath()+fileName1), "changed")
+		t.Assert(gfile.GetContents(testpath()+fileName2), "original") // Should not be changed
+
+		// Reset
+		err = gfile.PutContents(testpath()+fileName1, content)
+		t.AssertNil(err)
+
+		// Recursive
+		err = gfile.ReplaceDirFunc(func(path, content string) string {
+			return "changed"
+		}, testpath()+dirName, "*.txt", true)
+		t.AssertNil(err)
+		t.Assert(gfile.GetContents(testpath()+fileName1), "changed")
+		t.Assert(gfile.GetContents(testpath()+fileName2), "changed")
+	})
+
+	// Test with non-existent directory
+	gtest.C(t, func(t *gtest.T) {
+		err := gfile.ReplaceDirFunc(func(path, content string) string {
+			return content
+		}, "/nonexistent_dir_12345", "*.txt")
+		t.AssertNE(err, nil)
+	})
+}
diff --git a/os/gfile/gfile_z_unit_sort_test.go b/os/gfile/gfile_z_unit_sort_test.go
new file mode 100644
index 000000000..e0068b4a9
--- /dev/null
+++ b/os/gfile/gfile_z_unit_sort_test.go
@@ -0,0 +1,150 @@
+// 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 gfile_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+func Test_SortFiles(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			dirName   = "/testdir_sort_" + gconv.String(gtime.TimestampNano())
+			fileName1 = dirName + "/b.txt"
+			fileName2 = dirName + "/a.txt"
+			subDir1   = dirName + "/subdir_b"
+			subDir2   = dirName + "/subdir_a"
+		)
+		createDir(dirName)
+		createDir(subDir1)
+		createDir(subDir2)
+		createTestFile(fileName1, "")
+		createTestFile(fileName2, "")
+		defer delTestFiles(dirName)
+
+		// Test sorting: directories should come before files, then sorted alphabetically
+		files := []string{
+			testpath() + fileName1,
+			testpath() + fileName2,
+			testpath() + subDir1,
+			testpath() + subDir2,
+		}
+		sorted := gfile.SortFiles(files)
+
+		// Directories should come first, sorted alphabetically
+		t.Assert(sorted[0], testpath()+subDir2) // subdir_a
+		t.Assert(sorted[1], testpath()+subDir1) // subdir_b
+		// Files should come after, sorted alphabetically
+		t.Assert(sorted[2], testpath()+fileName2) // a.txt
+		t.Assert(sorted[3], testpath()+fileName1) // b.txt
+	})
+
+	// Test with only files
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			dirName   = "/testdir_sort_files_" + gconv.String(gtime.TimestampNano())
+			fileName1 = dirName + "/c.txt"
+			fileName2 = dirName + "/a.txt"
+			fileName3 = dirName + "/b.txt"
+		)
+		createDir(dirName)
+		createTestFile(fileName1, "")
+		createTestFile(fileName2, "")
+		createTestFile(fileName3, "")
+		defer delTestFiles(dirName)
+
+		files := []string{
+			testpath() + fileName1,
+			testpath() + fileName2,
+			testpath() + fileName3,
+		}
+		sorted := gfile.SortFiles(files)
+
+		t.Assert(sorted[0], testpath()+fileName2) // a.txt
+		t.Assert(sorted[1], testpath()+fileName3) // b.txt
+		t.Assert(sorted[2], testpath()+fileName1) // c.txt
+	})
+
+	// Test with only directories
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			dirName = "/testdir_sort_dirs_" + gconv.String(gtime.TimestampNano())
+			subDir1 = dirName + "/c_dir"
+			subDir2 = dirName + "/a_dir"
+			subDir3 = dirName + "/b_dir"
+		)
+		createDir(dirName)
+		createDir(subDir1)
+		createDir(subDir2)
+		createDir(subDir3)
+		defer delTestFiles(dirName)
+
+		files := []string{
+			testpath() + subDir1,
+			testpath() + subDir2,
+			testpath() + subDir3,
+		}
+		sorted := gfile.SortFiles(files)
+
+		t.Assert(sorted[0], testpath()+subDir2) // a_dir
+		t.Assert(sorted[1], testpath()+subDir3) // b_dir
+		t.Assert(sorted[2], testpath()+subDir1) // c_dir
+	})
+
+	// Test with empty slice
+	gtest.C(t, func(t *gtest.T) {
+		files := []string{}
+		sorted := gfile.SortFiles(files)
+		t.Assert(len(sorted), 0)
+	})
+
+	// Test with single element
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			dirName  = "/testdir_sort_single_" + gconv.String(gtime.TimestampNano())
+			fileName = dirName + "/single.txt"
+		)
+		createDir(dirName)
+		createTestFile(fileName, "")
+		defer delTestFiles(dirName)
+
+		files := []string{testpath() + fileName}
+		sorted := gfile.SortFiles(files)
+
+		t.Assert(len(sorted), 1)
+		t.Assert(sorted[0], testpath()+fileName)
+	})
+
+	// Test with mixed paths (some may not exist - testing sort behavior)
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			dirName  = "/testdir_sort_mixed_" + gconv.String(gtime.TimestampNano())
+			fileName = dirName + "/existing.txt"
+			subDir   = dirName + "/existing_dir"
+		)
+		createDir(dirName)
+		createDir(subDir)
+		createTestFile(fileName, "")
+		defer delTestFiles(dirName)
+
+		// Mix of existing dir, existing file
+		files := []string{
+			testpath() + fileName,
+			testpath() + subDir,
+		}
+		sorted := gfile.SortFiles(files)
+
+		// Directory should come first
+		t.Assert(sorted[0], testpath()+subDir)
+		t.Assert(sorted[1], testpath()+fileName)
+	})
+}
diff --git a/os/gfile/gfile_z_unit_test.go b/os/gfile/gfile_z_unit_test.go
index 40696d871..8090b88ec 100644
--- a/os/gfile/gfile_z_unit_test.go
+++ b/os/gfile/gfile_z_unit_test.go
@@ -680,12 +680,6 @@ func Test_SelfName(t *testing.T) {
 	})
 }
 
-func Test_MTimestamp(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		t.Assert(gfile.MTimestamp(gfile.Temp()) > 0, true)
-	})
-}
-
 func Test_RemoveFile_RemoveAll(t *testing.T) {
 	// safe deleting single file.
 	gtest.C(t, func(t *gtest.T) {
@@ -725,3 +719,98 @@ func Test_RemoveFile_RemoveAll(t *testing.T) {
 		t.Assert(gfile.Exists(filePath2), false)
 	})
 }
+
+func Test_Join(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Basic join
+		t.Assert(gfile.Join("a", "b", "c"), "a"+gfile.Separator+"b"+gfile.Separator+"c")
+
+		// Join with trailing separator
+		t.Assert(gfile.Join("a"+gfile.Separator, "b"), "a"+gfile.Separator+"b")
+
+		// Join with empty string
+		t.Assert(gfile.Join("", "a", "b"), "a"+gfile.Separator+"b")
+
+		// Join single path
+		t.Assert(gfile.Join("single"), "single")
+
+		// Join with absolute path
+		t.Assert(gfile.Join(gfile.Separator+"root", "path"), gfile.Separator+"root"+gfile.Separator+"path")
+
+		// Join empty
+		t.Assert(gfile.Join(), "")
+	})
+}
+
+func Test_Chdir(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Save current working directory
+		originalPwd := gfile.Pwd()
+		defer func() {
+			// Restore original working directory
+			_ = gfile.Chdir(originalPwd)
+		}()
+
+		// Test changing to temp directory
+		tempDir := gfile.Temp()
+		err := gfile.Chdir(tempDir)
+		t.AssertNil(err)
+		t.Assert(gfile.Pwd(), tempDir)
+
+		// Test changing to non-existent directory
+		err = gfile.Chdir("/nonexistent_dir_12345")
+		t.AssertNE(err, nil)
+	})
+}
+
+func Test_Abs(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test with relative path
+		absPath := gfile.Abs(".")
+		t.Assert(len(absPath) > 0, true)
+		t.Assert(filepath.IsAbs(absPath), true)
+
+		// Test with already absolute path
+		tempDir := gfile.Temp()
+		t.Assert(gfile.Abs(tempDir), tempDir)
+
+		// Test with relative path components
+		absPath = gfile.Abs("./test")
+		t.Assert(filepath.IsAbs(absPath), true)
+
+		// Test with parent directory reference
+		absPath = gfile.Abs("../test")
+		t.Assert(filepath.IsAbs(absPath), true)
+
+		// Test with empty string
+		absPath = gfile.Abs("")
+		t.Assert(len(absPath) > 0, true)
+		t.Assert(filepath.IsAbs(absPath), true)
+	})
+}
+
+func Test_Name(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test with file extension
+		t.Assert(gfile.Name("/var/www/file.js"), "file")
+		t.Assert(gfile.Name("file.js"), "file")
+
+		// Test with multiple dots
+		t.Assert(gfile.Name("/var/www/file.min.js"), "file.min")
+		t.Assert(gfile.Name("archive.tar.gz"), "archive.tar")
+
+		// Test without extension
+		t.Assert(gfile.Name("/var/www/file"), "file")
+		t.Assert(gfile.Name("file"), "file")
+
+		// Test with hidden file (dot file)
+		t.Assert(gfile.Name(".gitignore"), "")
+		t.Assert(gfile.Name(".hidden.txt"), ".hidden")
+
+		// Test with directory path
+		t.Assert(gfile.Name("/var/www/"), "www")
+
+		// Test with only extension
+		t.Assert(gfile.Name(".txt"), "")
+	})
+}
diff --git a/os/gfile/gfile_z_unit_time_test.go b/os/gfile/gfile_z_unit_time_test.go
index fb83d1faa..1e9497606 100644
--- a/os/gfile/gfile_z_unit_time_test.go
+++ b/os/gfile/gfile_z_unit_time_test.go
@@ -55,3 +55,36 @@ func Test_MTimeMillisecond(t *testing.T) {
 		t.Assert(gfile.MTimestampMilli(""), -1)
 	})
 }
+
+func Test_MTimestamp(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			file1   = "/testfile_mtimestamp.txt"
+			err     error
+			fileobj os.FileInfo
+		)
+
+		createTestFile(file1, "")
+		defer delTestFiles(file1)
+		fileobj, err = os.Stat(testpath() + file1)
+		t.AssertNil(err)
+
+		// Test MTimestamp returns correct unix timestamp
+		timestamp := gfile.MTimestamp(testpath() + file1)
+		t.Assert(timestamp, fileobj.ModTime().Unix())
+		t.Assert(timestamp > 0, true)
+
+		// Test with non-existent file
+		t.Assert(gfile.MTimestamp("/nonexistent_file_12345.txt"), -1)
+
+		// Test with empty path
+		t.Assert(gfile.MTimestamp(""), -1)
+	})
+
+	// Test MTimestamp with directory
+	gtest.C(t, func(t *gtest.T) {
+		tempDir := gfile.Temp()
+		timestamp := gfile.MTimestamp(tempDir)
+		t.Assert(timestamp > 0, true)
+	})
+}
diff --git a/os/gfpool/gfpool.go b/os/gfpool/gfpool.go
index 5eec01b27..b6bd61078 100644
--- a/os/gfpool/gfpool.go
+++ b/os/gfpool/gfpool.go
@@ -36,6 +36,8 @@ type File struct {
 }
 
 var (
+	// checker is used for checking whether the value is nil.
+	checker = func(v *Pool) bool { return v == nil }
 	// Global file pointer pool.
-	pools = gmap.NewStrAnyMap(true)
+	pools = gmap.NewKVMapWithChecker[string, *Pool](checker, true)
 )
diff --git a/os/gfpool/gfpool_file.go b/os/gfpool/gfpool_file.go
index b77f2fbf4..b0bc98d8a 100644
--- a/os/gfpool/gfpool_file.go
+++ b/os/gfpool/gfpool_file.go
@@ -31,10 +31,10 @@ func Open(path string, flag int, perm os.FileMode, ttl ...time.Duration) (file *
 	// }
 	pool := pools.GetOrSetFuncLock(
 		fmt.Sprintf("%s&%d&%d&%d", path, flag, fpTTL, perm),
-		func() any {
+		func() *Pool {
 			return New(path, flag, perm, fpTTL)
 		},
-	).(*Pool)
+	)
 
 	return pool.File()
 }
@@ -52,7 +52,7 @@ func Get(path string, flag int, perm os.FileMode, ttl ...time.Duration) (file *F
 		return nil
 	}
 
-	fp, _ := f.(*Pool).pool.Get()
+	fp, _ := f.pool.Get()
 	return fp.(*File)
 }
 
diff --git a/os/gfsnotify/gfsnotify.go b/os/gfsnotify/gfsnotify.go
index 2ff8f7eb0..8eb011fec 100644
--- a/os/gfsnotify/gfsnotify.go
+++ b/os/gfsnotify/gfsnotify.go
@@ -27,22 +27,22 @@ import (
 
 // Watcher is the monitor for file changes.
 type Watcher struct {
-	watcher   *fsnotify.Watcher // Underlying fsnotify object.
-	events    *gqueue.Queue     // Used for internal event management.
-	cache     *gcache.Cache     // Used for repeated event filter.
-	nameSet   *gset.StrSet      // Used for AddOnce feature.
-	callbacks *gmap.StrAnyMap   // Path(file/folder) to callbacks mapping.
-	closeChan chan struct{}     // Used for watcher closing notification.
+	watcher   *fsnotify.Watcher                            // Underlying fsnotify object.
+	events    *gqueue.TQueue[*Event]                       // Used for internal event management.
+	cache     *gcache.Cache                                // Used for repeated event filter.
+	nameSet   *gset.StrSet                                 // Used for AddOnce feature.
+	callbacks *gmap.KVMap[string, *glist.TList[*Callback]] // Path(file/folder) to callbacks mapping.
+	closeChan chan struct{}                                // Used for watcher closing notification.
 }
 
 // Callback is the callback function for Watcher.
 type Callback struct {
-	Id        int                // Unique id for callback object.
-	Func      func(event *Event) // Callback function.
-	Path      string             // Bound file path (absolute).
-	name      string             // Registered name for AddOnce.
-	elem      *glist.Element     // Element in the callbacks of watcher.
-	recursive bool               // Is bound to sub-path recursively or not.
+	Id        int                        // Unique id for callback object.
+	Func      func(event *Event)         // Callback function.
+	Path      string                     // Bound file path (absolute).
+	name      string                     // Registered name for AddOnce.
+	elem      *glist.TElement[*Callback] // Element in the callbacks of watcher.
+	recursive bool                       // Is bound to sub-path recursively or not.
 }
 
 // Event is the event produced by underlying fsnotify.
@@ -82,10 +82,12 @@ const (
 )
 
 var (
-	mu                  sync.Mutex                // Mutex for concurrent safety of defaultWatcher.
-	defaultWatcher      *Watcher                  // Default watcher.
-	callbackIdMap       = gmap.NewIntAnyMap(true) // Global callback id to callback function mapping.
-	callbackIdGenerator = gtype.NewInt()          // Atomic id generator for callback.
+	callBacksChecker     = func(v *glist.TList[*Callback]) bool { return v == nil }             // callBacksChecker checks whether the value is nil.
+	callbackIdMapChecker = func(v *Callback) bool { return v == nil }                           // callbackIdMapChecker checks whether the value is nil.
+	mu                   sync.Mutex                                                             // Mutex for concurrent safety of defaultWatcher.
+	defaultWatcher       *Watcher                                                               // Default watcher.
+	callbackIdMap        = gmap.NewKVMapWithChecker[int, *Callback](callbackIdMapChecker, true) // Global callback id to callback function mapping.
+	callbackIdGenerator  = gtype.NewInt()                                                       // Atomic id generator for callback.
 )
 
 // New creates and returns a new watcher.
@@ -96,10 +98,10 @@ var (
 func New() (*Watcher, error) {
 	w := &Watcher{
 		cache:     gcache.New(),
-		events:    gqueue.New(),
+		events:    gqueue.NewTQueue[*Event](),
 		nameSet:   gset.NewStrSet(true),
 		closeChan: make(chan struct{}),
-		callbacks: gmap.NewStrAnyMap(true),
+		callbacks: gmap.NewKVMapWithChecker[string, *glist.TList[*Callback]](callBacksChecker, true),
 	}
 	if watcher, err := fsnotify.NewWatcher(); err == nil {
 		w.watcher = watcher
@@ -154,11 +156,7 @@ func RemoveCallback(callbackID int) error {
 	if err != nil {
 		return err
 	}
-	callback := (*Callback)(nil)
-	if r := callbackIdMap.Get(callbackID); r != nil {
-		callback = r.(*Callback)
-	}
-	if callback == nil {
+	if callback := callbackIdMap.Get(callbackID); callback == nil {
 		return gerror.NewCodef(gcode.CodeInvalidParameter, `callback for id %d not found`, callbackID)
 	}
 	w.RemoveCallback(callbackID)
diff --git a/os/gfsnotify/gfsnotify_watcher.go b/os/gfsnotify/gfsnotify_watcher.go
index e475aea3c..b90fa7804 100644
--- a/os/gfsnotify/gfsnotify_watcher.go
+++ b/os/gfsnotify/gfsnotify_watcher.go
@@ -20,8 +20,7 @@ import (
 // The parameter `path` can be either a file or a directory path.
 // The optional parameter `recursive` specifies whether monitoring the `path` recursively,
 // which is true in default.
-func (w *Watcher) Add(
-	path string, callbackFunc func(event *Event), option ...WatchOption,
+func (w *Watcher) Add(path string, callbackFunc func(event *Event), option ...WatchOption,
 ) (callback *Callback, err error) {
 	return w.AddOnce("", path, callbackFunc, option...)
 }
@@ -35,8 +34,7 @@ func (w *Watcher) Add(
 // The parameter `path` can be either a file or a directory path.
 // The optional parameter `recursive` specifies whether monitoring the `path` recursively,
 // which is true in default.
-func (w *Watcher) AddOnce(
-	name, path string, callbackFunc func(event *Event), option ...WatchOption,
+func (w *Watcher) AddOnce(name, path string, callbackFunc func(event *Event), option ...WatchOption,
 ) (callback *Callback, err error) {
 	var watchOption = w.getWatchOption(option...)
 	w.nameSet.AddIfNotExistFuncLock(name, func() bool {
@@ -89,8 +87,7 @@ func (w *Watcher) getWatchOption(option ...WatchOption) WatchOption {
 
 // addWithCallbackFunc adds the path to underlying monitor, creates and returns a callback object.
 // Very note that if it calls multiple times with the same `path`, the latest one will overwrite the previous one.
-func (w *Watcher) addWithCallbackFunc(
-	name, path string, callbackFunc func(event *Event), option ...WatchOption,
+func (w *Watcher) addWithCallbackFunc(name, path string, callbackFunc func(event *Event), option ...WatchOption,
 ) (callback *Callback, err error) {
 	var watchOption = w.getWatchOption(option...)
 	// Check and convert the given path to absolute path.
@@ -108,13 +105,11 @@ func (w *Watcher) addWithCallbackFunc(
 		recursive: !watchOption.NoRecursive,
 	}
 	// Register the callback to watcher.
-	w.callbacks.LockFunc(func(m map[string]any) {
-		list := (*glist.List)(nil)
-		if v, ok := m[path]; !ok {
-			list = glist.New(true)
+	w.callbacks.LockFunc(func(m map[string]*glist.TList[*Callback]) {
+		list, ok := m[path]
+		if !ok {
+			list = glist.NewT[*Callback](true)
 			m[path] = list
-		} else {
-			list = v.(*glist.List)
 		}
 		callback.elem = list.PushBack(callback)
 	})
@@ -158,10 +153,9 @@ func (w *Watcher) Remove(path string) error {
 	for _, removedPath := range removedPaths {
 		// remove the callbacks of the path.
 		if value := w.callbacks.Remove(removedPath); value != nil {
-			list := value.(*glist.List)
 			for {
-				if item := list.PopFront(); item != nil {
-					callbackIdMap.Remove(item.(*Callback).Id)
+				if item := value.PopFront(); item != nil {
+					callbackIdMap.Remove(item.Id)
 				} else {
 					break
 				}
@@ -183,13 +177,9 @@ func (w *Watcher) Remove(path string) error {
 //
 // Note that, it auto removes the path watching if there's no callback bound on it.
 func (w *Watcher) RemoveCallback(callbackID int) {
-	callback := (*Callback)(nil)
-	if r := callbackIdMap.Get(callbackID); r != nil {
-		callback = r.(*Callback)
-	}
-	if callback != nil {
+	if callback := callbackIdMap.Get(callbackID); callback != nil {
 		if r := w.callbacks.Get(callback.Path); r != nil {
-			r.(*glist.List).Remove(callback.elem)
+			r.Remove(callback.elem)
 		}
 		callbackIdMap.Remove(callbackID)
 		if callback.name != "" {
diff --git a/os/gfsnotify/gfsnotify_watcher_loop.go b/os/gfsnotify/gfsnotify_watcher_loop.go
index 730931b11..e3818a5e7 100644
--- a/os/gfsnotify/gfsnotify_watcher_loop.go
+++ b/os/gfsnotify/gfsnotify_watcher_loop.go
@@ -9,7 +9,6 @@ package gfsnotify
 import (
 	"context"
 
-	"github.com/gogf/gf/v2/container/glist"
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/internal/intlog"
@@ -63,69 +62,68 @@ func (w *Watcher) eventLoop() {
 	)
 	for {
 		if v := w.events.Pop(); v != nil {
-			event := v.(*Event)
 			// If there's no any callback of this path, it removes it from monitor,
 			// as a path watching without callback is meaningless.
-			callbacks := w.getCallbacksForPath(event.Path)
+			callbacks := w.getCallbacksForPath(v.Path)
 			if len(callbacks) == 0 {
-				_ = w.watcher.Remove(event.Path)
+				_ = w.watcher.Remove(v.Path)
 				continue
 			}
 
 			switch {
-			case event.IsRemove():
+			case v.IsRemove():
 				// It should check again the existence of the path.
 				// It adds it back to the monitor if it still exists.
-				if fileExists(event.Path) {
+				if fileExists(v.Path) {
 					// A watch will be automatically removed if the watched path is deleted or
 					// renamed.
 					//
 					// It here adds the path back to monitor.
 					// We need no worry about the repeat adding.
-					if err = w.watcher.Add(event.Path); err != nil {
+					if err = w.watcher.Add(v.Path); err != nil {
 						intlog.Errorf(ctx, `%+v`, err)
 					} else {
 						intlog.Printf(
 							ctx,
 							"fake remove event, watcher re-adds monitor for: %s",
-							event.Path,
+							v.Path,
 						)
 					}
 					// Change the event to RENAME, which means it renames itself to its origin name.
-					event.Op = RENAME
+					v.Op = RENAME
 				}
 
-			case event.IsRename():
+			case v.IsRename():
 				// It should check again the existence of the path.
 				// It adds it back to the monitor if it still exists.
 				// Especially Some editors might do RENAME and then CHMOD when it's editing file.
-				if fileExists(event.Path) {
+				if fileExists(v.Path) {
 					// A watch will be automatically removed if the watched path is deleted or
 					// renamed.
 					//
 					// It might lose the monitoring for the path, so we add the path back to monitor.
 					// We need no worry about the repeat adding.
-					if err = w.watcher.Add(event.Path); err != nil {
+					if err = w.watcher.Add(v.Path); err != nil {
 						intlog.Errorf(ctx, `%+v`, err)
 					} else {
 						intlog.Printf(
 							ctx,
 							"fake rename event, watcher re-adds monitor for: %s",
-							event.Path,
+							v.Path,
 						)
 					}
 					// Change the event to CHMOD.
-					event.Op = CHMOD
+					v.Op = CHMOD
 				}
 
-			case event.IsCreate():
+			case v.IsCreate():
 				// =================================================================================
 				// Note that it here just adds the path to monitor without any callback registering,
 				// because its parent already has the callbacks.
 				// =================================================================================
-				if w.checkRecursiveWatchingInCreatingEvent(event.Path) {
+				if w.checkRecursiveWatchingInCreatingEvent(v.Path) {
 					// It handles only folders, watching folders also watching its sub files.
-					for _, subPath := range fileAllDirs(event.Path) {
+					for _, subPath := range fileAllDirs(v.Path) {
 						if fileIsDir(subPath) {
 							if err = w.watcher.Add(subPath); err != nil {
 								intlog.Errorf(ctx, `%+v`, err)
@@ -142,7 +140,7 @@ func (w *Watcher) eventLoop() {
 			}
 			// Calling the callbacks in multiple goroutines.
 			for _, callback := range callbacks {
-				go w.doCallback(event, callback)
+				go w.doCallback(v, callback)
 			}
 		} else {
 			break
@@ -166,9 +164,8 @@ func (w *Watcher) checkRecursiveWatchingInCreatingEvent(path string) bool {
 			break
 		}
 		if callbackItem := w.callbacks.Get(parentDirPath); callbackItem != nil {
-			for _, node := range callbackItem.(*glist.List).FrontAll() {
-				callback := node.(*Callback)
-				if callback.recursive {
+			for _, node := range callbackItem.FrontAll() {
+				if node.recursive {
 					return true
 				}
 			}
@@ -201,10 +198,7 @@ func (w *Watcher) doCallback(event *Event, callback *Callback) {
 func (w *Watcher) getCallbacksForPath(path string) (callbacks []*Callback) {
 	// Firstly add the callbacks of itself.
 	if item := w.callbacks.Get(path); item != nil {
-		for _, node := range item.(*glist.List).FrontAll() {
-			callback := node.(*Callback)
-			callbacks = append(callbacks, callback)
-		}
+		callbacks = append(callbacks, item.FrontAll()...)
 	}
 	// ============================================================================================================
 	// Secondly searches its direct parent for callbacks.
@@ -214,10 +208,7 @@ func (w *Watcher) getCallbacksForPath(path string) (callbacks []*Callback) {
 	// ============================================================================================================
 	dirPath := fileDir(path)
 	if item := w.callbacks.Get(dirPath); item != nil {
-		for _, node := range item.(*glist.List).FrontAll() {
-			callback := node.(*Callback)
-			callbacks = append(callbacks, callback)
-		}
+		callbacks = append(callbacks, item.FrontAll()...)
 	}
 
 	// Lastly searches all the parents of directory of `path` recursively for callbacks.
@@ -227,10 +218,9 @@ func (w *Watcher) getCallbacksForPath(path string) (callbacks []*Callback) {
 			break
 		}
 		if item := w.callbacks.Get(parentDirPath); item != nil {
-			for _, node := range item.(*glist.List).FrontAll() {
-				callback := node.(*Callback)
-				if callback.recursive {
-					callbacks = append(callbacks, callback)
+			for _, node := range item.FrontAll() {
+				if node.recursive {
+					callbacks = append(callbacks, node)
 				}
 			}
 		}
diff --git a/os/glog/glog_instance.go b/os/glog/glog_instance.go
index 4f6dad14e..104308de1 100644
--- a/os/glog/glog_instance.go
+++ b/os/glog/glog_instance.go
@@ -14,8 +14,10 @@ const (
 )
 
 var (
+	// Checker function for instances map.
+	checker = func(v *Logger) bool { return v == nil }
 	// Instances map.
-	instances = gmap.NewStrAnyMap(true)
+	instances = gmap.NewKVMapWithChecker[string, *Logger](checker, true)
 )
 
 // Instance returns an instance of Logger with default settings.
@@ -25,7 +27,5 @@ func Instance(name ...string) *Logger {
 	if len(name) > 0 && name[0] != "" {
 		key = name[0]
 	}
-	return instances.GetOrSetFuncLock(key, func() any {
-		return New()
-	}).(*Logger)
+	return instances.GetOrSetFuncLock(key, New)
 }
diff --git a/os/gmlock/gmlock_locker.go b/os/gmlock/gmlock_locker.go
index 424fcf056..0eaaa2410 100644
--- a/os/gmlock/gmlock_locker.go
+++ b/os/gmlock/gmlock_locker.go
@@ -12,18 +12,20 @@ import (
 	"github.com/gogf/gf/v2/container/gmap"
 )
 
+var checker = func(v *sync.RWMutex) bool { return v == nil }
+
 // Locker is a memory based locker.
 // Note that there's no cache expire mechanism for mutex in locker.
 // You need remove certain mutex manually when you do not want use it anymore.
 type Locker struct {
-	m *gmap.StrAnyMap
+	m *gmap.KVMap[string, *sync.RWMutex]
 }
 
 // New creates and returns a new memory locker.
 // A memory locker can lock/unlock with dynamic string key.
 func New() *Locker {
 	return &Locker{
-		m: gmap.NewStrAnyMap(true),
+		m: gmap.NewKVMapWithChecker[string, *sync.RWMutex](checker, true),
 	}
 }
 
@@ -43,7 +45,7 @@ func (l *Locker) TryLock(key string) bool {
 // Unlock unlocks the writing lock of the `key`.
 func (l *Locker) Unlock(key string) {
 	if v := l.m.Get(key); v != nil {
-		v.(*sync.RWMutex).Unlock()
+		v.Unlock()
 	}
 }
 
@@ -63,7 +65,7 @@ func (l *Locker) TryRLock(key string) bool {
 // RUnlock unlocks the reading lock of the `key`.
 func (l *Locker) RUnlock(key string) {
 	if v := l.m.Get(key); v != nil {
-		v.(*sync.RWMutex).RUnlock()
+		v.RUnlock()
 	}
 }
 
@@ -128,7 +130,7 @@ func (l *Locker) Clear() {
 // getOrNewMutex returns the mutex of given `key` if it exists,
 // or else creates and returns a new one.
 func (l *Locker) getOrNewMutex(key string) *sync.RWMutex {
-	return l.m.GetOrSetFuncLock(key, func() any {
+	return l.m.GetOrSetFuncLock(key, func() *sync.RWMutex {
 		return &sync.RWMutex{}
-	}).(*sync.RWMutex)
+	})
 }
diff --git a/os/gmutex/gmutex.go b/os/gmutex/gmutex.go
index 956ccdc8b..1d49f07fc 100644
--- a/os/gmutex/gmutex.go
+++ b/os/gmutex/gmutex.go
@@ -10,6 +10,7 @@
 package gmutex
 
 // New creates and returns a new mutex.
+//
 // Deprecated: use Mutex or RWMutex instead.
 func New() *RWMutex {
 	return &RWMutex{}
diff --git a/os/gproc/gproc_comm.go b/os/gproc/gproc_comm.go
index b547d31d7..9e2a3b2c1 100644
--- a/os/gproc/gproc_comm.go
+++ b/os/gproc/gproc_comm.go
@@ -12,6 +12,7 @@ import (
 	"sync"
 
 	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/container/gqueue"
 	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/internal/intlog"
 	"github.com/gogf/gf/v2/net/gtcp"
@@ -42,9 +43,11 @@ const (
 )
 
 var (
+	// checker is used for checking whether the value is nil.
+	checker = func(v *gqueue.TQueue[*MsgRequest]) bool { return v == nil }
 	// commReceiveQueues is the group name to queue map for storing received data.
-	// The value of the map is type of *gqueue.Queue.
-	commReceiveQueues = gmap.NewStrAnyMap(true)
+	// The value of the map is type of *gqueue.TQueue[*MsgRequest].
+	commReceiveQueues = gmap.NewKVMapWithChecker[string, *gqueue.TQueue[*MsgRequest]](checker, true)
 
 	// commPidFolderPath specifies the folder path storing pid to port mapping files.
 	commPidFolderPath string
diff --git a/os/gproc/gproc_comm_receive.go b/os/gproc/gproc_comm_receive.go
index 5271b4d3d..5c8b720a3 100644
--- a/os/gproc/gproc_comm_receive.go
+++ b/os/gproc/gproc_comm_receive.go
@@ -39,15 +39,10 @@ func Receive(group ...string) *MsgRequest {
 	} else {
 		groupName = defaultGroupNameForProcComm
 	}
-	queue := commReceiveQueues.GetOrSetFuncLock(groupName, func() any {
-		return gqueue.New(maxLengthForProcMsgQueue)
-	}).(*gqueue.Queue)
-
-	// Blocking receiving.
-	if v := queue.Pop(); v != nil {
-		return v.(*MsgRequest)
-	}
-	return nil
+	queue := commReceiveQueues.GetOrSetFuncLock(groupName, func() *gqueue.TQueue[*MsgRequest] {
+		return gqueue.NewTQueue[*MsgRequest](maxLengthForProcMsgQueue)
+	})
+	return queue.Pop()
 }
 
 // receiveTcpListening scans local for available port and starts listening.
@@ -110,7 +105,7 @@ func receiveTcpHandler(conn *gtcp.Conn) {
 			} else {
 				// Push to buffer queue.
 				response.Code = 1
-				v.(*gqueue.Queue).Push(msg)
+				v.Push(msg)
 			}
 		} else {
 			// Empty package.
diff --git a/os/gres/gres_instance.go b/os/gres/gres_instance.go
index 7b58c4979..71ce4baa0 100644
--- a/os/gres/gres_instance.go
+++ b/os/gres/gres_instance.go
@@ -14,8 +14,10 @@ const (
 )
 
 var (
+	// checker checks whether the value is nil.
+	checker = func(v *Resource) bool { return v == nil }
 	// Instances map.
-	instances = gmap.NewStrAnyMap(true)
+	instances = gmap.NewKVMapWithChecker[string, *Resource](checker, true)
 )
 
 // Instance returns an instance of Resource.
@@ -25,7 +27,5 @@ func Instance(name ...string) *Resource {
 	if len(name) > 0 && name[0] != "" {
 		key = name[0]
 	}
-	return instances.GetOrSetFuncLock(key, func() any {
-		return New()
-	}).(*Resource)
+	return instances.GetOrSetFuncLock(key, New)
 }
diff --git a/os/grpool/grpool.go b/os/grpool/grpool.go
index 1abf99195..521a110fb 100644
--- a/os/grpool/grpool.go
+++ b/os/grpool/grpool.go
@@ -25,10 +25,10 @@ type RecoverFunc func(ctx context.Context, exception error)
 
 // Pool manages the goroutines using pool.
 type Pool struct {
-	limit  int         // Max goroutine count limit.
-	count  *gtype.Int  // Current running goroutine count.
-	list   *glist.List // List for asynchronous job adding purpose.
-	closed *gtype.Bool // Is pool closed or not.
+	limit  int                          // Max goroutine count limit.
+	count  *gtype.Int                   // Current running goroutine count.
+	list   *glist.TList[*localPoolItem] // List for asynchronous job adding purpose.
+	closed *gtype.Bool                  // Is pool closed or not.
 }
 
 // localPoolItem is the job item storing in job list.
@@ -55,7 +55,7 @@ func New(limit ...int) *Pool {
 		pool = &Pool{
 			limit:  -1,
 			count:  gtype.NewInt(),
-			list:   glist.New(true),
+			list:   glist.NewT[*localPoolItem](true),
 			closed: gtype.NewBool(),
 		}
 		timerDuration = grand.D(
diff --git a/os/grpool/grpool_pool.go b/os/grpool/grpool_pool.go
index 4296fc2c3..cb5d692cf 100644
--- a/os/grpool/grpool_pool.go
+++ b/os/grpool/grpool_pool.go
@@ -104,18 +104,12 @@ func (p *Pool) checkAndForkNewGoroutineWorker() {
 
 func (p *Pool) asynchronousWorker() {
 	defer p.count.Add(-1)
-
-	var (
-		listItem any
-		poolItem *localPoolItem
-	)
 	// Harding working, one by one, job never empty, worker never die.
 	for !p.closed.Val() {
-		listItem = p.list.PopBack()
+		listItem := p.list.PopBack()
 		if listItem == nil {
 			return
 		}
-		poolItem = listItem.(*localPoolItem)
-		poolItem.Func(poolItem.Ctx)
+		listItem.Func(listItem.Ctx)
 	}
 }
diff --git a/os/gspath/gspath.go b/os/gspath/gspath.go
index 051ef2f2e..5e2060614 100644
--- a/os/gspath/gspath.go
+++ b/os/gspath/gspath.go
@@ -39,8 +39,10 @@ type SPathCacheItem struct {
 }
 
 var (
+	// checker is the checking function for checking the value is nil or not.
+	checker = func(v *SPath) bool { return v == nil }
 	// Path to searching object mapping, used for instance management.
-	pathsMap = gmap.NewStrAnyMap(true)
+	pathsMap = gmap.NewKVMapWithChecker[string, *SPath](checker, true)
 )
 
 // New creates and returns a new path searching manager.
@@ -65,9 +67,9 @@ func Get(root string, cache bool) *SPath {
 	if root == "" {
 		root = "/"
 	}
-	return pathsMap.GetOrSetFuncLock(root, func() any {
+	return pathsMap.GetOrSetFuncLock(root, func() *SPath {
 		return New(root, cache)
-	}).(*SPath)
+	})
 }
 
 // Search searches file `name` under path `root`.
diff --git a/os/gview/gview.go b/os/gview/gview.go
index acd395b48..4ab011b1a 100644
--- a/os/gview/gview.go
+++ b/os/gview/gview.go
@@ -23,11 +23,11 @@ import (
 
 // View object for template engine.
 type View struct {
-	searchPaths  *garray.StrArray // Searching array for path, NOT concurrent-safe for performance purpose.
-	data         map[string]any   // Global template variables.
-	funcMap      map[string]any   // Global template function map.
-	fileCacheMap *gmap.StrAnyMap  // File cache map.
-	config       Config           // Extra configuration for the view.
+	searchPaths  *garray.StrArray                    // Searching array for path, NOT concurrent-safe for performance purpose.
+	data         map[string]any                      // Global template variables.
+	funcMap      map[string]any                      // Global template function map.
+	fileCacheMap *gmap.KVMap[string, *fileCacheItem] // File cache map.
+	config       Config                              // Extra configuration for the view.
 }
 
 type (
@@ -41,7 +41,8 @@ const (
 
 var (
 	// Default view object.
-	defaultViewObj *View
+	defaultViewObj       *View
+	fileCacheItemChecker = func(v *fileCacheItem) bool { return v == nil }
 )
 
 // checkAndInitDefaultView checks and initializes the default view object.
@@ -69,7 +70,7 @@ func New(path ...string) *View {
 		searchPaths:  garray.NewStrArray(),
 		data:         make(map[string]any),
 		funcMap:      make(map[string]any),
-		fileCacheMap: gmap.NewStrAnyMap(true),
+		fileCacheMap: gmap.NewKVMapWithChecker[string, *fileCacheItem](fileCacheItemChecker, true),
 		config:       DefaultConfig(),
 	}
 	if len(path) > 0 && len(path[0]) > 0 {
diff --git a/os/gview/gview_instance.go b/os/gview/gview_instance.go
index cb75d5d42..c36b0582d 100644
--- a/os/gview/gview_instance.go
+++ b/os/gview/gview_instance.go
@@ -14,8 +14,9 @@ const (
 )
 
 var (
+	checker = func(v *View) bool { return v == nil }
 	// Instances map.
-	instances = gmap.NewStrAnyMap(true)
+	instances = gmap.NewKVMapWithChecker[string, *View](checker, true)
 )
 
 // Instance returns an instance of View with default settings.
@@ -25,7 +26,7 @@ func Instance(name ...string) *View {
 	if len(name) > 0 && name[0] != "" {
 		key = name[0]
 	}
-	return instances.GetOrSetFuncLock(key, func() any {
+	return instances.GetOrSetFuncLock(key, func() *View {
 		return New()
-	}).(*View)
+	})
 }
diff --git a/os/gview/gview_parse.go b/os/gview/gview_parse.go
index 02d2888b0..1f49bc33a 100644
--- a/os/gview/gview_parse.go
+++ b/os/gview/gview_parse.go
@@ -102,6 +102,7 @@ func (view *View) ParseContent(ctx context.Context, content string, params ...Pa
 }
 
 // Option for template parsing.
+//
 // Deprecated: use Options instead.
 type Option = Options
 
@@ -114,6 +115,7 @@ type Options struct {
 }
 
 // ParseOption implements template parsing using Option.
+//
 // Deprecated: use ParseWithOptions instead.
 func (view *View) ParseOption(ctx context.Context, option Option) (result string, err error) {
 	return view.ParseWithOptions(ctx, option)
@@ -128,7 +130,7 @@ func (view *View) ParseWithOptions(ctx context.Context, opts Options) (result st
 		return "", gerror.New(`template file cannot be empty`)
 	}
 	// It caches the file, folder, and content to enhance performance.
-	r := view.fileCacheMap.GetOrSetFuncLock(opts.File, func() any {
+	r := view.fileCacheMap.GetOrSetFuncLock(opts.File, func() *fileCacheItem {
 		var (
 			path     string
 			folder   string
@@ -167,30 +169,29 @@ func (view *View) ParseWithOptions(ctx context.Context, opts Options) (result st
 	if r == nil {
 		return
 	}
-	item := r.(*fileCacheItem)
 	// It's not necessary continuing parsing if template content is empty.
-	if item.content == "" {
+	if r.content == "" {
 		return "", nil
 	}
 	// If it's an Orphan option, it just parses the single file by ParseContent.
 	if opts.Orphan {
-		return view.doParseContent(ctx, item.content, opts.Params)
+		return view.doParseContent(ctx, r.content, opts.Params)
 	}
 	// Get the template object instance for `folder`.
 	var tpl any
-	tpl, err = view.getTemplate(item.path, item.folder, fmt.Sprintf(`*%s`, gfile.Ext(item.path)))
+	tpl, err = view.getTemplate(r.path, r.folder, fmt.Sprintf(`*%s`, gfile.Ext(r.path)))
 	if err != nil {
 		return "", err
 	}
 	// Using memory lock to ensure concurrent safety for template parsing.
-	gmlock.LockFunc("gview.Parse:"+item.path, func() {
+	gmlock.LockFunc("gview.Parse:"+r.path, func() {
 		if view.config.AutoEncode {
-			tpl, err = tpl.(*htmltpl.Template).Parse(item.content)
+			tpl, err = tpl.(*htmltpl.Template).Parse(r.content)
 		} else {
-			tpl, err = tpl.(*texttpl.Template).Parse(item.content)
+			tpl, err = tpl.(*texttpl.Template).Parse(r.content)
 		}
-		if err != nil && item.path != "" {
-			err = gerror.Wrap(err, item.path)
+		if err != nil && r.path != "" {
+			err = gerror.Wrap(err, r.path)
 		}
 	})
 	if err != nil {
diff --git a/util/gconv/gconv.go b/util/gconv/gconv.go
index 58f8c63eb..cc5adc497 100644
--- a/util/gconv/gconv.go
+++ b/util/gconv/gconv.go
@@ -154,6 +154,7 @@ func NewConverter() Converter {
 }
 
 // RegisterConverter registers custom converter.
+//
 // Deprecated: use RegisterTypeConverterFunc instead for clear
 func RegisterConverter(fn any) (err error) {
 	return RegisterTypeConverterFunc(fn)
diff --git a/util/gconv/gconv_map.go b/util/gconv/gconv_map.go
index 04733e8b3..caa4cced0 100644
--- a/util/gconv/gconv_map.go
+++ b/util/gconv/gconv_map.go
@@ -20,6 +20,7 @@ func Map(value any, option ...MapOption) map[string]any {
 // MapDeep does Map function recursively, which means if the attribute of `value`
 // is also a struct/*struct, calls Map function on this attribute converting it to
 // a map[string]any type variable.
+//
 // Deprecated: used Map instead.
 func MapDeep(value any, tags ...string) map[string]any {
 	result, _ := defaultConverter.Map(value, MapOption{
@@ -40,6 +41,7 @@ func MapStrStr(value any, option ...MapOption) map[string]string {
 
 // MapStrStrDeep converts `value` to map[string]string recursively.
 // Note that there might be data copy for this map type converting.
+//
 // Deprecated: used MapStrStr instead.
 func MapStrStrDeep(value any, tags ...string) map[string]string {
 	if r, ok := value.(map[string]string); ok {
diff --git a/util/gconv/gconv_maps.go b/util/gconv/gconv_maps.go
index a3d7b6a8c..f622b2ae4 100644
--- a/util/gconv/gconv_maps.go
+++ b/util/gconv/gconv_maps.go
@@ -17,6 +17,7 @@ func SliceMap(anyInput any, option ...MapOption) []map[string]any {
 }
 
 // SliceMapDeep is alias of MapsDeep.
+//
 // Deprecated: used SliceMap instead.
 func SliceMapDeep(anyInput any) []map[string]any {
 	return MapsDeep(anyInput)
@@ -43,6 +44,7 @@ func Maps(value any, option ...MapOption) []map[string]any {
 // MapsDeep converts `value` to []map[string]any recursively.
 //
 // TODO completely implement the recursive converting for all types.
+//
 // Deprecated: used Maps instead.
 func MapsDeep(value any, tags ...string) []map[string]any {
 	if value == nil {
diff --git a/util/gconv/gconv_scan.go b/util/gconv/gconv_scan.go
index da3fcc431..83c5319cf 100644
--- a/util/gconv/gconv_scan.go
+++ b/util/gconv/gconv_scan.go
@@ -25,3 +25,35 @@ func Scan(srcValue any, dstPointer any, paramKeyToAttrMap ...map[string]string)
 	}
 	return defaultConverter.Scan(srcValue, dstPointer, option)
 }
+
+// ScanWithOptions automatically checks the type of `dstPointer` and converts `srcValue` to `dstPointer`.
+// It is the same as Scan function, but accepts one or more ScanOption values for additional conversion control.
+//
+// When using ScanWithOptions, the term "omit" means that the assignment from the source to the destination
+// is skipped, so the existing value in the destination field is preserved.
+//
+//   - option.OmitEmpty, when set to true, skips assignment of empty source values (for example: empty strings,
+//     zero numeric values, zero time values, empty slices or maps), preserving any existing non-empty values
+//     in the destination.
+//
+//   - option.OmitNil, when set to true, skips assignment of nil source values, preserving the existing values
+//     in the destination when the source contains nil.
+//
+// Example:
+//
+//	type User struct {
+//	    Name  string
+//	    Email string
+//	}
+//
+//	dst := &User{Name: "Alice", Email: "alice@example.com"}
+//	src := map[string]any{
+//	    "Name":  "",
+//	    "Email": nil,
+//	}
+//
+//	// With OmitEmpty and OmitNil, empty and nil values in src will not overwrite dst.
+//	err := ScanWithOptions(src, dst, ScanOption{OmitEmpty: true, OmitNil: true})
+func ScanWithOptions(srcValue any, dstPointer any, option ...ScanOption) (err error) {
+	return defaultConverter.Scan(srcValue, dstPointer, option...)
+}
diff --git a/util/gconv/gconv_slice_bool.go b/util/gconv/gconv_slice_bool.go
new file mode 100644
index 000000000..e7b09df1f
--- /dev/null
+++ b/util/gconv/gconv_slice_bool.go
@@ -0,0 +1,20 @@
+// 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 gconv
+
+// SliceBool is alias of Bools.
+func SliceBool(anyInput any) []bool {
+	return Bools(anyInput)
+}
+
+// Bools converts `any` to []bool.
+func Bools(anyInput any) []bool {
+	result, _ := defaultConverter.SliceBool(anyInput, SliceOption{
+		ContinueOnError: true,
+	})
+	return result
+}
diff --git a/util/gconv/gconv_unsafe.go b/util/gconv/gconv_unsafe.go
index e4b24fdfc..4381ddffc 100644
--- a/util/gconv/gconv_unsafe.go
+++ b/util/gconv/gconv_unsafe.go
@@ -12,12 +12,12 @@ import "unsafe"
 // Note that, if you completely sure you will never use `s` variable in the feature,
 // you can use this unsafe function to implement type conversion in high performance.
 func UnsafeStrToBytes(s string) []byte {
-	return *(*[]byte)(unsafe.Pointer(&s))
+	return unsafe.Slice(unsafe.StringData(s), len(s))
 }
 
 // UnsafeBytesToStr converts []byte to string without memory copy.
 // Note that, if you completely sure you will never use `b` variable in the feature,
 // you can use this unsafe function to implement type conversion in high performance.
 func UnsafeBytesToStr(b []byte) string {
-	return *(*string)(unsafe.Pointer(&b))
+	return unsafe.String(unsafe.SliceData(b), len(b))
 }
diff --git a/util/gconv/gconv_z_unit_bool_test.go b/util/gconv/gconv_z_unit_bool_test.go
index 774af4483..9afa2aafc 100644
--- a/util/gconv/gconv_z_unit_bool_test.go
+++ b/util/gconv/gconv_z_unit_bool_test.go
@@ -71,3 +71,26 @@ func TestBool(t *testing.T) {
 		}
 	})
 }
+
+func TestBools(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		t.AssertEQ(gconv.Bools(nil), nil)
+		t.AssertEQ(gconv.Bools([]bool{true, false}), []bool{true, false})
+		t.AssertEQ(gconv.Bools([]int{1, 0, 2}), []bool{true, false, true})
+		t.AssertEQ(gconv.Bools([]string{"true", "false", "1", "0"}), []bool{true, false, true, false})
+		t.AssertEQ(gconv.Bools([]string{"t", "f", "T", "F"}), []bool{true, false, true, false})
+		t.AssertEQ(gconv.Bools([]string{"True", "False", "TRUE", "FALSE"}), []bool{true, false, true, false})
+		t.AssertEQ(gconv.Bools([]string{"yes", "no", "YES", "NO"}), []bool{true, false, true, false})
+		t.AssertEQ(gconv.Bools([]string{"on", "off", "ON", "OFF"}), []bool{true, false, true, false})
+		t.AssertEQ(gconv.Bools([]any{true, 0, "false", 1}), []bool{true, false, false, true})
+		t.AssertEQ(gconv.Bools(`[true, false, true]`), []bool{true, false, true})
+		t.AssertEQ(gconv.Bools(""), []bool{})
+		t.AssertEQ(gconv.Bools("true"), []bool{true})
+	})
+}
+
+func TestSliceBool(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		t.AssertEQ(gconv.SliceBool([]bool{true, false}), []bool{true, false})
+	})
+}
diff --git a/util/gconv/gconv_z_unit_issue_test.go b/util/gconv/gconv_z_unit_issue_test.go
index bf249383e..76443df9e 100644
--- a/util/gconv/gconv_z_unit_issue_test.go
+++ b/util/gconv/gconv_z_unit_issue_test.go
@@ -805,3 +805,182 @@ func Test_Issue3903(t *testing.T) {
 		t.Assert(a.UserId, 100)
 	})
 }
+
+// https://github.com/gogf/gf/issues/4218
+func Test_Issue4218(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		type SysMenuVo struct {
+			MenuId   int64        `json:"menuId"     orm:"menu_id"`
+			MenuName string       `json:"menuName"   orm:"menu_name"`
+			Children []*SysMenuVo `json:"children"   orm:"children"`
+			ParentId int64        `json:"parentId"   orm:"parent_id"`
+		}
+		menus := []*SysMenuVo{
+			{
+				MenuId:   1,
+				MenuName: "系统管理",
+				ParentId: 0,
+			},
+			{
+				MenuId:   2,
+				MenuName: "字典查询",
+				ParentId: 1,
+			},
+		}
+		var parent *SysMenuVo
+		err := gconv.Scan(menus[0], &parent)
+		t.AssertNil(err)
+		t.Assert(parent.MenuId, 1)
+		t.Assert(parent.ParentId, 0)
+
+		parent.Children = append(parent.Children, menus[1])
+
+		t.Assert(len(menus[0].Children), 1)
+		t.Assert(menus[0].Children[0].MenuId, 2)
+		t.Assert(menus[0].Children[0].ParentId, 1)
+	})
+}
+
+// https://github.com/gogf/gf/issues/4542
+func Test_Issue4542(t *testing.T) {
+	// Test case 1: Nested map conversion - map[string]any to map[string]map[string]float64
+	// This is the original bug report scenario
+	gtest.C(t, func(t *gtest.T) {
+		type ExchangeRate map[string]map[string]float64
+
+		// Source data from JSON unmarshalling (nested map[string]any)
+		source := map[string]any{
+			"USD": map[string]any{
+				"CNY": 7.0,
+				"EUR": 0.85,
+			},
+			"EUR": map[string]any{
+				"CNY": 8.2,
+				"USD": 1.18,
+			},
+		}
+
+		var exchangeRate ExchangeRate
+		err := gconv.Scan(source, &exchangeRate)
+		t.AssertNil(err)
+		t.Assert(len(exchangeRate), 2)
+		t.Assert(len(exchangeRate["USD"]), 2)
+		t.Assert(exchangeRate["USD"]["CNY"], 7.0)
+		t.Assert(exchangeRate["USD"]["EUR"], 0.85)
+		t.Assert(exchangeRate["EUR"]["CNY"], 8.2)
+		t.Assert(exchangeRate["EUR"]["USD"], 1.18)
+	})
+
+	// Test case 2: Deeply nested map conversion (3 levels)
+	// Verifies recursion terminates correctly at base types
+	gtest.C(t, func(t *gtest.T) {
+		type DeepMap map[string]map[string]map[string]int
+
+		source := map[string]any{
+			"level1": map[string]any{
+				"level2": map[string]any{
+					"level3": 100,
+				},
+			},
+		}
+
+		var deepMap DeepMap
+		err := gconv.Scan(source, &deepMap)
+		t.AssertNil(err)
+		t.Assert(deepMap["level1"]["level2"]["level3"], 100)
+	})
+
+	// Test case 3: Map with different key types
+	gtest.C(t, func(t *gtest.T) {
+		source := map[string]any{
+			"1": map[string]any{
+				"value": 100,
+			},
+			"2": map[string]any{
+				"value": 200,
+			},
+		}
+
+		var result map[int]map[string]int
+		err := gconv.Scan(source, &result)
+		t.AssertNil(err)
+		t.Assert(result[1]["value"], 100)
+		t.Assert(result[2]["value"], 200)
+	})
+
+	// Test case 4: Empty nested map - verifies recursion terminates on empty map
+	gtest.C(t, func(t *gtest.T) {
+		source := map[string]any{
+			"USD": map[string]any{},
+		}
+
+		var result map[string]map[string]float64
+		err := gconv.Scan(source, &result)
+		t.AssertNil(err)
+		t.Assert(len(result), 1)
+		t.Assert(len(result["USD"]), 0)
+	})
+
+	// Test case 5: Mixed struct and map in nested structure
+	// Verifies struct conversion still works (no regression)
+	gtest.C(t, func(t *gtest.T) {
+		type Config struct {
+			Name  string
+			Value int
+		}
+
+		source := map[string]any{
+			"config1": map[string]any{
+				"Name":  "test1",
+				"Value": 100,
+			},
+			"config2": map[string]any{
+				"Name":  "test2",
+				"Value": 200,
+			},
+		}
+
+		// Map value is struct - should still work
+		var result map[string]Config
+		err := gconv.Scan(source, &result)
+		t.AssertNil(err)
+		t.Assert(result["config1"].Name, "test1")
+		t.Assert(result["config1"].Value, 100)
+		t.Assert(result["config2"].Name, "test2")
+		t.Assert(result["config2"].Value, 200)
+	})
+
+	// Test case 6: Very deep nesting (5 levels) - stress test for recursion
+	gtest.C(t, func(t *gtest.T) {
+		source := map[string]any{
+			"l1": map[string]any{
+				"l2": map[string]any{
+					"l3": map[string]any{
+						"l4": map[string]any{
+							"l5": "deep_value",
+						},
+					},
+				},
+			},
+		}
+
+		var result map[string]map[string]map[string]map[string]map[string]string
+		err := gconv.Scan(source, &result)
+		t.AssertNil(err)
+		t.Assert(result["l1"]["l2"]["l3"]["l4"]["l5"], "deep_value")
+	})
+
+	// Test case 7: Source value is not a map (should be converted first)
+	// Verifies no infinite recursion when source doesn't match expected structure
+	gtest.C(t, func(t *gtest.T) {
+		source := map[string]any{
+			"key": "not_a_map",
+		}
+
+		var result map[string]map[string]string
+		err := gconv.Scan(source, &result)
+		// This should not cause infinite recursion, but conversion may fail or return empty
+		// The key point is it should not hang
+		t.AssertNil(err)
+	})
+}
diff --git a/util/gconv/gconv_z_unit_scan_omit_test.go b/util/gconv/gconv_z_unit_scan_omit_test.go
new file mode 100644
index 000000000..8fa8e75fa
--- /dev/null
+++ b/util/gconv/gconv_z_unit_scan_omit_test.go
@@ -0,0 +1,146 @@
+// 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 gconv_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+type User struct {
+	Name  string
+	Age   int
+	Email string
+}
+
+type User2 struct {
+	Name  *string
+	Age   int
+	Email string
+}
+
+type Person struct {
+	Name  string
+	Age   int
+	Email string
+}
+
+func TestScan_OmitEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		user := User{Name: "", Age: 20, Email: ""}
+		person := Person{Name: "zhangsan", Age: 0, Email: "old@example.com"}
+
+		err := gconv.ScanWithOptions(user, &person, gconv.ScanOption{
+			OmitEmpty: true,
+		})
+		t.AssertNil(err)
+		t.Assert(person.Name, "zhangsan")
+		t.Assert(person.Age, 20)
+		t.Assert(person.Email, "old@example.com")
+	})
+}
+
+func TestScan_AllOmitEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		user := User{Name: "", Age: 0, Email: ""}
+		person := Person{Name: "zhangsan", Age: 100, Email: "old@example.com"}
+
+		err := gconv.ScanWithOptions(user, &person, gconv.ScanOption{
+			OmitEmpty: true,
+		})
+		t.AssertNil(err)
+		t.Assert(person.Name, "zhangsan")
+		t.Assert(person.Age, 100)
+		t.Assert(person.Email, "old@example.com")
+	})
+}
+
+func TestScan_OmitNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		data := map[string]any{
+			"Name":  nil,
+			"Age":   30,
+			"Email": nil,
+		}
+		person := Person{Name: "lisi", Age: 0, Email: "old@example.com"}
+
+		err := gconv.ScanWithOptions(data, &person, gconv.ScanOption{
+			OmitNil: true,
+		})
+		t.AssertNil(err)
+		t.Assert(person.Name, "lisi")
+		t.Assert(person.Age, 30)
+		t.Assert(person.Email, "old@example.com")
+	})
+}
+
+func TestScan_OmitEmptyAndOmitNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		data := map[string]any{
+			"Name":  "",
+			"Age":   25,
+			"Email": nil,
+		}
+		person := Person{Name: "wangwu", Age: 0, Email: "old2@example.com"}
+
+		err := gconv.ScanWithOptions(data, &person, gconv.ScanOption{
+			OmitEmpty: true,
+			OmitNil:   true,
+		})
+		t.AssertNil(err)
+		t.Assert(person.Name, "wangwu")
+		t.Assert(person.Age, 25)
+		t.Assert(person.Email, "old2@example.com")
+	})
+}
+
+func TestScan_NoOmitOptions(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		user := User{Name: "", Age: 20, Email: ""}
+		person := Person{Name: "zhangsan", Age: 30, Email: "old@example.com"}
+
+		err := gconv.ScanWithOptions(user, &person, gconv.ScanOption{
+			OmitEmpty: false,
+			OmitNil:   false,
+		})
+		t.AssertNil(err)
+		t.Assert(person.Name, "")
+		t.Assert(person.Age, 20)
+		t.Assert(person.Email, "")
+	})
+}
+
+func TestScan_OriginalBehavior(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		user := User{Name: "newname", Age: 25, Email: "new@example.com"}
+		person := Person{Name: "", Age: 0, Email: ""}
+
+		err := gconv.Scan(user, &person)
+		t.AssertNil(err)
+		t.Assert(person.Name, "newname")
+		t.Assert(person.Age, 25)
+		t.Assert(person.Email, "new@example.com")
+	})
+}
+
+func TestScan_StructOmitEmptyAndOmitNilOptions(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		user2 := User2{Name: nil, Age: 25, Email: ""}
+		person := Person{Name: "wangwu", Age: 0, Email: "old2@example.com"}
+
+		err := gconv.ScanWithOptions(user2, &person, gconv.ScanOption{
+			OmitEmpty: true,
+			OmitNil:   true,
+		})
+		t.AssertNil(err)
+		t.Assert(person.Name, "wangwu")
+		t.Assert(person.Age, 25)
+		t.Assert(person.Email, "old2@example.com")
+	})
+}
diff --git a/util/gconv/internal/converter/converter_bool.go b/util/gconv/internal/converter/converter_bool.go
index ae1cb4afd..60bceda06 100644
--- a/util/gconv/internal/converter/converter_bool.go
+++ b/util/gconv/internal/converter/converter_bool.go
@@ -8,6 +8,7 @@ package converter
 
 import (
 	"reflect"
+	"strconv"
 	"strings"
 
 	"github.com/gogf/gf/v2/internal/empty"
@@ -23,11 +24,17 @@ func (c *Converter) Bool(anyInput any) (bool, error) {
 	case bool:
 		return value, nil
 	case []byte:
+		if parsed, err := strconv.ParseBool(string(value)); err == nil {
+			return parsed, nil
+		}
 		if _, ok := emptyStringMap[strings.ToLower(string(value))]; ok {
 			return false, nil
 		}
 		return true, nil
 	case string:
+		if parsed, err := strconv.ParseBool(value); err == nil {
+			return parsed, nil
+		}
 		if _, ok := emptyStringMap[strings.ToLower(value)]; ok {
 			return false, nil
 		}
diff --git a/util/gconv/internal/converter/converter_maptomap.go b/util/gconv/internal/converter/converter_maptomap.go
index 6e5755cea..0f47e3db5 100644
--- a/util/gconv/internal/converter/converter_maptomap.go
+++ b/util/gconv/internal/converter/converter_maptomap.go
@@ -99,7 +99,12 @@ func (c *Converter) MapToMap(
 	for _, key := range paramsKeys {
 		mapValue := reflect.New(pointerValueType).Elem()
 		switch pointerValueKind {
-		case reflect.Map, reflect.Struct:
+		case reflect.Map:
+			// For nested map types, recursively call MapToMap.
+			if err = c.MapToMap(paramsRv.MapIndex(key).Interface(), mapValue.Addr().Interface(), mapping, option...); err != nil {
+				return err
+			}
+		case reflect.Struct:
 			structOption := StructOption{
 				ParamKeyToAttrMap: mapping,
 				PriorityTag:       "",
diff --git a/util/gconv/internal/converter/converter_scan.go b/util/gconv/internal/converter/converter_scan.go
index 6a8e8c4b4..feb7cadcb 100644
--- a/util/gconv/internal/converter/converter_scan.go
+++ b/util/gconv/internal/converter/converter_scan.go
@@ -23,6 +23,15 @@ type ScanOption struct {
 	// ContinueOnError specifies whether to continue converting the next element
 	// if one element converting fails.
 	ContinueOnError bool
+
+	// OmitEmpty specifies whether to skip assignment when the source value is empty
+	// (empty string, zero value, etc.), preserving the existing value in the
+	// destination field.
+	OmitEmpty bool
+
+	// OmitNil specifies whether to skip assignment when the source value is nil,
+	// preserving the existing value in the destination field.
+	OmitNil bool
 }
 
 func (c *Converter) getScanOption(option ...ScanOption) ScanOption {
@@ -87,11 +96,14 @@ func (c *Converter) Scan(srcValue any, dstPointer any, option ...ScanOption) (er
 	}
 
 	// Get the element type and kind of dstPointer
-	var (
-		dstPointerReflectValueElem     = dstPointerReflectValue.Elem()
-		dstPointerReflectValueElemKind = dstPointerReflectValueElem.Kind()
-	)
+	var dstPointerReflectValueElem = dstPointerReflectValue.Elem()
+	// Check if srcValue and dstPointer are the same type, in which case direct assignment can be performed
+	if ok := c.doConvertWithTypeCheck(srcValueReflectValue, dstPointerReflectValueElem); ok {
+		return nil
+	}
+
 	// Handle multiple level pointers
+	var dstPointerReflectValueElemKind = dstPointerReflectValueElem.Kind()
 	if dstPointerReflectValueElemKind == reflect.Pointer {
 		if dstPointerReflectValueElem.IsNil() {
 			// Create a new value for the pointer dereference
@@ -105,11 +117,6 @@ func (c *Converter) Scan(srcValue any, dstPointer any, option ...ScanOption) (er
 		return c.Scan(srcValueReflectValue, dstPointerReflectValueElem, option...)
 	}
 
-	// Check if srcValue and dstPointer are the same type, in which case direct assignment can be performed
-	if ok := c.doConvertWithTypeCheck(srcValueReflectValue, dstPointerReflectValueElem); ok {
-		return nil
-	}
-
 	scanOption := c.getScanOption(option...)
 	// Handle different destination types
 	switch dstPointerReflectValueElemKind {
@@ -292,6 +299,8 @@ func (c *Converter) doScanForComplicatedTypes(
 			mapOption = StructOption{
 				ParamKeyToAttrMap: keyToAttributeNameMapping,
 				ContinueOnError:   option.ContinueOnError,
+				OmitEmpty:         option.OmitEmpty,
+				OmitNil:           option.OmitNil,
 			}
 		)
 		return c.Structs(srcValue, dstPointer, StructsOption{
@@ -304,6 +313,8 @@ func (c *Converter) doScanForComplicatedTypes(
 			ParamKeyToAttrMap: keyToAttributeNameMapping,
 			PriorityTag:       "",
 			ContinueOnError:   option.ContinueOnError,
+			OmitEmpty:         option.OmitEmpty,
+			OmitNil:           option.OmitNil,
 		}
 		return c.Struct(srcValue, dstPointer, structOption)
 	}
diff --git a/util/gconv/internal/converter/converter_slice_bool.go b/util/gconv/internal/converter/converter_slice_bool.go
new file mode 100644
index 000000000..e0f398bd0
--- /dev/null
+++ b/util/gconv/internal/converter/converter_slice_bool.go
@@ -0,0 +1,173 @@
+// 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 converter
+
+import (
+	"reflect"
+
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/reflection"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// SliceBool converts `any` to []bool.
+func (c *Converter) SliceBool(anyInput any, option ...SliceOption) ([]bool, error) {
+	if empty.IsNil(anyInput) {
+		return nil, nil
+	}
+	var (
+		err         error
+		bb          bool
+		array       []bool
+		sliceOption = c.getSliceOption(option...)
+	)
+	switch value := anyInput.(type) {
+	case []string:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			bb, err = c.Bool(v)
+			if err != nil && !sliceOption.ContinueOnError {
+				return nil, err
+			}
+			array[k] = bb
+		}
+	case []int:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			array[k] = v != 0
+		}
+	case []int8:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			array[k] = v != 0
+		}
+	case []int16:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			array[k] = v != 0
+		}
+	case []int32:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			array[k] = v != 0
+		}
+	case []int64:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			array[k] = v != 0
+		}
+	case []uint:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			array[k] = v != 0
+		}
+	case []uint8:
+		if json.Valid(value) {
+			if err = json.UnmarshalUseNumber(value, &array); array != nil {
+				return array, err
+			}
+		}
+		array = make([]bool, len(value))
+		for k, v := range value {
+			array[k] = v != 0
+		}
+	case []uint16:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			array[k] = v != 0
+		}
+	case []uint32:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			array[k] = v != 0
+		}
+	case []uint64:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			array[k] = v != 0
+		}
+	case []bool:
+		array = value
+	case []float32:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			array[k] = v != 0
+		}
+	case []float64:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			array[k] = v != 0
+		}
+	case []any:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			bb, err = c.Bool(v)
+			if err != nil && !sliceOption.ContinueOnError {
+				return nil, err
+			}
+			array[k] = bb
+		}
+	case [][]byte:
+		array = make([]bool, len(value))
+		for k, v := range value {
+			bb, err = c.Bool(v)
+			if err != nil && !sliceOption.ContinueOnError {
+				return nil, err
+			}
+			array[k] = bb
+		}
+	case string:
+		byteValue := []byte(value)
+		if json.Valid(byteValue) {
+			if err = json.UnmarshalUseNumber(byteValue, &array); array != nil {
+				return array, err
+			}
+		}
+		if value == "" {
+			return []bool{}, err
+		}
+		bb, err = c.Bool(value)
+		if err != nil && !sliceOption.ContinueOnError {
+			return nil, err
+		}
+		return []bool{bb}, err
+	}
+	if array != nil {
+		return array, err
+	}
+	if v, ok := anyInput.(localinterface.IInterfaces); ok {
+		return c.SliceBool(v.Interfaces(), option...)
+	}
+	// Not a common type, it then uses reflection for conversion.
+	originValueAndKind := reflection.OriginValueAndKind(anyInput)
+	switch originValueAndKind.OriginKind {
+	case reflect.Slice, reflect.Array:
+		var (
+			length = originValueAndKind.OriginValue.Len()
+			slice  = make([]bool, length)
+		)
+		for i := 0; i < length; i++ {
+			bb, err = c.Bool(originValueAndKind.OriginValue.Index(i).Interface())
+			if err != nil && !sliceOption.ContinueOnError {
+				return nil, err
+			}
+			slice[i] = bb
+		}
+		return slice, err
+
+	default:
+		if originValueAndKind.OriginValue.IsZero() {
+			return []bool{}, err
+		}
+		bb, err = c.Bool(anyInput)
+		if err != nil && !sliceOption.ContinueOnError {
+			return nil, err
+		}
+		return []bool{bb}, err
+	}
+}
diff --git a/util/gconv/internal/converter/converter_struct.go b/util/gconv/internal/converter/converter_struct.go
index 0f7bd357e..b4376660e 100644
--- a/util/gconv/internal/converter/converter_struct.go
+++ b/util/gconv/internal/converter/converter_struct.go
@@ -30,6 +30,15 @@ type StructOption struct {
 	// ContinueOnError specifies whether to continue converting the next element
 	// if one element converting fails.
 	ContinueOnError bool
+
+	// OmitEmpty specifies whether to skip assignment when the source value is empty
+	// (empty string, zero value, etc.), preserving the existing value in the
+	// destination field.
+	OmitEmpty bool
+
+	// OmitNil specifies whether to skip assignment when the source value is nil,
+	// preserving the existing value in the destination field.
+	OmitNil bool
 }
 
 func (c *Converter) getStructOption(option ...StructOption) StructOption {
@@ -364,6 +373,13 @@ func (c *Converter) bindVarToStructField(
 			}
 		}
 	}()
+	// Check if the value should be omitted based on OmitEmpty or OmitNil options
+	if option.OmitNil && empty.IsNil(srcValue) {
+		return nil
+	}
+	if option.OmitEmpty && empty.IsEmpty(srcValue) {
+		return nil
+	}
 	// Directly converting.
 	if empty.IsNil(srcValue) {
 		fieldValue.Set(reflect.Zero(fieldValue.Type()))
diff --git a/util/gutil/gutil_comparator.go b/util/gutil/gutil_comparator.go
index a5e73d41a..2591b0d60 100644
--- a/util/gutil/gutil_comparator.go
+++ b/util/gutil/gutil_comparator.go
@@ -7,6 +7,7 @@
 package gutil
 
 import (
+	"cmp"
 	"strings"
 
 	"github.com/gogf/gf/v2/util/gconv"
@@ -125,3 +126,12 @@ func ComparatorTime(a, b any) int {
 		return 0
 	}
 }
+
+// ComparatorT provides a generic comparison for ordered types.
+func ComparatorT[T cmp.Ordered](a, b T) int {
+	return cmp.Compare(a, b)
+}
+
+func ComparatorTStr[T any](a, b T) int {
+	return cmp.Compare(gconv.String(a), gconv.String(b))
+}
diff --git a/util/gutil/gutil_dump.go b/util/gutil/gutil_dump.go
index 7aca81b5d..018a46986 100644
--- a/util/gutil/gutil_dump.go
+++ b/util/gutil/gutil_dump.go
@@ -308,8 +308,10 @@ func doDumpStruct(in doDumpInternalInput) {
 			fmt.Fprintf(in.Buffer, `<cycle dump %s>`, in.PtrAddress)
 			return
 		}
+		// Add to set and remove when function returns (path-based cycle detection).
+		in.DumpedPointerSet[in.PtrAddress] = struct{}{}
+		defer delete(in.DumpedPointerSet, in.PtrAddress)
 	}
-	in.DumpedPointerSet[in.PtrAddress] = struct{}{}
 
 	structFields, _ := gstructs.Fields(gstructs.FieldsInput{
 		Pointer:         in.Value,
diff --git a/util/gutil/gutil_z_unit_dump_test.go b/util/gutil/gutil_z_unit_dump_test.go
index 04a966500..8ddffa8a2 100755
--- a/util/gutil/gutil_z_unit_dump_test.go
+++ b/util/gutil/gutil_z_unit_dump_test.go
@@ -13,6 +13,7 @@ import (
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/net/ghttp"
+	"github.com/gogf/gf/v2/os/gstructs"
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/text/gstr"
@@ -295,3 +296,95 @@ func Test_DumpJson(t *testing.T) {
 		gutil.DumpJson(jsonContent)
 	})
 }
+
+// https://github.com/gogf/gf/issues/2902
+func Test_Dump_Issue2902_SharedPointer(t *testing.T) {
+	type Inner struct {
+		Value int
+	}
+	type Outer struct {
+		A *Inner
+		B *Inner
+	}
+	gtest.C(t, func(t *gtest.T) {
+		// Shared pointer (not a cycle) should not be marked as cycle dump.
+		shared := &Inner{Value: 100}
+		data := Outer{A: shared, B: shared}
+		buffer := bytes.NewBuffer(nil)
+		g.DumpTo(buffer, data, gutil.DumpOption{})
+		output := buffer.String()
+		// The second field should show the actual value, not "cycle dump".
+		// Both fields point to the same object, but it's not a cycle.
+		t.Assert(gstr.Contains(output, "cycle"), false)
+		t.Assert(gstr.Count(output, "Value"), 2)
+		t.Assert(gstr.Count(output, "100"), 2)
+	})
+}
+
+// https://github.com/gogf/gf/issues/2902
+func Test_Dump_Issue2902_SameTypeFields(t *testing.T) {
+	type User struct {
+		Id   int `params:"id"`
+		Name int `params:"name"`
+	}
+	gtest.C(t, func(t *gtest.T) {
+		// Fields with same type (e.g., both are int) share the same reflect.Type,
+		// which should not be marked as cycle dump.
+		var user User
+		fields, _ := gstructs.TagFields(&user, []string{"p", "params"})
+		buffer := bytes.NewBuffer(nil)
+		g.DumpTo(buffer, fields, gutil.DumpOption{})
+		output := buffer.String()
+		// Both fields' Type should show "int", not "cycle dump".
+		t.Assert(gstr.Contains(output, "cycle"), false)
+		t.Assert(gstr.Count(output, `Type:`), 2)
+	})
+}
+
+type benchStruct struct {
+	A int
+	B string
+	C *benchStruct
+	D []int
+	E map[string]int
+}
+
+func createBenchNested(depth int) *benchStruct {
+	if depth <= 0 {
+		return nil
+	}
+	return &benchStruct{
+		A: depth,
+		B: "test",
+		C: createBenchNested(depth - 1),
+		D: []int{1, 2, 3, 4, 5},
+		E: map[string]int{"x": 1, "y": 2},
+	}
+}
+
+var (
+	benchShallow  = &benchStruct{A: 1, B: "test", D: []int{1, 2, 3}, E: map[string]int{"a": 1}}
+	benchNested20 = createBenchNested(20)
+	benchDeep50   = createBenchNested(50)
+)
+
+func Benchmark_Dump_Shallow(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		var buf bytes.Buffer
+		gutil.DumpTo(&buf, benchShallow, gutil.DumpOption{})
+	}
+}
+
+func Benchmark_Dump_Nested20(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		var buf bytes.Buffer
+		gutil.DumpTo(&buf, benchNested20, gutil.DumpOption{})
+	}
+}
+
+func Benchmark_Dump_Deep50(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		var buf bytes.Buffer
+		gutil.DumpTo(&buf, benchDeep50, gutil.DumpOption{})
+	}
+}
diff --git a/util/gvalid/gvalid.go b/util/gvalid/gvalid.go
index 534899076..0559210d2 100644
--- a/util/gvalid/gvalid.go
+++ b/util/gvalid/gvalid.go
@@ -91,7 +91,7 @@ var (
 // The sequence tag is like: [alias@]rule[...#msg...]
 func ParseTagValue(tag string) (field, rule, msg string) {
 	// Complete sequence tag.
-	// Example: name@required|length:2,20|password3|same:password1#||密码强度不足 | 两次密码不一致
+	// Example: name@required|length:2,20|password3|same:password1#||Password strength is insufficient | Passwords are not match
 	match, _ := gregex.MatchString(`\s*((\w+)\s*@){0,1}\s*([^#]+)\s*(#\s*(.*)){0,1}\s*`, tag)
 	if len(match) > 5 {
 		msg = strings.TrimSpace(match[5])
diff --git a/util/gvalid/gvalid_validator_check_struct.go b/util/gvalid/gvalid_validator_check_struct.go
index a6bf353d1..5370570f9 100644
--- a/util/gvalid/gvalid_validator_check_struct.go
+++ b/util/gvalid/gvalid_validator_check_struct.go
@@ -138,7 +138,7 @@ func (v *Validator) doCheckStruct(ctx context.Context, object any) Error {
 				name = value
 			} else {
 				// It or else uses the attribute name directly.
-				name = fieldName
+				name = field.TagPriorityName()
 			}
 		} else {
 			// It uses the alias name from validation rule.
diff --git a/util/gvalid/gvalid_z_example_feature_rule_test.go b/util/gvalid/gvalid_z_example_feature_rule_test.go
index f458dcc65..399c71fd7 100644
--- a/util/gvalid/gvalid_z_example_feature_rule_test.go
+++ b/util/gvalid/gvalid_z_example_feature_rule_test.go
@@ -954,8 +954,8 @@ func ExampleValidator_json() {
 	var (
 		ctx = context.Background()
 		req = BizReq{
-			JSON1: "{\"name\":\"goframe\",\"author\":\"郭强\"}",
-			JSON2: "{\"name\":\"goframe\",\"author\":\"郭强\",\"test\"}",
+			JSON1: "{\"name\":\"goframe\",\"author\":\"Guo Qiang\"}",
+			JSON2: "{\"name\":\"goframe\",\"author\":\"Guo Qiang\",\"test\"}",
 		}
 	)
 	if err := g.Validator().Data(req).Run(ctx); err != nil {
@@ -963,7 +963,7 @@ func ExampleValidator_json() {
 	}
 
 	// Output:
-	// The JSON2 value `{"name":"goframe","author":"郭强","test"}` is not a valid JSON string
+	// The JSON2 value `{"name":"goframe","author":"Guo Qiang","test"}` is not a valid JSON string
 }
 
 func ExampleValidator_integer() {
diff --git a/util/gvalid/gvalid_z_example_test.go b/util/gvalid/gvalid_z_example_test.go
index 52631ef77..5d56a8f8c 100644
--- a/util/gvalid/gvalid_z_example_test.go
+++ b/util/gvalid/gvalid_z_example_test.go
@@ -217,9 +217,9 @@ func ExampleValidator_Data_map1() {
 		fmt.Println(e.FirstError())
 	}
 	// May Output:
-	// map[required:账号不能为空 length:账号长度应当在 6 到 16 之间]
-	// passport map[required:账号不能为空 length:账号长度应当在 6 到 16 之间]
-	// 账号不能为空
+	// map[required:The passport field is required length:The passport value `` length must be between 6 and 16]
+	// passport map[required:The passport field is required length:The passport value `` length must be between 6 and 16]
+	// The passport field is required
 }
 
 func ExampleValidator_Data_map2() {
@@ -273,11 +273,11 @@ func ExampleValidator_Data_map3() {
 	// May Output:
 	// {
 	//	"passport": {
-	//	"length": "账号长度应当在 6 到 16 之间",
-	//		"required": "账号不能为空"
+	//	"length": "The passport value `` length must be between 6 and 16",
+	//		"required": "The passport field is required"
 	// },
 	//	"password": {
-	//	"same": "两次密码输入不相等"
+	//	"same": "The password value `123456` must be the same as field password2 value `1234567`"
 	// }
 	// }
 }
@@ -521,5 +521,5 @@ func ExampleValidator_registerRule() {
 	err := g.Validator().Data(user).Run(gctx.New())
 	fmt.Println(err.Error())
 	// May Output:
-	// 用户名称已被占用
+	// The Name value `john` is not unique
 }
diff --git a/util/gvalid/gvalid_z_unit_feature_rule_test.go b/util/gvalid/gvalid_z_unit_feature_rule_test.go
index f9ffbb903..da6f94898 100755
--- a/util/gvalid/gvalid_z_unit_feature_rule_test.go
+++ b/util/gvalid/gvalid_z_unit_feature_rule_test.go
@@ -270,31 +270,24 @@ func Test_RequiredWithOutAll(t *testing.T) {
 
 func Test_Date(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "date"
-		val1 := "2010"
-		val2 := "201011"
-		val3 := "20101101"
-		val4 := "2010-11-01"
-		val5 := "2010.11.01"
-		val6 := "2010/11/01"
-		val7 := "2010=11=01"
-		val8 := "123"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		err6 := g.Validator().Data(val6).Rules(rule).Run(ctx)
-		err7 := g.Validator().Data(val7).Rules(rule).Run(ctx)
-		err8 := g.Validator().Data(val8).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
-		t.Assert(err5, nil)
-		t.Assert(err6, nil)
-		t.AssertNE(err7, nil)
-		t.AssertNE(err8, nil)
+		m := g.MapStrBool{
+			"2010":       false,
+			"201011":     false,
+			"20101101":   true,
+			"2010-11-01": true,
+			"2010.11.01": true,
+			"2010/11/01": true,
+			"2010=11=01": false,
+			"123":        false,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("date").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
@@ -356,232 +349,238 @@ func Test_DateFormat(t *testing.T) {
 
 func Test_Email(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "email"
-		value1 := "m@johngcn"
-		value2 := "m@www@johngcn"
-		value3 := "m-m_m@mail.johng.cn"
-		value4 := "m.m-m@johng.cn"
-		err1 := g.Validator().Data(value1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(value2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(value3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(value4).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
+		m := g.MapStrBool{
+			"m@johngcn":           false,
+			"m@www@johngcn":       false,
+			"m-m_m@mail.johng.cn": true,
+			"m.m-m@johng.cn":      true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("email").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_Phone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		err1 := g.Validator().Data("1361990897").Rules("phone").Run(ctx)
-		err2 := g.Validator().Data("13619908979").Rules("phone").Run(ctx)
-		err3 := g.Validator().Data("16719908979").Rules("phone").Run(ctx)
-		err4 := g.Validator().Data("19719908989").Rules("phone").Run(ctx)
-		t.AssertNE(err1.String(), nil)
-		t.Assert(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
+		m := g.MapStrBool{
+			"1361990897":  false,
+			"13619908979": true,
+			"16719908979": true,
+			"19719908989": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("phone").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_PhoneLoose(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		err1 := g.Validator().Data("13333333333").Rules("phone-loose").Run(ctx)
-		err2 := g.Validator().Data("15555555555").Rules("phone-loose").Run(ctx)
-		err3 := g.Validator().Data("16666666666").Rules("phone-loose").Run(ctx)
-		err4 := g.Validator().Data("23333333333").Rules("phone-loose").Run(ctx)
-		err5 := g.Validator().Data("1333333333").Rules("phone-loose").Run(ctx)
-		err6 := g.Validator().Data("10333333333").Rules("phone-loose").Run(ctx)
-		t.Assert(err1, nil)
-		t.Assert(err2, nil)
-		t.Assert(err3, nil)
-		t.AssertNE(err4, nil)
-		t.AssertNE(err5, nil)
-		t.AssertNE(err6, nil)
+		m := g.MapStrBool{
+			"13333333333": true,
+			"15555555555": true,
+			"16666666666": true,
+			"23333333333": false,
+			"1333333333":  false,
+			"10333333333": false,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("phone-loose").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_Telephone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "telephone"
-		val1 := "869265"
-		val2 := "028-869265"
-		val3 := "86292651"
-		val4 := "028-8692651"
-		val5 := "0830-8692651"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
-		t.Assert(err5, nil)
+		m := g.MapStrBool{
+			"869265":       false,
+			"028-869265":   false,
+			"86292651":     true,
+			"028-8692651":  true,
+			"0830-8692651": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("telephone").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_Passport(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "passport"
-		val1 := "123456"
-		val2 := "a12345-6"
-		val3 := "aaaaa"
-		val4 := "aaaaaa"
-		val5 := "a123_456"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.AssertNE(err3, nil)
-		t.Assert(err4, nil)
-		t.Assert(err5, nil)
+		m := g.MapStrBool{
+			"123456":   false,
+			"a12345-6": false,
+			"aaaaa":    false,
+			"aaaaaa":   true,
+			"a123_456": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("passport").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_Password(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "password"
-		val1 := "12345"
-		val2 := "aaaaa"
-		val3 := "a12345-6"
-		val4 := ">,/;'[09-"
-		val5 := "a123_456"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
-		t.Assert(err5, nil)
+		m := g.MapStrBool{
+			"12345":     false,
+			"aaaaa":     false,
+			"a12345-6":  true,
+			">,/;'[09-": true,
+			"a123_456":  true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("password").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_Password2(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "password2"
-		val1 := "12345"
-		val2 := "Naaaa"
-		val3 := "a12345-6"
-		val4 := ">,/;'[09-"
-		val5 := "a123_456"
-		val6 := "Nant1986"
-		val7 := "Nant1986!"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		err6 := g.Validator().Data(val6).Rules(rule).Run(ctx)
-		err7 := g.Validator().Data(val7).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.AssertNE(err3, nil)
-		t.AssertNE(err4, nil)
-		t.AssertNE(err5, nil)
-		t.Assert(err6, nil)
-		t.Assert(err7, nil)
+		m := g.MapStrBool{
+			"12345":     false,
+			"Naaaa":     false,
+			"a12345-6":  false,
+			">,/;'[09-": false,
+			"a123_456":  false,
+			"Nant1986":  true,
+			"Nant1986!": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("password2").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_Password3(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "password3"
-		val1 := "12345"
-		val2 := "Naaaa"
-		val3 := "a12345-6"
-		val4 := ">,/;'[09-"
-		val5 := "a123_456"
-		val6 := "Nant1986"
-		val7 := "Nant1986!"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		err6 := g.Validator().Data(val6).Rules(rule).Run(ctx)
-		err7 := g.Validator().Data(val7).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.AssertNE(err3, nil)
-		t.AssertNE(err4, nil)
-		t.AssertNE(err5, nil)
-		t.AssertNE(err6, nil)
-		t.Assert(err7, nil)
+		m := g.MapStrBool{
+			"12345":     false,
+			"Naaaa":     false,
+			"a12345-6":  false,
+			">,/;'[09-": false,
+			"a123_456":  false,
+			"Nant1986":  false,
+			"Nant1986!": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("password3").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_Postcode(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "postcode"
-		val1 := "12345"
-		val2 := "610036"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.Assert(err2, nil)
+		m := g.MapStrBool{
+			"12345":  false,
+			"610036": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("postcode").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_ResidentId(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "resident-id"
-		val1 := "11111111111111"
-		val2 := "1111111111111111"
-		val3 := "311128500121201"
-		val4 := "510521198607185367"
-		val5 := "51052119860718536x"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.AssertNE(err3, nil)
-		t.AssertNE(err4, nil)
-		t.Assert(err5, nil)
+		m := g.MapStrBool{
+			"11111111111111":     false,
+			"1111111111111111":   false,
+			"311128500121201":    false,
+			"510521198607185367": false,
+			"51052119860718536x": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("resident-id").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_BankCard(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "bank-card"
-		val1 := "6230514630000424470"
-		val2 := "6230514630000424473"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.Assert(err2, nil)
+		m := g.MapStrBool{
+			"6230514630000424470": false,
+			"6230514630000424473": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("bank-card").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_QQ(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "qq"
-		val1 := "100"
-		val2 := "1"
-		val3 := "10000"
-		val4 := "38996181"
-		val5 := "389961817"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
-		t.Assert(err5, nil)
+		m := g.MapStrBool{
+			"100":       false,
+			"1":         false,
+			"10000":     true,
+			"38996181":  true,
+			"389961817": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("qq").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
@@ -617,76 +616,78 @@ func Test_Ip(t *testing.T) {
 
 func Test_IPv4(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "ipv4"
-		val1 := "0.0.0"
-		val2 := "0.0.0.0"
-		val3 := "1.1.1.1"
-		val4 := "255.255.255.0"
-		val5 := "127.0.0.1"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.Assert(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
-		t.Assert(err5, nil)
+		m := g.MapStrBool{
+			"0.0.0":         false,
+			"0.0.0.0":       true,
+			"1.1.1.1":       true,
+			"255.255.255.0": true,
+			"127.0.0.1":     true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("ipv4").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_IPv6(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "ipv6"
-		val1 := "192.168.1.1"
-		val2 := "CDCD:910A:2222:5498:8475:1111:3900:2020"
-		val3 := "1030::C9B4:FF12:48AA:1A2B"
-		val4 := "2000:0:0:0:0:0:0:1"
-		val5 := "0000:0000:0000:0000:0000:ffff:c0a8:5909"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.Assert(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
-		t.Assert(err5, nil)
+		m := g.MapStrBool{
+			"192.168.1.1": false,
+			"CDCD:910A:2222:5498:8475:1111:3900:2020": true,
+			"1030::C9B4:FF12:48AA:1A2B":               true,
+			"2000:0:0:0:0:0:0:1":                      true,
+			"0000:0000:0000:0000:0000:ffff:c0a8:5909": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("ipv6").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_MAC(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "mac"
-		val1 := "192.168.1.1"
-		val2 := "44-45-53-54-00-00"
-		val3 := "01:00:5e:00:00:00"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.Assert(err2, nil)
-		t.Assert(err3, nil)
+		m := g.MapStrBool{
+			"192.168.1.1":       false,
+			"44-45-53-54-00-00": true,
+			"01:00:5e:00:00:00": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("mac").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_URL(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "url"
-		val1 := "127.0.0.1"
-		val2 := "https://www.baidu.com"
-		val3 := "http://127.0.0.1"
-		val4 := "file:///tmp/test.txt"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.Assert(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
+		m := g.MapStrBool{
+			"127.0.0.1":             false,
+			"https://www.baidu.com": true,
+			"http://127.0.0.1":      true,
+			"file:///tmp/test.txt":  true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("url").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
@@ -798,290 +799,275 @@ func Test_Between(t *testing.T) {
 
 func Test_Min(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "min:100"
-		val1 := "1"
-		val2 := "99"
-		val3 := "100"
-		val4 := "1000"
-		val5 := "a"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
-		t.AssertNE(err5, nil)
-
-		rule2 := "min:a"
-		err6 := g.Validator().Data(val1).Rules(rule2).Run(ctx)
-		t.AssertNE(err6, nil)
+		m := g.MapStrBool{
+			"1":    false,
+			"99":   false,
+			"100":  true,
+			"1000": true,
+			"a":    false,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("min:100").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
+	})
+	gtest.C(t, func(t *gtest.T) {
+		err := g.Validator().Data("1").Rules("min:a").Run(ctx)
+		t.AssertNE(err, nil)
 	})
 }
 
 func Test_Max(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "max:100"
-		val1 := "1"
-		val2 := "99"
-		val3 := "100"
-		val4 := "1000"
-		val5 := "a"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		t.Assert(err1, nil)
-		t.Assert(err2, nil)
-		t.Assert(err3, nil)
-		t.AssertNE(err4, nil)
-		t.AssertNE(err5, nil)
-
-		rule2 := "max:a"
-		err6 := g.Validator().Data(val1).Rules(rule2).Run(ctx)
-		t.AssertNE(err6, nil)
+		m := g.MapStrBool{
+			"1":    true,
+			"99":   true,
+			"100":  true,
+			"1000": false,
+			"a":    false,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("max:100").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
+	})
+	gtest.C(t, func(t *gtest.T) {
+		err := g.Validator().Data("1").Rules("max:a").Run(ctx)
+		t.AssertNE(err, nil)
 	})
 }
 
 func Test_Json(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "json"
-		val1 := ""
-		val2 := "."
-		val3 := "{}"
-		val4 := "[]"
-		val5 := "[1,2,3,4]"
-		val6 := `{"list":[1,2,3,4]}`
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		err6 := g.Validator().Data(val6).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
-		t.Assert(err5, nil)
-		t.Assert(err6, nil)
+		m := g.MapStrBool{
+			"":                   false,
+			".":                  false,
+			"{}":                 true,
+			"[]":                 true,
+			"[1,2,3,4]":          true,
+			`{"list":[1,2,3,4]}`: true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("json").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_Integer(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "integer"
-		val1 := ""
-		val2 := "1.0"
-		val3 := "001"
-		val4 := "1"
-		val5 := "100"
-		val6 := `999999999`
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		err6 := g.Validator().Data(val6).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
-		t.Assert(err5, nil)
-		t.Assert(err6, nil)
+		m := g.MapStrBool{
+			"":          false,
+			"1.0":       false,
+			"001":       true,
+			"1":         true,
+			"100":       true,
+			"999999999": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("integer").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_Float(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "float"
-		val1 := ""
-		val2 := "a"
-		val3 := "1"
-		val4 := "1.0"
-		val5 := "1.1"
-		val6 := `0.1`
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		err6 := g.Validator().Data(val6).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
-		t.Assert(err5, nil)
-		t.Assert(err6, nil)
+		m := g.MapStrBool{
+			"":    false,
+			"a":   false,
+			"1":   true,
+			"1.0": true,
+			"1.1": true,
+			"0.1": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("float").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_Boolean(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "boolean"
-		val1 := "a"
-		val2 := "-"
-		val3 := ""
-		val4 := "1"
-		val5 := "true"
-		val6 := `off`
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		err5 := g.Validator().Data(val5).Rules(rule).Run(ctx)
-		err6 := g.Validator().Data(val6).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
-		t.Assert(err5, nil)
-		t.Assert(err6, nil)
+		m := g.MapStrBool{
+			"a":    false,
+			"-":    false,
+			"":     true,
+			"1":    true,
+			"true": true,
+			"off":  true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("boolean").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_Same(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "same:id"
-		val1 := "100"
-		params1 := g.Map{
-			"age": 18,
+		type testCase struct {
+			params g.Map
+			pass   bool
 		}
-		params2 := g.Map{
-			"id": 100,
+		cases := []testCase{
+			{g.Map{"age": 18}, false},
+			{g.Map{"id": 100}, true},
+			{g.Map{"id": 100, "name": "john"}, true},
 		}
-		params3 := g.Map{
-			"id":   100,
-			"name": "john",
+		for _, c := range cases {
+			err := g.Validator().Data("100").Assoc(c.params).Rules("same:id").Run(ctx)
+			if c.pass {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
 		}
-		err1 := g.Validator().Data(val1).Assoc(params1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val1).Assoc(params2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val1).Assoc(params3).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.Assert(err2, nil)
-		t.Assert(err3, nil)
 	})
 }
 
 func Test_Different(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "different:id"
-		val1 := "100"
-		params1 := g.Map{
-			"age": 18,
+		type testCase struct {
+			params g.Map
+			pass   bool
 		}
-		params2 := g.Map{
-			"id": 100,
+		cases := []testCase{
+			{g.Map{"age": 18}, true},
+			{g.Map{"id": 100}, false},
+			{g.Map{"id": 100, "name": "john"}, false},
 		}
-		params3 := g.Map{
-			"id":   100,
-			"name": "john",
+		for _, c := range cases {
+			err := g.Validator().Data("100").Assoc(c.params).Rules("different:id").Run(ctx)
+			if c.pass {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
 		}
-		err1 := g.Validator().Data(val1).Assoc(params1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val1).Assoc(params2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val1).Assoc(params3).Rules(rule).Run(ctx)
-		t.Assert(err1, nil)
-		t.AssertNE(err2, nil)
-		t.AssertNE(err3, nil)
 	})
 }
 
 func Test_EQ(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "eq:id"
-		val1 := "100"
-		params1 := g.Map{
-			"age": 18,
+		type testCase struct {
+			params g.Map
+			pass   bool
 		}
-		params2 := g.Map{
-			"id": 100,
+		cases := []testCase{
+			{g.Map{"age": 18}, false},
+			{g.Map{"id": 100}, true},
+			{g.Map{"id": 100, "name": "john"}, true},
 		}
-		params3 := g.Map{
-			"id":   100,
-			"name": "john",
+		for _, c := range cases {
+			err := g.Validator().Data("100").Assoc(c.params).Rules("eq:id").Run(ctx)
+			if c.pass {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
 		}
-		err1 := g.Validator().Data(val1).Assoc(params1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val1).Assoc(params2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val1).Assoc(params3).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.Assert(err2, nil)
-		t.Assert(err3, nil)
 	})
 }
 
 func Test_Not_EQ(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "not-eq:id"
-		val1 := "100"
-		params1 := g.Map{
-			"age": 18,
+		type testCase struct {
+			params g.Map
+			pass   bool
 		}
-		params2 := g.Map{
-			"id": 100,
+		cases := []testCase{
+			{g.Map{"age": 18}, true},
+			{g.Map{"id": 100}, false},
+			{g.Map{"id": 100, "name": "john"}, false},
 		}
-		params3 := g.Map{
-			"id":   100,
-			"name": "john",
+		for _, c := range cases {
+			err := g.Validator().Data("100").Assoc(c.params).Rules("not-eq:id").Run(ctx)
+			if c.pass {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
 		}
-		err1 := g.Validator().Data(val1).Assoc(params1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val1).Assoc(params2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val1).Assoc(params3).Rules(rule).Run(ctx)
-		t.Assert(err1, nil)
-		t.AssertNE(err2, nil)
-		t.AssertNE(err3, nil)
 	})
 }
 
 func Test_In(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "in:100,200"
-		val1 := ""
-		val2 := "1"
-		val3 := "100"
-		val4 := "200"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		t.AssertNE(err1, nil)
-		t.AssertNE(err2, nil)
-		t.Assert(err3, nil)
-		t.Assert(err4, nil)
+		m := g.MapStrBool{
+			"":    false,
+			"1":   false,
+			"100": true,
+			"200": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("in:100,200").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
 func Test_NotIn(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		rule := "not-in:100"
-		val1 := ""
-		val2 := "1"
-		val3 := "100"
-		val4 := "200"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		t.Assert(err1, nil)
-		t.Assert(err2, nil)
-		t.AssertNE(err3, nil)
-		t.Assert(err4, nil)
+		m := g.MapStrBool{
+			"":    true,
+			"1":   true,
+			"100": false,
+			"200": true,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("not-in:100").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 	gtest.C(t, func(t *gtest.T) {
-		rule := "not-in:100,200"
-		val1 := ""
-		val2 := "1"
-		val3 := "100"
-		val4 := "200"
-		err1 := g.Validator().Data(val1).Rules(rule).Run(ctx)
-		err2 := g.Validator().Data(val2).Rules(rule).Run(ctx)
-		err3 := g.Validator().Data(val3).Rules(rule).Run(ctx)
-		err4 := g.Validator().Data(val4).Rules(rule).Run(ctx)
-		t.Assert(err1, nil)
-		t.Assert(err2, nil)
-		t.AssertNE(err3, nil)
-		t.AssertNE(err4, nil)
+		m := g.MapStrBool{
+			"":    true,
+			"1":   true,
+			"100": false,
+			"200": false,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("not-in:100,200").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
 	})
 }
 
@@ -1619,3 +1605,148 @@ func Test_Enums(t *testing.T) {
 		t.AssertNil(err)
 	})
 }
+func Test_Alpha(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := g.MapStrBool{
+			"abc":     true,
+			"ABC":     true,
+			"abcABC":  true,
+			"abc123":  false,
+			"abc-123": false,
+			"abc_123": false,
+			"123":     false,
+			"":        false,
+			"abc def": false,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("alpha").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
+	})
+}
+
+func Test_AlphaDash(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := g.MapStrBool{
+			"abc":          true,
+			"ABC":          true,
+			"abc123":       true,
+			"abc-123":      true,
+			"abc_123":      true,
+			"abc-_123":     true,
+			"abc-_ABC-123": true,
+			"abc 123":      false,
+			"abc@123":      false,
+			"":             false,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("alpha-dash").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
+	})
+}
+
+func Test_AlphaNum(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := g.MapStrBool{
+			"abc":       true,
+			"ABC":       true,
+			"123":       true,
+			"abc123":    true,
+			"ABC123":    true,
+			"abcABC123": true,
+			"abc-123":   false,
+			"abc_123":   false,
+			"abc 123":   false,
+			"":          false,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("alpha-num").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
+	})
+}
+
+func Test_Lowercase(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := g.MapStrBool{
+			"abc":     true,
+			"abcdef":  true,
+			"ABC":     false,
+			"Abc":     false,
+			"aBc":     false,
+			"abc123":  false,
+			"abc-def": false,
+			"abc_def": false,
+			"":        false,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("lowercase").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
+	})
+}
+
+func Test_Numeric(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := g.MapStrBool{
+			"0":         true,
+			"123":       true,
+			"0123":      true,
+			"123456789": true,
+			"1.23":      false,
+			"abc":       false,
+			"123abc":    false,
+			"abc123":    false,
+			"":          false,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("numeric").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
+	})
+}
+
+func Test_Uppercase(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := g.MapStrBool{
+			"ABC":     true,
+			"ABCDEF":  true,
+			"abc":     false,
+			"Abc":     false,
+			"AbC":     false,
+			"ABC123":  false,
+			"ABC-DEF": false,
+			"ABC_DEF": false,
+			"":        false,
+		}
+		for k, v := range m {
+			err := g.Validator().Data(k).Rules("uppercase").Run(ctx)
+			if v {
+				t.AssertNil(err)
+			} else {
+				t.AssertNE(err, nil)
+			}
+		}
+	})
+}
diff --git a/util/gvalid/internal/builtin/builtin_alpha.go b/util/gvalid/internal/builtin/builtin_alpha.go
new file mode 100644
index 000000000..ffddf5aad
--- /dev/null
+++ b/util/gvalid/internal/builtin/builtin_alpha.go
@@ -0,0 +1,39 @@
+// 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 builtin
+
+import (
+	"errors"
+
+	"github.com/gogf/gf/v2/text/gregex"
+)
+
+// RuleAlpha implements `alpha` rule:
+// Alpha characters (a-z, A-Z).
+//
+// Format: alpha
+type RuleAlpha struct{}
+
+func init() {
+	Register(RuleAlpha{})
+}
+
+func (r RuleAlpha) Name() string {
+	return "alpha"
+}
+
+func (r RuleAlpha) Message() string {
+	return "The {field} value `{value}` must contain only alphabetic characters"
+}
+
+func (r RuleAlpha) Run(in RunInput) error {
+	ok := gregex.IsMatchString(`^[a-zA-Z]+$`, in.Value.String())
+	if ok {
+		return nil
+	}
+	return errors.New(in.Message)
+}
diff --git a/util/gvalid/internal/builtin/builtin_alpha_dash.go b/util/gvalid/internal/builtin/builtin_alpha_dash.go
new file mode 100644
index 000000000..c5cb7101d
--- /dev/null
+++ b/util/gvalid/internal/builtin/builtin_alpha_dash.go
@@ -0,0 +1,39 @@
+// 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 builtin
+
+import (
+	"errors"
+
+	"github.com/gogf/gf/v2/text/gregex"
+)
+
+// RuleAlphaDash implements `alpha-dash` rule:
+// Alpha-numeric characters, hyphens, and underscores (a-z, A-Z, 0-9, -, _).
+//
+// Format: alpha-dash
+type RuleAlphaDash struct{}
+
+func init() {
+	Register(RuleAlphaDash{})
+}
+
+func (r RuleAlphaDash) Name() string {
+	return "alpha-dash"
+}
+
+func (r RuleAlphaDash) Message() string {
+	return "The {field} value `{value}` must contain only alpha-numeric characters, hyphens, and underscores"
+}
+
+func (r RuleAlphaDash) Run(in RunInput) error {
+	ok := gregex.IsMatchString(`^[a-zA-Z0-9_\-]+$`, in.Value.String())
+	if ok {
+		return nil
+	}
+	return errors.New(in.Message)
+}
diff --git a/util/gvalid/internal/builtin/builtin_alpha_num.go b/util/gvalid/internal/builtin/builtin_alpha_num.go
new file mode 100644
index 000000000..4599bc913
--- /dev/null
+++ b/util/gvalid/internal/builtin/builtin_alpha_num.go
@@ -0,0 +1,39 @@
+// 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 builtin
+
+import (
+	"errors"
+
+	"github.com/gogf/gf/v2/text/gregex"
+)
+
+// RuleAlphaNum implements `alpha-num` rule:
+// Alpha-numeric characters (a-z, A-Z, 0-9).
+//
+// Format: alpha-num
+type RuleAlphaNum struct{}
+
+func init() {
+	Register(RuleAlphaNum{})
+}
+
+func (r RuleAlphaNum) Name() string {
+	return "alpha-num"
+}
+
+func (r RuleAlphaNum) Message() string {
+	return "The {field} value `{value}` must contain only alpha-numeric characters"
+}
+
+func (r RuleAlphaNum) Run(in RunInput) error {
+	ok := gregex.IsMatchString(`^[a-zA-Z0-9]+$`, in.Value.String())
+	if ok {
+		return nil
+	}
+	return errors.New(in.Message)
+}
diff --git a/util/gvalid/internal/builtin/builtin_lowercase.go b/util/gvalid/internal/builtin/builtin_lowercase.go
new file mode 100644
index 000000000..0e2f1a87d
--- /dev/null
+++ b/util/gvalid/internal/builtin/builtin_lowercase.go
@@ -0,0 +1,39 @@
+// 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 builtin
+
+import (
+	"errors"
+
+	"github.com/gogf/gf/v2/text/gregex"
+)
+
+// RuleLowercase implements `lowercase` rule:
+// Lowercase alphabetic characters (a-z).
+//
+// Format: lowercase
+type RuleLowercase struct{}
+
+func init() {
+	Register(RuleLowercase{})
+}
+
+func (r RuleLowercase) Name() string {
+	return "lowercase"
+}
+
+func (r RuleLowercase) Message() string {
+	return "The {field} value `{value}` must be lowercase"
+}
+
+func (r RuleLowercase) Run(in RunInput) error {
+	ok := gregex.IsMatchString(`^[a-z]+$`, in.Value.String())
+	if ok {
+		return nil
+	}
+	return errors.New(in.Message)
+}
diff --git a/util/gvalid/internal/builtin/builtin_numeric.go b/util/gvalid/internal/builtin/builtin_numeric.go
new file mode 100644
index 000000000..372867bd0
--- /dev/null
+++ b/util/gvalid/internal/builtin/builtin_numeric.go
@@ -0,0 +1,39 @@
+// 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 builtin
+
+import (
+	"errors"
+
+	"github.com/gogf/gf/v2/text/gregex"
+)
+
+// RuleNumeric implements `numeric` rule:
+// Numeric string (0-9).
+//
+// Format: numeric
+type RuleNumeric struct{}
+
+func init() {
+	Register(RuleNumeric{})
+}
+
+func (r RuleNumeric) Name() string {
+	return "numeric"
+}
+
+func (r RuleNumeric) Message() string {
+	return "The {field} value `{value}` must be numeric"
+}
+
+func (r RuleNumeric) Run(in RunInput) error {
+	ok := gregex.IsMatchString(`^[0-9]+$`, in.Value.String())
+	if ok {
+		return nil
+	}
+	return errors.New(in.Message)
+}
diff --git a/util/gvalid/internal/builtin/builtin_phone_loose.go b/util/gvalid/internal/builtin/builtin_phone_loose.go
index 4c8bcf3ed..aedb622ae 100644
--- a/util/gvalid/internal/builtin/builtin_phone_loose.go
+++ b/util/gvalid/internal/builtin/builtin_phone_loose.go
@@ -13,10 +13,10 @@ import (
 )
 
 // RulePhoneLoose implements `phone-loose` rule:
-// Loose mobile phone number verification(宽松的手机号验证)
+// Loose mobile phone number verification.
 // As long as the 11 digits numbers beginning with
 // 13, 14, 15, 16, 17, 18, 19 can pass the verification
-// (只要满足 13、14、15、16、17、18、19开头的11位数字都可以通过验证).
+// (Any 11-digit numbers starting with 13, 14, 15, 16, 17, 18, 19 can pass the validation).
 //
 // Format: phone-loose
 type RulePhoneLoose struct{}
diff --git a/util/gvalid/internal/builtin/builtin_resident_id.go b/util/gvalid/internal/builtin/builtin_resident_id.go
index 3da02e786..990496abf 100644
--- a/util/gvalid/internal/builtin/builtin_resident_id.go
+++ b/util/gvalid/internal/builtin/builtin_resident_id.go
@@ -41,23 +41,23 @@ func (r RuleResidentId) Run(in RunInput) error {
 
 // checkResidentId checks whether given id a china resident id number.
 //
-// xxxxxx yyyy MM dd 375 0  十八位
-// xxxxxx   yy MM dd  75 0  十五位
+// xxxxxx yyyy MM dd 375 0  18 digits
+// xxxxxx   yy MM dd  75 0  15 digits
 //
-// 地区：     [1-9]\d{5}
-// 年的前两位：(18|19|([23]\d))  1800-2399
-// 年的后两位：\d{2}
-// 月份：     ((0[1-9])|(10|11|12))
-// 天数：     (([0-2][1-9])|10|20|30|31) 闰年不能禁止29+
+// Region:     [1-9]\d{5}
+// First two digits of year: (18|19|([23]\d))  1800-2399
+// Last two digits of year: \d{2}
+// Month:     ((0[1-9])|(10|11|12))
+// Day:       (([0-2][1-9])|10|20|30|31) Leap year cannot prohibit 29+
 //
-// 三位顺序码：\d{3}
-// 两位顺序码：\d{2}
-// 校验码：   [0-9Xx]
+// Three sequential digits: \d{3}
+// Two sequential digits: \d{2}
+// Check code:   [0-9Xx]
 //
-// 十八位：^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$
-// 十五位：^[1-9]\d{5}\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}$
+// 18 digits: ^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$
+// 15 digits: ^[1-9]\d{5}\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}$
 //
-// 总：
+// Total:
 // (^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$)|(^[1-9]\d{5}\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}$)
 func (r RuleResidentId) checkResidentId(id string) bool {
 	id = strings.ToUpper(strings.TrimSpace(id))
diff --git a/util/gvalid/internal/builtin/builtin_uppercase.go b/util/gvalid/internal/builtin/builtin_uppercase.go
new file mode 100644
index 000000000..0bc00da86
--- /dev/null
+++ b/util/gvalid/internal/builtin/builtin_uppercase.go
@@ -0,0 +1,39 @@
+// 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 builtin
+
+import (
+	"errors"
+
+	"github.com/gogf/gf/v2/text/gregex"
+)
+
+// RuleUppercase implements `uppercase` rule:
+// Uppercase alphabetic characters (A-Z).
+//
+// Format: uppercase
+type RuleUppercase struct{}
+
+func init() {
+	Register(RuleUppercase{})
+}
+
+func (r RuleUppercase) Name() string {
+	return "uppercase"
+}
+
+func (r RuleUppercase) Message() string {
+	return "The {field} value `{value}` must be uppercase"
+}
+
+func (r RuleUppercase) Run(in RunInput) error {
+	ok := gregex.IsMatchString(`^[A-Z]+$`, in.Value.String())
+	if ok {
+		return nil
+	}
+	return errors.New(in.Message)
+}
diff --git a/util/gvalid/testdata/i18n/cn/validation.toml b/util/gvalid/testdata/i18n/cn/validation.toml
index 5b601158f..42bebe6fa 100644
--- a/util/gvalid/testdata/i18n/cn/validation.toml
+++ b/util/gvalid/testdata/i18n/cn/validation.toml
@@ -7,7 +7,7 @@
 "gf.gvalid.rule.required-without-all" = "{field}字段不能为空"
 "gf.gvalid.rule.date"                 = "{field}字段值`{value}`日期格式不满足Y-m-d格式，例如: 2001-02-03"
 "gf.gvalid.rule.datetime"             = "{field}字段值`{value}`日期格式不满足Y-m-d H:i:s格式，例如: 2001-02-03 12:00:00"
-"gf.gvalid.rule.date-format"          = "{field}字段值`{value}`日期格式不满足{format}"
+"gf.gvalid.rule.date-format"          = "{field}字段值`{value}`日期格式不满足{pattern}"
 "gf.gvalid.rule.email"                = "{field}字段值`{value}`邮箱地址格式不正确"
 "gf.gvalid.rule.phone"                = "{field}字段值`{value}`手机号码格式不正确"
 "gf.gvalid.rule.phone-loose"          = "{field}字段值`{value}`手机号码格式不正确"
diff --git a/version.go b/version.go
index 308cbe519..0d52ed59e 100644
--- a/version.go
+++ b/version.go
@@ -2,5 +2,5 @@ package gf
 
 const (
 	// VERSION is the current GoFrame version.
-	VERSION = "v2.9.3"
+	VERSION = "v2.9.8"
 )