refactor: use generic for heartbeat instruction handler (#7149)

* refactor: use generic

Signed-off-by: discord9 <discord9@163.com>

* w

Signed-off-by: discord9 <discord9@163.com>

* per review

Signed-off-by: discord9 <discord9@163.com>

---------

Signed-off-by: discord9 <discord9@163.com>

.github/scripts/package-lock.json

@@ -0,0 +1,507 @@
+{
+  "name": "greptimedb-github-scripts",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "greptimedb-github-scripts",
+      "version": "1.0.0",
+      "dependencies": {
+        "@octokit/rest": "^21.0.0",
+        "axios": "^1.7.0"
+      }
+    },
+    "node_modules/@octokit/auth-token": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-5.1.2.tgz",
+      "integrity": "sha512-JcQDsBdg49Yky2w2ld20IHAlwr8d/d8N6NiOXbtuoPCqzbsiJgF633mVUw3x4mo0H5ypataQIX7SFu3yy44Mpw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/core": {
+      "version": "6.1.6",
+      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-6.1.6.tgz",
+      "integrity": "sha512-kIU8SLQkYWGp3pVKiYzA5OSaNF5EE03P/R8zEmmrG6XwOg5oBjXyQVVIauQ0dgau4zYhpZEhJrvIYt6oM+zZZA==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/auth-token": "^5.0.0",
+        "@octokit/graphql": "^8.2.2",
+        "@octokit/request": "^9.2.3",
+        "@octokit/request-error": "^6.1.8",
+        "@octokit/types": "^14.0.0",
+        "before-after-hook": "^3.0.2",
+        "universal-user-agent": "^7.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/endpoint": {
+      "version": "10.1.4",
+      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-10.1.4.tgz",
+      "integrity": "sha512-OlYOlZIsfEVZm5HCSR8aSg02T2lbUWOsCQoPKfTXJwDzcHQBrVBGdGXb89dv2Kw2ToZaRtudp8O3ZIYoaOjKlA==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^14.0.0",
+        "universal-user-agent": "^7.0.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/graphql": {
+      "version": "8.2.2",
+      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-8.2.2.tgz",
+      "integrity": "sha512-Yi8hcoqsrXGdt0yObxbebHXFOiUA+2v3n53epuOg1QUgOB6c4XzvisBNVXJSl8RYA5KrDuSL2yq9Qmqe5N0ryA==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/request": "^9.2.3",
+        "@octokit/types": "^14.0.0",
+        "universal-user-agent": "^7.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/openapi-types": {
+      "version": "25.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-25.1.0.tgz",
+      "integrity": "sha512-idsIggNXUKkk0+BExUn1dQ92sfysJrje03Q0bv0e+KPLrvyqZF8MnBpFz8UNfYDwB3Ie7Z0TByjWfzxt7vseaA==",
+      "license": "MIT"
+    },
+    "node_modules/@octokit/plugin-paginate-rest": {
+      "version": "11.6.0",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-11.6.0.tgz",
+      "integrity": "sha512-n5KPteiF7pWKgBIBJSk8qzoZWcUkza2O6A0za97pMGVrGfPdltxrfmfF5GucHYvHGZD8BdaZmmHGz5cX/3gdpw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^13.10.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=6"
+      }
+    },
+    "node_modules/@octokit/plugin-paginate-rest/node_modules/@octokit/openapi-types": {
+      "version": "24.2.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-24.2.0.tgz",
+      "integrity": "sha512-9sIH3nSUttelJSXUrmGzl7QUBFul0/mB8HRYl3fOlgHbIWG+WnYDXU3v/2zMtAvuzZ/ed00Ei6on975FhBfzrg==",
+      "license": "MIT"
+    },
+    "node_modules/@octokit/plugin-paginate-rest/node_modules/@octokit/types": {
+      "version": "13.10.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-13.10.0.tgz",
+      "integrity": "sha512-ifLaO34EbbPj0Xgro4G5lP5asESjwHracYJvVaPIyXMuiuXLlhic3S47cBdTb+jfODkTE5YtGCLt3Ay3+J97sA==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/openapi-types": "^24.2.0"
+      }
+    },
+    "node_modules/@octokit/plugin-request-log": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-5.3.1.tgz",
+      "integrity": "sha512-n/lNeCtq+9ofhC15xzmJCNKP2BWTv8Ih2TTy+jatNCCq/gQP/V7rK3fjIfuz0pDWDALO/o/4QY4hyOF6TQQFUw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=6"
+      }
+    },
+    "node_modules/@octokit/plugin-rest-endpoint-methods": {
+      "version": "13.5.0",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-13.5.0.tgz",
+      "integrity": "sha512-9Pas60Iv9ejO3WlAX3maE1+38c5nqbJXV5GrncEfkndIpZrJ/WPMRd2xYDcPPEt5yzpxcjw9fWNoPhsSGzqKqw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^13.10.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=6"
+      }
+    },
+    "node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/openapi-types": {
+      "version": "24.2.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-24.2.0.tgz",
+      "integrity": "sha512-9sIH3nSUttelJSXUrmGzl7QUBFul0/mB8HRYl3fOlgHbIWG+WnYDXU3v/2zMtAvuzZ/ed00Ei6on975FhBfzrg==",
+      "license": "MIT"
+    },
+    "node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/types": {
+      "version": "13.10.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-13.10.0.tgz",
+      "integrity": "sha512-ifLaO34EbbPj0Xgro4G5lP5asESjwHracYJvVaPIyXMuiuXLlhic3S47cBdTb+jfODkTE5YtGCLt3Ay3+J97sA==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/openapi-types": "^24.2.0"
+      }
+    },
+    "node_modules/@octokit/request": {
+      "version": "9.2.4",
+      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-9.2.4.tgz",
+      "integrity": "sha512-q8ybdytBmxa6KogWlNa818r0k1wlqzNC+yNkcQDECHvQo8Vmstrg18JwqJHdJdUiHD2sjlwBgSm9kHkOKe2iyA==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/endpoint": "^10.1.4",
+        "@octokit/request-error": "^6.1.8",
+        "@octokit/types": "^14.0.0",
+        "fast-content-type-parse": "^2.0.0",
+        "universal-user-agent": "^7.0.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/request-error": {
+      "version": "6.1.8",
+      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-6.1.8.tgz",
+      "integrity": "sha512-WEi/R0Jmq+IJKydWlKDmryPcmdYSVjL3ekaiEL1L9eo1sUnqMJ+grqmC9cjk7CA7+b2/T397tO5d8YLOH3qYpQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^14.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/rest": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-21.1.1.tgz",
+      "integrity": "sha512-sTQV7va0IUVZcntzy1q3QqPm/r8rWtDCqpRAmb8eXXnKkjoQEtFe3Nt5GTVsHft+R6jJoHeSiVLcgcvhtue/rg==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/core": "^6.1.4",
+        "@octokit/plugin-paginate-rest": "^11.4.2",
+        "@octokit/plugin-request-log": "^5.3.1",
+        "@octokit/plugin-rest-endpoint-methods": "^13.3.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/types": {
+      "version": "14.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-14.1.0.tgz",
+      "integrity": "sha512-1y6DgTy8Jomcpu33N+p5w58l6xyt55Ar2I91RPiIA0xCJBXyUAhXCcmZaDWSANiha7R9a6qJJ2CRomGPZ6f46g==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/openapi-types": "^25.1.0"
+      }
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
+    "node_modules/axios": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.12.2.tgz",
+      "integrity": "sha512-vMJzPewAlRyOgxV2dU0Cuz2O8zzzx9VYtbJOaBgXFeLc4IV/Eg50n4LowmehOOR61S8ZMpc2K5Sa7g6A4jfkUw==",
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.4",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/before-after-hook": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-3.0.2.tgz",
+      "integrity": "sha512-Nik3Sc0ncrMK4UUdXQmAnRtzmNQTAAXmXIopizwZ1W1t8QmfJj+zL4OA2I7XPTPW5z5TDqv4hRo/JzouDJnX3A==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/fast-content-type-parse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/fast-content-type-parse/-/fast-content-type-parse-2.0.1.tgz",
+      "integrity": "sha512-nGqtvLrj5w0naR6tDPfB4cUmYCqouzyQiz6C5y/LtcDllJdrcc6WaWW6iXyIIOErTa/XRybj28aasdn4LkVk6Q==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.11",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
+      "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
+      "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
+    "node_modules/universal-user-agent": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-7.0.3.tgz",
+      "integrity": "sha512-TmnEAEAsBJVZM/AADELsK76llnwcf9vMKuPz8JflO1frO8Lchitr0fNaN9d+Ap0BjKtqWqd/J17qeDnXh8CL2A==",
+      "license": "ISC"
+    }
+  }
+}

.github/scripts/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "greptimedb-github-scripts",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "GitHub automation scripts for GreptimeDB",
+  "dependencies": {
+    "@octokit/rest": "^21.0.0",
+    "axios": "^1.7.0"
+  }
+}

.github/scripts/pr-review-reminder.js

@@ -0,0 +1,152 @@
+// Daily PR Review Reminder Script
+// Fetches open PRs from GreptimeDB repository and sends Slack notifications
+// to PR owners and assigned reviewers to keep review process moving.
+
+(async () => {
+  const { Octokit } = await import("@octokit/rest");
+  const { default: axios } = await import('axios');
+
+  // Configuration
+  const GITHUB_TOKEN = process.env.GITHUB_TOKEN;
+  const SLACK_WEBHOOK_URL = process.env.SLACK_PR_REVIEW_WEBHOOK_URL;
+  const REPO_OWNER = "GreptimeTeam";
+  const REPO_NAME = "greptimedb";
+  const GITHUB_TO_SLACK = JSON.parse(process.env.GITHUBID_SLACKID_MAPPING || '{}');
+
+  // Debug: Print environment variable status
+  console.log("=== Environment Variables Debug ===");
+  console.log(`GITHUB_TOKEN: ${GITHUB_TOKEN ? 'Set ✓' : 'NOT SET ✗'}`);
+  console.log(`SLACK_PR_REVIEW_WEBHOOK_URL: ${SLACK_WEBHOOK_URL ? 'Set ✓' : 'NOT SET ✗'}`);
+  console.log(`GITHUBID_SLACKID_MAPPING: ${process.env.GITHUBID_SLACKID_MAPPING ? `Set ✓ (${Object.keys(GITHUB_TO_SLACK).length} mappings)` : 'NOT SET ✗'}`);
+  console.log("===================================\n");
+
+  const octokit = new Octokit({
+    auth: GITHUB_TOKEN
+  });
+
+  // Fetch all open PRs from the repository
+  async function fetchOpenPRs() {
+    try {
+      const prs = await octokit.pulls.list({
+        owner: REPO_OWNER,
+        repo: REPO_NAME,
+        state: "open",
+        per_page: 100,
+        sort: "created",
+        direction: "asc"
+      });
+      return prs.data.filter((pr) => !pr.draft);
+    } catch (error) {
+      console.error("Error fetching PRs:", error);
+      return [];
+    }
+  }
+
+  // Convert GitHub username to Slack mention or fallback to GitHub username
+  function toSlackMention(githubUser) {
+    const slackUserId = GITHUB_TO_SLACK[githubUser];
+    return slackUserId ? `<@${slackUserId}>` : `@${githubUser}`;
+  }
+
+  // Calculate days since PR was opened
+  function getDaysOpen(createdAt) {
+    const created = new Date(createdAt);
+    const now = new Date();
+    const diffMs = now - created;
+    const days = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    return days;
+  }
+
+  // Build Slack notification message from PR list
+  function buildSlackMessage(prs) {
+    if (prs.length === 0) {
+      return "*🎉 Great job! No pending PRs for review.*";
+    }
+
+    // Separate PRs by age threshold (14 days)
+    const criticalPRs = [];
+    const recentPRs = [];
+
+    prs.forEach(pr => {
+      const daysOpen = getDaysOpen(pr.created_at);
+      if (daysOpen >= 14) {
+        criticalPRs.push(pr);
+      } else {
+        recentPRs.push(pr);
+      }
+    });
+
+    const lines = [
+      `*🔍 Daily PR Review Reminder 🔍*`,
+      `Found *${criticalPRs.length}* critical PR(s) (14+ days old)\n`
+    ];
+
+    // Show critical PRs (14+ days) in detail
+    if (criticalPRs.length > 0) {
+      criticalPRs.forEach((pr, index) => {
+        const owner = toSlackMention(pr.user.login);
+        const reviewers = pr.requested_reviewers || [];
+        const reviewerMentions = reviewers.map(r => toSlackMention(r.login)).join(", ");
+        const daysOpen = getDaysOpen(pr.created_at);
+
+        const prInfo = `${index + 1}. <${pr.html_url}|#${pr.number}: ${pr.title}>`;
+        const ageInfo = `   🔴 Opened *${daysOpen}* day(s) ago`;
+        const ownerInfo = `   👤 Owner: ${owner}`;
+        const reviewerInfo = reviewers.length > 0
+          ? `   👁️ Reviewers: ${reviewerMentions}`
+          : `   👁️ Reviewers: _Not assigned yet_`;
+
+        lines.push(prInfo);
+        lines.push(ageInfo);
+        lines.push(ownerInfo);
+        lines.push(reviewerInfo);
+        lines.push(""); // Empty line between PRs
+      });
+    }
+
+    lines.push("_Let's keep the code review process moving! 🚀_");
+
+    return lines.join("\n");
+  }
+
+  // Send notification to Slack webhook
+  async function sendSlackNotification(message) {
+    if (!SLACK_WEBHOOK_URL) {
+      console.log("⚠️  SLACK_PR_REVIEW_WEBHOOK_URL not configured. Message preview:");
+      console.log("=".repeat(60));
+      console.log(message);
+      console.log("=".repeat(60));
+      return;
+    }
+
+    try {
+      const response = await axios.post(SLACK_WEBHOOK_URL, {
+        text: message
+      });
+
+      if (response.status !== 200) {
+        throw new Error(`Slack API returned status ${response.status}`);
+      }
+      console.log("Slack notification sent successfully.");
+    } catch (error) {
+      console.error("Error sending Slack notification:", error);
+      throw error;
+    }
+  }
+
+  // Main execution flow
+  async function run() {
+    console.log(`Fetching open PRs from ${REPO_OWNER}/${REPO_NAME}...`);
+    const prs = await fetchOpenPRs();
+    console.log(`Found ${prs.length} open PR(s).`);
+
+    const message = buildSlackMessage(prs);
+    console.log("Sending Slack notification...");
+    await sendSlackNotification(message);
+  }
+
+  run().catch(error => {
+    console.error("Script execution failed:", error);
+    process.exit(1);
+  });
+})();

.github/workflows/develop.yml

@@ -632,7 +632,7 @@ jobs:
       - name: Unzip binaries
         run: tar -xvf ./bins.tar.gz
       - name: Run sqlness
-        run: RUST_BACKTRACE=1 ./bins/sqlness-runner ${{ matrix.mode.opts }} -c ./tests/cases --bins-dir ./bins --preserve-state
+        run: RUST_BACKTRACE=1 ./bins/sqlness-runner bare ${{ matrix.mode.opts }} -c ./tests/cases --bins-dir ./bins --preserve-state
       - name: Upload sqlness logs
         if: failure()
         uses: actions/upload-artifact@v4

.github/workflows/pr-review-reminder.yml

@@ -0,0 +1,36 @@
+name: PR Review Reminder
+
+on:
+  schedule:
+    # Run at 9:00 AM UTC+8 (01:00 AM UTC) on Monday, Wednesday, Friday
+    - cron: '0 1 * * 1,3,5'
+  workflow_dispatch:
+
+jobs:
+  pr-review-reminder:
+    name: Send PR Review Reminders
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        working-directory: .github/scripts
+        run: npm ci
+
+      - name: Run PR review reminder
+        working-directory: .github/scripts
+        run: node pr-review-reminder.js
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SLACK_PR_REVIEW_WEBHOOK_URL: ${{ vars.SLACK_PR_REVIEW_WEBHOOK_URL }}
+          GITHUBID_SLACKID_MAPPING: ${{ vars.GITHUBID_SLACKID_MAPPING }}

Cargo.toml

@@ -99,12 +99,12 @@ rust.unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tokio_unstable)'] }
 # See for more detaiils: https://github.com/rust-lang/cargo/issues/11329
 ahash = { version = "0.8", features = ["compile-time-rng"] }
 aquamarine = "0.6"
-arrow = { version = "56.0", features = ["prettyprint"] }
-arrow-array = { version = "56.0", default-features = false, features = ["chrono-tz"] }
-arrow-buffer = "56.0"
-arrow-flight = "56.0"
-arrow-ipc = { version = "56.0", default-features = false, features = ["lz4", "zstd"] }
-arrow-schema = { version = "56.0", features = ["serde"] }
+arrow = { version = "56.2", features = ["prettyprint"] }
+arrow-array = { version = "56.2", default-features = false, features = ["chrono-tz"] }
+arrow-buffer = "56.2"
+arrow-flight = "56.2"
+arrow-ipc = { version = "56.2", default-features = false, features = ["lz4", "zstd"] }
+arrow-schema = { version = "56.2", features = ["serde"] }
 async-stream = "0.3"
 async-trait = "0.1"
 # Remember to update axum-extra, axum-macros when updating axum
@@ -123,18 +123,18 @@ clap = { version = "4.4", features = ["derive"] }
 config = "0.13.0"
 crossbeam-utils = "0.8"
 dashmap = "6.1"
-datafusion = "49"
-datafusion-common = "49"
-datafusion-expr = "49"
-datafusion-functions = "49"
-datafusion-functions-aggregate-common = "49"
-datafusion-optimizer = "49"
-datafusion-orc = { git = "https://github.com/GreptimeTeam/datafusion-orc", rev = "a0a5f902158f153119316eaeec868cff3fc8a99d" }
-datafusion-pg-catalog = { git = "https://github.com/datafusion-contrib/datafusion-postgres", rev = "3d1b7c7d5b82dd49bafc2803259365e633f654fa" }
-datafusion-physical-expr = "49"
-datafusion-physical-plan = "49"
-datafusion-sql = "49"
-datafusion-substrait = "49"
+datafusion = "50"
+datafusion-common = "50"
+datafusion-expr = "50"
+datafusion-functions = "50"
+datafusion-functions-aggregate-common = "50"
+datafusion-optimizer = "50"
+datafusion-orc = "0.5"
+datafusion-pg-catalog = "0.11"
+datafusion-physical-expr = "50"
+datafusion-physical-plan = "50"
+datafusion-sql = "50"
+datafusion-substrait = "50"
 deadpool = "0.12"
 deadpool-postgres = "0.14"
 derive_builder = "0.20"
@@ -147,7 +147,7 @@ etcd-client = { git = "https://github.com/GreptimeTeam/etcd-client", rev = "f62d
 fst = "0.4.7"
 futures = "0.3"
 futures-util = "0.3"
-greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "3e821d0d405e6733690a4e4352812ba2ff780a3e" }
+greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "14b9dc40bdc8288742b0cefc7bb024303b7429ef" }
 hex = "0.4"
 http = "1"
 humantime = "2.1"
@@ -180,7 +180,7 @@ otel-arrow-rust = { git = "https://github.com/GreptimeTeam/otel-arrow", rev = "2
     "server",
 ] }
 parking_lot = "0.12"
-parquet = { version = "56.0", default-features = false, features = ["arrow", "async", "object_store"] }
+parquet = { version = "56.2", default-features = false, features = ["arrow", "async", "object_store"] }
 paste = "1.0"
 pin-project = "1.0"
 pretty_assertions = "1.4.0"
@@ -191,7 +191,7 @@ prost-types = "0.13"
 raft-engine = { version = "0.4.1", default-features = false }
 rand = "0.9"
 ratelimit = "0.10"
-regex = "1.8"
+regex = "1.12"
 regex-automata = "0.4"
 reqwest = { version = "0.12", default-features = false, features = [
     "json",
@@ -207,6 +207,7 @@ rstest_reuse = "0.7"
 rust_decimal = "1.33"
 rustc-hash = "2.0"
 # It is worth noting that we should try to avoid using aws-lc-rs until it can be compiled on various platforms.
+hostname = "0.4.0"
 rustls = { version = "0.23.25", default-features = false }
 sea-query = "0.32"
 serde = { version = "1.0", features = ["derive"] }
@@ -216,10 +217,7 @@ simd-json = "0.15"
 similar-asserts = "1.6.0"
 smallvec = { version = "1", features = ["serde"] }
 snafu = "0.8"
-sqlparser = { git = "https://github.com/GreptimeTeam/sqlparser-rs.git", rev = "39e4fc94c3c741981f77e9d63b5ce8c02e0a27ea", features = [
-    "visitor",
-    "serde",
-] } # branch = "v0.55.x"
+sqlparser = { version = "0.58.0", default-features = false, features = ["std", "visitor", "serde"] }
 sqlx = { version = "0.8", features = [
     "runtime-tokio-rustls",
     "mysql",
@@ -321,16 +319,19 @@ git = "https://github.com/GreptimeTeam/greptime-meter.git"
 rev = "5618e779cf2bb4755b499c630fba4c35e91898cb"
 
 [patch.crates-io]
-datafusion = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "7d5214512740b4dfb742b6b3d91ed9affcc2c9d0" }
-datafusion-common = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "7d5214512740b4dfb742b6b3d91ed9affcc2c9d0" }
-datafusion-expr = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "7d5214512740b4dfb742b6b3d91ed9affcc2c9d0" }
-datafusion-functions = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "7d5214512740b4dfb742b6b3d91ed9affcc2c9d0" }
-datafusion-functions-aggregate-common = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "7d5214512740b4dfb742b6b3d91ed9affcc2c9d0" }
-datafusion-optimizer = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "7d5214512740b4dfb742b6b3d91ed9affcc2c9d0" }
-datafusion-physical-expr = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "7d5214512740b4dfb742b6b3d91ed9affcc2c9d0" }
-datafusion-physical-plan = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "7d5214512740b4dfb742b6b3d91ed9affcc2c9d0" }
-datafusion-sql = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "7d5214512740b4dfb742b6b3d91ed9affcc2c9d0" }
-datafusion-substrait = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "7d5214512740b4dfb742b6b3d91ed9affcc2c9d0" }
+datafusion = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "fd4b2abcf3c3e43e94951bda452c9fd35243aab0" }
+datafusion-common = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "fd4b2abcf3c3e43e94951bda452c9fd35243aab0" }
+datafusion-expr = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "fd4b2abcf3c3e43e94951bda452c9fd35243aab0" }
+datafusion-functions = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "fd4b2abcf3c3e43e94951bda452c9fd35243aab0" }
+datafusion-functions-aggregate-common = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "fd4b2abcf3c3e43e94951bda452c9fd35243aab0" }
+datafusion-optimizer = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "fd4b2abcf3c3e43e94951bda452c9fd35243aab0" }
+datafusion-physical-expr = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "fd4b2abcf3c3e43e94951bda452c9fd35243aab0" }
+datafusion-physical-expr-common = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "fd4b2abcf3c3e43e94951bda452c9fd35243aab0" }
+datafusion-physical-plan = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "fd4b2abcf3c3e43e94951bda452c9fd35243aab0" }
+datafusion-datasource = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "fd4b2abcf3c3e43e94951bda452c9fd35243aab0" }
+datafusion-sql = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "fd4b2abcf3c3e43e94951bda452c9fd35243aab0" }
+datafusion-substrait = { git = "https://github.com/GreptimeTeam/datafusion.git", rev = "fd4b2abcf3c3e43e94951bda452c9fd35243aab0" }
+sqlparser = { git = "https://github.com/GreptimeTeam/sqlparser-rs.git", rev = "4b519a5caa95472cc3988f5556813a583dd35af1" }                           # branch = "v0.58.x"
 
 [profile.release]
 debug = 1

Makefile

@@ -8,7 +8,7 @@ CARGO_BUILD_OPTS := --locked
 IMAGE_REGISTRY ?= docker.io
 IMAGE_NAMESPACE ?= greptime
 IMAGE_TAG ?= latest
-DEV_BUILDER_IMAGE_TAG ?= 2025-05-19-f55023f3-20250829091211
+DEV_BUILDER_IMAGE_TAG ?= 2025-10-01-8fe17d43-20251011080129
 BUILDX_MULTI_PLATFORM_BUILD ?= false
 BUILDX_BUILDER_NAME ?= gtbuilder
 BASE_IMAGE ?= ubuntu
@@ -169,7 +169,7 @@ nextest: ## Install nextest tools.
 
 .PHONY: sqlness-test
 sqlness-test: ## Run sqlness test.
-	cargo sqlness ${SQLNESS_OPTS}
+	cargo sqlness bare ${SQLNESS_OPTS}
 
 RUNS ?= 1
 FUZZ_TARGET ?= fuzz_alter_table

config/config.md

@@ -13,6 +13,7 @@
 | Key | Type | Default | Descriptions |
 | --- | -----| ------- | ----------- |
 | `default_timezone` | String | Unset | The default timezone of the server. |
+| `default_column_prefix` | String | Unset | The default column prefix for auto-created time index and value columns. |
 | `init_regions_in_background` | Bool | `false` | Initialize all regions in the background during the startup.<br/>By default, it provides services after all regions have been initialized. |
 | `init_regions_parallelism` | Integer | `16` | Parallelism of initializing regions. |
 | `max_concurrent_queries` | Integer | `0` | The maximum current queries allowed to be executed. Zero means unlimited. |
@@ -25,12 +26,14 @@
 | `http.addr` | String | `127.0.0.1:4000` | The address to bind the HTTP server. |
 | `http.timeout` | String | `0s` | HTTP request timeout. Set to 0 to disable timeout. |
 | `http.body_limit` | String | `64MB` | HTTP request body limit.<br/>The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.<br/>Set to 0 to disable limit. |
+| `http.max_total_body_memory` | String | Unset | Maximum total memory for all concurrent HTTP request bodies.<br/>Set to 0 to disable the limit. Default: "0" (unlimited) |
 | `http.enable_cors` | Bool | `true` | HTTP CORS support, it's turned on by default<br/>This allows browser to access http APIs without CORS restrictions |
 | `http.cors_allowed_origins` | Array | Unset | Customize allowed origins for HTTP CORS. |
 | `http.prom_validation_mode` | String | `strict` | Whether to enable validation for Prometheus remote write requests.<br/>Available options:<br/>- strict: deny invalid UTF-8 strings (default).<br/>- lossy: allow invalid UTF-8 strings, replace invalid characters with REPLACEMENT_CHARACTER(U+FFFD).<br/>- unchecked: do not valid strings. |
 | `grpc` | -- | -- | The gRPC server options. |
 | `grpc.bind_addr` | String | `127.0.0.1:4001` | The address to bind the gRPC server. |
 | `grpc.runtime_size` | Integer | `8` | The number of server worker threads. |
+| `grpc.max_total_message_memory` | String | Unset | Maximum total memory for all concurrent gRPC request messages.<br/>Set to 0 to disable the limit. Default: "0" (unlimited) |
 | `grpc.max_connection_age` | String | Unset | The maximum connection age for gRPC connection.<br/>The value can be a human-readable time string. For example: `10m` for ten minutes or `1h` for one hour.<br/>Refer to https://grpc.io/docs/guides/keepalive/ for more details. |
 | `grpc.tls` | -- | -- | gRPC server TLS options, see `mysql.tls` section. |
 | `grpc.tls.mode` | String | `disable` | TLS mode. |
@@ -153,7 +156,7 @@
 | `region_engine.mito.max_concurrent_scan_files` | Integer | `384` | Maximum number of SST files to scan concurrently. |
 | `region_engine.mito.allow_stale_entries` | Bool | `false` | Whether to allow stale WAL entries read during replay. |
 | `region_engine.mito.min_compaction_interval` | String | `0m` | Minimum time interval between two compactions.<br/>To align with the old behavior, the default value is 0 (no restrictions). |
-| `region_engine.mito.enable_experimental_flat_format` | Bool | `false` | Whether to enable experimental flat format. |
+| `region_engine.mito.default_experimental_flat_format` | Bool | `false` | Whether to enable experimental flat format as the default format. |
 | `region_engine.mito.index` | -- | -- | The options for index in Mito engine. |
 | `region_engine.mito.index.aux_path` | String | `""` | Auxiliary directory path for the index in filesystem, used to store intermediate files for<br/>creating the index and staging files for searching the index, defaults to `{data_home}/index_intermediate`.<br/>The default name for this directory is `index_intermediate` for backward compatibility.<br/><br/>This path contains two subdirectories:<br/>- `__intm`: for storing intermediate files used during creating index.<br/>- `staging`: for storing staging files used during searching index. |
 | `region_engine.mito.index.staging_size` | String | `2GB` | The max capacity of the staging directory. |
@@ -224,6 +227,7 @@
 | Key | Type | Default | Descriptions |
 | --- | -----| ------- | ----------- |
 | `default_timezone` | String | Unset | The default timezone of the server. |
+| `default_column_prefix` | String | Unset | The default column prefix for auto-created time index and value columns. |
 | `max_in_flight_write_bytes` | String | Unset | The maximum in-flight write bytes. |
 | `runtime` | -- | -- | The runtime options. |
 | `runtime.global_rt_size` | Integer | `8` | The number of threads to execute the runtime for global read operations. |
@@ -235,6 +239,7 @@
 | `http.addr` | String | `127.0.0.1:4000` | The address to bind the HTTP server. |
 | `http.timeout` | String | `0s` | HTTP request timeout. Set to 0 to disable timeout. |
 | `http.body_limit` | String | `64MB` | HTTP request body limit.<br/>The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.<br/>Set to 0 to disable limit. |
+| `http.max_total_body_memory` | String | Unset | Maximum total memory for all concurrent HTTP request bodies.<br/>Set to 0 to disable the limit. Default: "0" (unlimited) |
 | `http.enable_cors` | Bool | `true` | HTTP CORS support, it's turned on by default<br/>This allows browser to access http APIs without CORS restrictions |
 | `http.cors_allowed_origins` | Array | Unset | Customize allowed origins for HTTP CORS. |
 | `http.prom_validation_mode` | String | `strict` | Whether to enable validation for Prometheus remote write requests.<br/>Available options:<br/>- strict: deny invalid UTF-8 strings (default).<br/>- lossy: allow invalid UTF-8 strings, replace invalid characters with REPLACEMENT_CHARACTER(U+FFFD).<br/>- unchecked: do not valid strings. |
@@ -242,6 +247,7 @@
 | `grpc.bind_addr` | String | `127.0.0.1:4001` | The address to bind the gRPC server. |
 | `grpc.server_addr` | String | `127.0.0.1:4001` | The address advertised to the metasrv, and used for connections from outside the host.<br/>If left empty or unset, the server will automatically use the IP address of the first network interface<br/>on the host, with the same port number as the one specified in `grpc.bind_addr`. |
 | `grpc.runtime_size` | Integer | `8` | The number of server worker threads. |
+| `grpc.max_total_message_memory` | String | Unset | Maximum total memory for all concurrent gRPC request messages.<br/>Set to 0 to disable the limit. Default: "0" (unlimited) |
 | `grpc.flight_compression` | String | `arrow_ipc` | Compression mode for frontend side Arrow IPC service. Available options:<br/>- `none`: disable all compression<br/>- `transport`: only enable gRPC transport compression (zstd)<br/>- `arrow_ipc`: only enable Arrow IPC compression (lz4)<br/>- `all`: enable all compression.<br/>Default to `none` |
 | `grpc.max_connection_age` | String | Unset | The maximum connection age for gRPC connection.<br/>The value can be a human-readable time string. For example: `10m` for ten minutes or `1h` for one hour.<br/>Refer to https://grpc.io/docs/guides/keepalive/ for more details. |
 | `grpc.tls` | -- | -- | gRPC server TLS options, see `mysql.tls` section. |
@@ -436,6 +442,7 @@
 | Key | Type | Default | Descriptions |
 | --- | -----| ------- | ----------- |
 | `node_id` | Integer | Unset | The datanode identifier and should be unique in the cluster. |
+| `default_column_prefix` | String | Unset | The default column prefix for auto-created time index and value columns. |
 | `require_lease_before_startup` | Bool | `false` | Start services after regions have obtained leases.<br/>It will block the datanode start if it can't receive leases in the heartbeat from metasrv. |
 | `init_regions_in_background` | Bool | `false` | Initialize all regions in the background during the startup.<br/>By default, it provides services after all regions have been initialized. |
 | `init_regions_parallelism` | Integer | `16` | Parallelism of initializing regions. |
@@ -474,7 +481,7 @@
 | `meta_client.metadata_cache_ttl` | String | `10m` | TTL of the metadata cache. |
 | `meta_client.metadata_cache_tti` | String | `5m` | -- |
 | `wal` | -- | -- | The WAL options. |
-| `wal.provider` | String | `raft_engine` | The provider of the WAL.<br/>- `raft_engine`: the wal is stored in the local file system by raft-engine.<br/>- `kafka`: it's remote wal that data is stored in Kafka. |
+| `wal.provider` | String | `raft_engine` | The provider of the WAL.<br/>- `raft_engine`: the wal is stored in the local file system by raft-engine.<br/>- `kafka`: it's remote wal that data is stored in Kafka.<br/>- `noop`: it's a no-op WAL provider that does not store any WAL data.<br/>**Notes: any unflushed data will be lost when the datanode is shutdown.** |
 | `wal.dir` | String | Unset | The directory to store the WAL files.<br/>**It's only used when the provider is `raft_engine`**. |
 | `wal.file_size` | String | `128MB` | The size of the WAL segment file.<br/>**It's only used when the provider is `raft_engine`**. |
 | `wal.purge_threshold` | String | `1GB` | The threshold of the WAL size to trigger a purge.<br/>**It's only used when the provider is `raft_engine`**. |
@@ -547,7 +554,7 @@
 | `region_engine.mito.max_concurrent_scan_files` | Integer | `384` | Maximum number of SST files to scan concurrently. |
 | `region_engine.mito.allow_stale_entries` | Bool | `false` | Whether to allow stale WAL entries read during replay. |
 | `region_engine.mito.min_compaction_interval` | String | `0m` | Minimum time interval between two compactions.<br/>To align with the old behavior, the default value is 0 (no restrictions). |
-| `region_engine.mito.enable_experimental_flat_format` | Bool | `false` | Whether to enable experimental flat format. |
+| `region_engine.mito.default_experimental_flat_format` | Bool | `false` | Whether to enable experimental flat format as the default format. |
 | `region_engine.mito.index` | -- | -- | The options for index in Mito engine. |
 | `region_engine.mito.index.aux_path` | String | `""` | Auxiliary directory path for the index in filesystem, used to store intermediate files for<br/>creating the index and staging files for searching the index, defaults to `{data_home}/index_intermediate`.<br/>The default name for this directory is `index_intermediate` for backward compatibility.<br/><br/>This path contains two subdirectories:<br/>- `__intm`: for storing intermediate files used during creating index.<br/>- `staging`: for storing staging files used during searching index. |
 | `region_engine.mito.index.staging_size` | String | `2GB` | The max capacity of the staging directory. |

config/datanode.example.toml

@@ -2,6 +2,10 @@
 ## @toml2docs:none-default
 node_id = 42
 
+## The default column prefix for auto-created time index and value columns.
+## @toml2docs:none-default
+default_column_prefix = "greptime"
+
 ## Start services after regions have obtained leases.
 ## It will block the datanode start if it can't receive leases in the heartbeat from metasrv.
 require_lease_before_startup = false
@@ -118,6 +122,7 @@ metadata_cache_tti = "5m"
 ## The provider of the WAL.
 ## - `raft_engine`: the wal is stored in the local file system by raft-engine.
 ## - `kafka`: it's remote wal that data is stored in Kafka.
+## - `noop`: it's a no-op WAL provider that does not store any WAL data.<br/>**Notes: any unflushed data will be lost when the datanode is shutdown.**
 provider = "raft_engine"
 
 ## The directory to store the WAL files.
@@ -500,8 +505,8 @@ allow_stale_entries = false
 ## To align with the old behavior, the default value is 0 (no restrictions).
 min_compaction_interval = "0m"
 
-## Whether to enable experimental flat format.
-enable_experimental_flat_format = false
+## Whether to enable experimental flat format as the default format.
+default_experimental_flat_format = false
 
 ## The options for index in Mito engine.
 [region_engine.mito.index]

config/frontend.example.toml

@@ -2,6 +2,10 @@
 ## @toml2docs:none-default
 default_timezone = "UTC"
 
+## The default column prefix for auto-created time index and value columns.
+## @toml2docs:none-default
+default_column_prefix = "greptime"
+
 ## The maximum in-flight write bytes.
 ## @toml2docs:none-default
 #+ max_in_flight_write_bytes = "500MB"
@@ -31,6 +35,10 @@ timeout = "0s"
 ## The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.
 ## Set to 0 to disable limit.
 body_limit = "64MB"
+## Maximum total memory for all concurrent HTTP request bodies.
+## Set to 0 to disable the limit. Default: "0" (unlimited)
+## @toml2docs:none-default
+#+ max_total_body_memory = "1GB"
 ## HTTP CORS support, it's turned on by default
 ## This allows browser to access http APIs without CORS restrictions
 enable_cors = true
@@ -54,6 +62,10 @@ bind_addr = "127.0.0.1:4001"
 server_addr = "127.0.0.1:4001"
 ## The number of server worker threads.
 runtime_size = 8
+## Maximum total memory for all concurrent gRPC request messages.
+## Set to 0 to disable the limit. Default: "0" (unlimited)
+## @toml2docs:none-default
+#+ max_total_message_memory = "1GB"
 ## Compression mode for frontend side Arrow IPC service. Available options:
 ## - `none`: disable all compression
 ## - `transport`: only enable gRPC transport compression (zstd)

config/standalone.example.toml

@@ -2,6 +2,10 @@
 ## @toml2docs:none-default
 default_timezone = "UTC"
 
+## The default column prefix for auto-created time index and value columns.
+## @toml2docs:none-default
+default_column_prefix = "greptime"
+
 ## Initialize all regions in the background during the startup.
 ## By default, it provides services after all regions have been initialized.
 init_regions_in_background = false
@@ -36,6 +40,10 @@ timeout = "0s"
 ## The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.
 ## Set to 0 to disable limit.
 body_limit = "64MB"
+## Maximum total memory for all concurrent HTTP request bodies.
+## Set to 0 to disable the limit. Default: "0" (unlimited)
+## @toml2docs:none-default
+#+ max_total_body_memory = "1GB"
 ## HTTP CORS support, it's turned on by default
 ## This allows browser to access http APIs without CORS restrictions
 enable_cors = true
@@ -56,6 +64,10 @@ prom_validation_mode = "strict"
 bind_addr = "127.0.0.1:4001"
 ## The number of server worker threads.
 runtime_size = 8
+## Maximum total memory for all concurrent gRPC request messages.
+## Set to 0 to disable the limit. Default: "0" (unlimited)
+## @toml2docs:none-default
+#+ max_total_message_memory = "1GB"
 ## The maximum connection age for gRPC connection.
 ## The value can be a human-readable time string. For example: `10m` for ten minutes or `1h` for one hour.
 ## Refer to https://grpc.io/docs/guides/keepalive/ for more details.
@@ -584,8 +596,8 @@ allow_stale_entries = false
 ## To align with the old behavior, the default value is 0 (no restrictions).
 min_compaction_interval = "0m"
 
-## Whether to enable experimental flat format.
-enable_experimental_flat_format = false
+## Whether to enable experimental flat format as the default format.
+default_experimental_flat_format = false
 
 ## The options for index in Mito engine.
 [region_engine.mito.index]

docs/how-to/how-to-profile-memory.md

@@ -71,6 +71,15 @@ curl -X POST localhost:4000/debug/prof/mem/activate
 
 # Deactivate heap profiling
 curl -X POST localhost:4000/debug/prof/mem/deactivate
+
+# Activate gdump feature that dumps memory profiling data every time virtual memory usage exceeds previous maximum value.
+curl -X POST localhost:4000/debug/prof/mem/gdump -d 'activate=true'
+
+# Deactivate gdump.
+curl -X POST localhost:4000/debug/prof/mem/gdump -d 'activate=false'
+
+# Retrieve current gdump status.
+curl -X GET localhost:4000/debug/prof/mem/gdump
 ```
 
 ### Dump memory profiling data

flake.lock

@@ -8,11 +8,11 @@
         "rust-analyzer-src": "rust-analyzer-src"
       },
       "locked": {
-        "lastModified": 1745735608,
-        "narHash": "sha256-L0jzm815XBFfF2wCFmR+M1CF+beIEFj6SxlqVKF59Ec=",
+        "lastModified": 1760078406,
+        "narHash": "sha256-JeJK0ZA845PtkCHkfo4KjeI1mYrsr2s3cxBYKhF4BoE=",
         "owner": "nix-community",
         "repo": "fenix",
-        "rev": "c39a78eba6ed2a022cc3218db90d485077101496",
+        "rev": "351277c60d104944122ee389cdf581c5ce2c6732",
         "type": "github"
       },
       "original": {
@@ -41,11 +41,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1748162331,
-        "narHash": "sha256-rqc2RKYTxP3tbjA+PB3VMRQNnjesrT0pEofXQTrMsS8=",
+        "lastModified": 1759994382,
+        "narHash": "sha256-wSK+3UkalDZRVHGCRikZ//CyZUJWDJkBDTQX1+G77Ow=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "7c43f080a7f28b2774f3b3f43234ca11661bf334",
+        "rev": "5da4a26309e796daa7ffca72df93dbe53b8164c7",
         "type": "github"
       },
       "original": {
@@ -65,11 +65,11 @@
     "rust-analyzer-src": {
       "flake": false,
       "locked": {
-        "lastModified": 1745694049,
-        "narHash": "sha256-fxvRYH/tS7hGQeg9zCVh5RBcSWT+JGJet7RA8Ss+rC0=",
+        "lastModified": 1760014945,
+        "narHash": "sha256-ySdl7F9+oeWNHVrg3QL/brazqmJvYFEdpGnF3pyoDH8=",
         "owner": "rust-lang",
         "repo": "rust-analyzer",
-        "rev": "d8887c0758bbd2d5f752d5bd405d4491e90e7ed6",
+        "rev": "90d2e1ce4dfe7dc49250a8b88a0f08ffdb9cb23f",
         "type": "github"
       },
       "original": {

flake.nix

@@ -19,7 +19,7 @@
         lib = nixpkgs.lib;
         rustToolchain = fenix.packages.${system}.fromToolchainName {
           name = (lib.importTOML ./rust-toolchain.toml).toolchain.channel;
-          sha256 = "sha256-tJJr8oqX3YD+ohhPK7jlt/7kvKBnBqJVjYtoFr520d4=";
+          sha256 = "sha256-GCGEXGZeJySLND0KU5TdtTrqFV76TF3UdvAHSUegSsk=";
         };
       in
       {

rust-toolchain.toml

@@ -1,2 +1,2 @@
 [toolchain]
-channel = "nightly-2025-05-19"
+channel = "nightly-2025-10-01"

src/api/src/lib.rs

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(let_chains)]
-
 pub mod error;
 pub mod helper;
 

src/api/src/v1/column_def.rs

@@ -16,8 +16,8 @@ use std::collections::HashMap;
 
 use datatypes::schema::{
     COMMENT_KEY, ColumnDefaultConstraint, ColumnSchema, FULLTEXT_KEY, FulltextAnalyzer,
-    FulltextBackend, FulltextOptions, INVERTED_INDEX_KEY, SKIPPING_INDEX_KEY, SkippingIndexOptions,
-    SkippingIndexType,
+    FulltextBackend, FulltextOptions, INVERTED_INDEX_KEY, JSON_STRUCTURE_SETTINGS_KEY,
+    SKIPPING_INDEX_KEY, SkippingIndexOptions, SkippingIndexType,
 };
 use greptime_proto::v1::{
     Analyzer, FulltextBackend as PbFulltextBackend, SkippingIndexType as PbSkippingIndexType,
@@ -37,8 +37,10 @@ const SKIPPING_INDEX_GRPC_KEY: &str = "skipping_index";
 
 /// Tries to construct a `ColumnSchema` from the given  `ColumnDef`.
 pub fn try_as_column_schema(column_def: &ColumnDef) -> Result<ColumnSchema> {
-    let data_type =
-        ColumnDataTypeWrapper::try_new(column_def.data_type, column_def.datatype_extension)?;
+    let data_type = ColumnDataTypeWrapper::try_new(
+        column_def.data_type,
+        column_def.datatype_extension.clone(),
+    )?;
 
     let constraint = if column_def.default_constraint.is_empty() {
         None
@@ -66,6 +68,9 @@ pub fn try_as_column_schema(column_def: &ColumnDef) -> Result<ColumnSchema> {
         if let Some(skipping_index) = options.options.get(SKIPPING_INDEX_GRPC_KEY) {
             metadata.insert(SKIPPING_INDEX_KEY.to_string(), skipping_index.to_owned());
         }
+        if let Some(settings) = options.options.get(JSON_STRUCTURE_SETTINGS_KEY) {
+            metadata.insert(JSON_STRUCTURE_SETTINGS_KEY.to_string(), settings.clone());
+        }
     }
 
     ColumnSchema::new(&column_def.name, data_type.into(), column_def.is_nullable)
@@ -137,6 +142,11 @@ pub fn options_from_column_schema(column_schema: &ColumnSchema) -> Option<Column
             .options
             .insert(SKIPPING_INDEX_GRPC_KEY.to_string(), skipping_index.clone());
     }
+    if let Some(settings) = column_schema.metadata().get(JSON_STRUCTURE_SETTINGS_KEY) {
+        options
+            .options
+            .insert(JSON_STRUCTURE_SETTINGS_KEY.to_string(), settings.clone());
+    }
 
     (!options.options.is_empty()).then_some(options)
 }

src/auth/src/common.rs

@@ -35,7 +35,7 @@ pub fn userinfo_by_name(username: Option<String>) -> UserInfoRef {
     DefaultUserInfo::with_name(username.unwrap_or_else(|| DEFAULT_USERNAME.to_string()))
 }
 
-pub fn user_provider_from_option(opt: &String) -> Result<UserProviderRef> {
+pub fn user_provider_from_option(opt: &str) -> Result<UserProviderRef> {
     let (name, content) = opt.split_once(':').with_context(|| InvalidConfigSnafu {
         value: opt.to_string(),
         msg: "UserProviderOption must be in format `<option>:<value>`",
@@ -57,7 +57,7 @@ pub fn user_provider_from_option(opt: &String) -> Result<UserProviderRef> {
     }
 }
 
-pub fn static_user_provider_from_option(opt: &String) -> Result<StaticUserProvider> {
+pub fn static_user_provider_from_option(opt: &str) -> Result<StaticUserProvider> {
     let (name, content) = opt.split_once(':').with_context(|| InvalidConfigSnafu {
         value: opt.to_string(),
         msg: "UserProviderOption must be in format `<option>:<value>`",

src/catalog/src/lib.rs

@@ -14,7 +14,6 @@
 
 #![feature(assert_matches)]
 #![feature(try_blocks)]
-#![feature(let_chains)]
 
 use std::any::Any;
 use std::fmt::{Debug, Formatter};

src/catalog/src/memory/manager.rs

@@ -392,15 +392,15 @@ impl MemoryCatalogManager {
         if !manager.schema_exist_sync(catalog, schema).unwrap() {
             manager
                 .register_schema_sync(RegisterSchemaRequest {
-                    catalog: catalog.to_string(),
-                    schema: schema.to_string(),
+                    catalog: catalog.clone(),
+                    schema: schema.clone(),
                 })
                 .unwrap();
         }
 
         let request = RegisterTableRequest {
-            catalog: catalog.to_string(),
-            schema: schema.to_string(),
+            catalog: catalog.clone(),
+            schema: schema.clone(),
             table_name: table.table_info().name.clone(),
             table_id: table.table_info().ident.table_id,
             table,

src/catalog/src/process_manager.rs

@@ -56,14 +56,21 @@ pub struct ProcessManager {
 #[derive(Debug, Clone)]
 pub enum QueryStatement {
     Sql(Statement),
-    Promql(EvalStmt),
+    // The optional string is the alias of the PromQL query.
+    Promql(EvalStmt, Option<String>),
 }
 
 impl Display for QueryStatement {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             QueryStatement::Sql(stmt) => write!(f, "{}", stmt),
-            QueryStatement::Promql(eval_stmt) => write!(f, "{}", eval_stmt),
+            QueryStatement::Promql(eval_stmt, alias) => {
+                if let Some(alias) = alias {
+                    write!(f, "{} AS {}", eval_stmt, alias)
+                } else {
+                    write!(f, "{}", eval_stmt)
+                }
+            }
         }
     }
 }
@@ -338,9 +345,9 @@ impl SlowQueryTimer {
         };
 
         match &self.stmt {
-            QueryStatement::Promql(stmt) => {
+            QueryStatement::Promql(stmt, _alias) => {
                 slow_query_event.is_promql = true;
-                slow_query_event.query = stmt.expr.to_string();
+                slow_query_event.query = self.stmt.to_string();
                 slow_query_event.promql_step = Some(stmt.interval.as_millis() as u64);
 
                 let start = stmt

src/catalog/src/system_schema/information_schema.rs

@@ -48,7 +48,7 @@ use datatypes::schema::SchemaRef;
 use lazy_static::lazy_static;
 use paste::paste;
 use process_list::InformationSchemaProcessList;
-use store_api::sst_entry::{ManifestSstEntry, StorageSstEntry};
+use store_api::sst_entry::{ManifestSstEntry, PuffinIndexMetaEntry, StorageSstEntry};
 use store_api::storage::{ScanRequest, TableId};
 use table::TableRef;
 use table::metadata::TableType;
@@ -68,7 +68,7 @@ use crate::system_schema::information_schema::region_peers::InformationSchemaReg
 use crate::system_schema::information_schema::runtime_metrics::InformationSchemaMetrics;
 use crate::system_schema::information_schema::schemata::InformationSchemaSchemata;
 use crate::system_schema::information_schema::ssts::{
-    InformationSchemaSstsManifest, InformationSchemaSstsStorage,
+    InformationSchemaSstsIndexMeta, InformationSchemaSstsManifest, InformationSchemaSstsStorage,
 };
 use crate::system_schema::information_schema::table_constraints::InformationSchemaTableConstraints;
 use crate::system_schema::information_schema::tables::InformationSchemaTables;
@@ -263,6 +263,9 @@ impl SystemSchemaProviderInner for InformationSchemaProvider {
             SSTS_STORAGE => Some(Arc::new(InformationSchemaSstsStorage::new(
                 self.catalog_manager.clone(),
             )) as _),
+            SSTS_INDEX_META => Some(Arc::new(InformationSchemaSstsIndexMeta::new(
+                self.catalog_manager.clone(),
+            )) as _),
             _ => None,
         }
     }
@@ -342,6 +345,10 @@ impl InformationSchemaProvider {
                 SSTS_STORAGE.to_string(),
                 self.build_table(SSTS_STORAGE).unwrap(),
             );
+            tables.insert(
+                SSTS_INDEX_META.to_string(),
+                self.build_table(SSTS_INDEX_META).unwrap(),
+            );
         }
 
         tables.insert(TABLES.to_string(), self.build_table(TABLES).unwrap());
@@ -362,7 +369,7 @@ impl InformationSchemaProvider {
         }
         #[cfg(feature = "enterprise")]
         for name in self.extra_table_factories.keys() {
-            tables.insert(name.to_string(), self.build_table(name).expect(name));
+            tables.insert(name.clone(), self.build_table(name).expect(name));
         }
         // Add memory tables
         for name in MEMORY_TABLES.iter() {
@@ -456,6 +463,8 @@ pub enum DatanodeInspectKind {
     SstManifest,
     /// List SST entries discovered in storage layer
     SstStorage,
+    /// List index metadata collected from manifest
+    SstIndexMeta,
 }
 
 impl DatanodeInspectRequest {
@@ -464,6 +473,7 @@ impl DatanodeInspectRequest {
         match self.kind {
             DatanodeInspectKind::SstManifest => ManifestSstEntry::build_plan(self.scan),
             DatanodeInspectKind::SstStorage => StorageSstEntry::build_plan(self.scan),
+            DatanodeInspectKind::SstIndexMeta => PuffinIndexMetaEntry::build_plan(self.scan),
         }
     }
 }

src/catalog/src/system_schema/information_schema/cluster_info.rs

@@ -33,7 +33,6 @@ use datatypes::timestamp::TimestampMillisecond;
 use datatypes::value::Value;
 use datatypes::vectors::{
     Int64VectorBuilder, StringVectorBuilder, TimestampMillisecondVectorBuilder,
-    UInt32VectorBuilder, UInt64VectorBuilder,
 };
 use serde::Serialize;
 use snafu::ResultExt;
@@ -50,8 +49,11 @@ const PEER_TYPE_METASRV: &str = "METASRV";
 const PEER_ID: &str = "peer_id";
 const PEER_TYPE: &str = "peer_type";
 const PEER_ADDR: &str = "peer_addr";
-const CPUS: &str = "cpus";
-const MEMORY_BYTES: &str = "memory_bytes";
+const PEER_HOSTNAME: &str = "peer_hostname";
+const TOTAL_CPU_MILLICORES: &str = "total_cpu_millicores";
+const TOTAL_MEMORY_BYTES: &str = "total_memory_bytes";
+const CPU_USAGE_MILLICORES: &str = "cpu_usage_millicores";
+const MEMORY_USAGE_BYTES: &str = "memory_usage_bytes";
 const VERSION: &str = "version";
 const GIT_COMMIT: &str = "git_commit";
 const START_TIME: &str = "start_time";
@@ -66,8 +68,11 @@ const INIT_CAPACITY: usize = 42;
 /// - `peer_id`: the peer server id.
 /// - `peer_type`: the peer type, such as `datanode`, `frontend`, `metasrv` etc.
 /// - `peer_addr`: the peer gRPC address.
-/// - `cpus`: the number of CPUs of the peer.
-/// - `memory_bytes`: the memory bytes of the peer.
+/// - `peer_hostname`: the hostname of the peer.
+/// - `total_cpu_millicores`: the total CPU millicores of the peer.
+/// - `total_memory_bytes`: the total memory bytes of the peer.
+/// - `cpu_usage_millicores`: the CPU usage millicores of the peer.
+/// - `memory_usage_bytes`: the memory usage bytes of the peer.
 /// - `version`: the build package version of the peer.
 /// - `git_commit`: the build git commit hash of the peer.
 /// - `start_time`: the starting time of the peer.
@@ -94,8 +99,27 @@ impl InformationSchemaClusterInfo {
             ColumnSchema::new(PEER_ID, ConcreteDataType::int64_datatype(), false),
             ColumnSchema::new(PEER_TYPE, ConcreteDataType::string_datatype(), false),
             ColumnSchema::new(PEER_ADDR, ConcreteDataType::string_datatype(), true),
-            ColumnSchema::new(CPUS, ConcreteDataType::uint32_datatype(), false),
-            ColumnSchema::new(MEMORY_BYTES, ConcreteDataType::uint64_datatype(), false),
+            ColumnSchema::new(PEER_HOSTNAME, ConcreteDataType::string_datatype(), true),
+            ColumnSchema::new(
+                TOTAL_CPU_MILLICORES,
+                ConcreteDataType::int64_datatype(),
+                false,
+            ),
+            ColumnSchema::new(
+                TOTAL_MEMORY_BYTES,
+                ConcreteDataType::int64_datatype(),
+                false,
+            ),
+            ColumnSchema::new(
+                CPU_USAGE_MILLICORES,
+                ConcreteDataType::int64_datatype(),
+                false,
+            ),
+            ColumnSchema::new(
+                MEMORY_USAGE_BYTES,
+                ConcreteDataType::int64_datatype(),
+                false,
+            ),
             ColumnSchema::new(VERSION, ConcreteDataType::string_datatype(), false),
             ColumnSchema::new(GIT_COMMIT, ConcreteDataType::string_datatype(), false),
             ColumnSchema::new(
@@ -155,8 +179,11 @@ struct InformationSchemaClusterInfoBuilder {
     peer_ids: Int64VectorBuilder,
     peer_types: StringVectorBuilder,
     peer_addrs: StringVectorBuilder,
-    cpus: UInt32VectorBuilder,
-    memory_bytes: UInt64VectorBuilder,
+    peer_hostnames: StringVectorBuilder,
+    total_cpu_millicores: Int64VectorBuilder,
+    total_memory_bytes: Int64VectorBuilder,
+    cpu_usage_millicores: Int64VectorBuilder,
+    memory_usage_bytes: Int64VectorBuilder,
     versions: StringVectorBuilder,
     git_commits: StringVectorBuilder,
     start_times: TimestampMillisecondVectorBuilder,
@@ -173,8 +200,11 @@ impl InformationSchemaClusterInfoBuilder {
             peer_ids: Int64VectorBuilder::with_capacity(INIT_CAPACITY),
             peer_types: StringVectorBuilder::with_capacity(INIT_CAPACITY),
             peer_addrs: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            cpus: UInt32VectorBuilder::with_capacity(INIT_CAPACITY),
-            memory_bytes: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
+            peer_hostnames: StringVectorBuilder::with_capacity(INIT_CAPACITY),
+            total_cpu_millicores: Int64VectorBuilder::with_capacity(INIT_CAPACITY),
+            total_memory_bytes: Int64VectorBuilder::with_capacity(INIT_CAPACITY),
+            cpu_usage_millicores: Int64VectorBuilder::with_capacity(INIT_CAPACITY),
+            memory_usage_bytes: Int64VectorBuilder::with_capacity(INIT_CAPACITY),
             versions: StringVectorBuilder::with_capacity(INIT_CAPACITY),
             git_commits: StringVectorBuilder::with_capacity(INIT_CAPACITY),
             start_times: TimestampMillisecondVectorBuilder::with_capacity(INIT_CAPACITY),
@@ -203,6 +233,7 @@ impl InformationSchemaClusterInfoBuilder {
             (PEER_ID, &Value::from(peer_id)),
             (PEER_TYPE, &Value::from(peer_type)),
             (PEER_ADDR, &Value::from(node_info.peer.addr.as_str())),
+            (PEER_HOSTNAME, &Value::from(node_info.hostname.as_str())),
             (VERSION, &Value::from(node_info.version.as_str())),
             (GIT_COMMIT, &Value::from(node_info.git_commit.as_str())),
         ];
@@ -214,6 +245,7 @@ impl InformationSchemaClusterInfoBuilder {
         self.peer_ids.push(Some(peer_id));
         self.peer_types.push(Some(peer_type));
         self.peer_addrs.push(Some(&node_info.peer.addr));
+        self.peer_hostnames.push(Some(&node_info.hostname));
         self.versions.push(Some(&node_info.version));
         self.git_commits.push(Some(&node_info.git_commit));
         if node_info.start_time_ms > 0 {
@@ -228,8 +260,14 @@ impl InformationSchemaClusterInfoBuilder {
             self.start_times.push(None);
             self.uptimes.push(None);
         }
-        self.cpus.push(Some(node_info.cpus));
-        self.memory_bytes.push(Some(node_info.memory_bytes));
+        self.total_cpu_millicores
+            .push(Some(node_info.total_cpu_millicores));
+        self.total_memory_bytes
+            .push(Some(node_info.total_memory_bytes));
+        self.cpu_usage_millicores
+            .push(Some(node_info.cpu_usage_millicores));
+        self.memory_usage_bytes
+            .push(Some(node_info.memory_usage_bytes));
 
         if node_info.last_activity_ts > 0 {
             self.active_times.push(Some(
@@ -253,8 +291,11 @@ impl InformationSchemaClusterInfoBuilder {
             Arc::new(self.peer_ids.finish()),
             Arc::new(self.peer_types.finish()),
             Arc::new(self.peer_addrs.finish()),
-            Arc::new(self.cpus.finish()),
-            Arc::new(self.memory_bytes.finish()),
+            Arc::new(self.peer_hostnames.finish()),
+            Arc::new(self.total_cpu_millicores.finish()),
+            Arc::new(self.total_memory_bytes.finish()),
+            Arc::new(self.cpu_usage_millicores.finish()),
+            Arc::new(self.memory_usage_bytes.finish()),
             Arc::new(self.versions.finish()),
             Arc::new(self.git_commits.finish()),
             Arc::new(self.start_times.finish()),

src/catalog/src/system_schema/information_schema/flows.rs

@@ -254,9 +254,9 @@ impl InformationSchemaFlowsBuilder {
                 .await
                 .map_err(BoxedError::new)
                 .context(InternalSnafu)?
-                .context(FlowInfoNotFoundSnafu {
-                    catalog_name: catalog_name.to_string(),
-                    flow_name: flow_name.to_string(),
+                .with_context(|| FlowInfoNotFoundSnafu {
+                    catalog_name: catalog_name.clone(),
+                    flow_name: flow_name.clone(),
                 })?;
             self.add_flow(&predicates, flow_id.flow_id(), flow_info, &flow_stat)
                 .await?;
@@ -273,11 +273,11 @@ impl InformationSchemaFlowsBuilder {
         flow_stat: &Option<FlowStat>,
     ) -> Result<()> {
         let row = [
-            (FLOW_NAME, &Value::from(flow_info.flow_name().to_string())),
+            (FLOW_NAME, &Value::from(flow_info.flow_name().clone())),
             (FLOW_ID, &Value::from(flow_id)),
             (
                 TABLE_CATALOG,
-                &Value::from(flow_info.catalog_name().to_string()),
+                &Value::from(flow_info.catalog_name().clone()),
             ),
         ];
         if !predicates.eval(&row) {

src/catalog/src/system_schema/information_schema/process_list.rs

@@ -135,7 +135,7 @@ async fn make_process_list(
 
     for process in queries {
         let display_id = DisplayProcessId {
-            server_addr: process.frontend.to_string(),
+            server_addr: process.frontend.clone(),
             id: process.id,
         }
         .to_string();

src/catalog/src/system_schema/information_schema/region_peers.rs

@@ -199,10 +199,7 @@ impl InformationSchemaRegionPeersBuilder {
                     if table_info.table_type == TableType::Temporary {
                         Ok(None)
                     } else {
-                        Ok(Some((
-                            table_info.ident.table_id,
-                            table_info.name.to_string(),
-                        )))
+                        Ok(Some((table_info.ident.table_id, table_info.name.clone())))
                     }
                 });
 

src/catalog/src/system_schema/information_schema/ssts.rs

@@ -15,20 +15,22 @@
 use std::sync::{Arc, Weak};
 
 use common_catalog::consts::{
-    INFORMATION_SCHEMA_SSTS_MANIFEST_TABLE_ID, INFORMATION_SCHEMA_SSTS_STORAGE_TABLE_ID,
+    INFORMATION_SCHEMA_SSTS_INDEX_META_TABLE_ID, INFORMATION_SCHEMA_SSTS_MANIFEST_TABLE_ID,
+    INFORMATION_SCHEMA_SSTS_STORAGE_TABLE_ID,
 };
 use common_error::ext::BoxedError;
 use common_recordbatch::SendableRecordBatchStream;
 use common_recordbatch::adapter::AsyncRecordBatchStreamAdapter;
 use datatypes::schema::SchemaRef;
 use snafu::ResultExt;
-use store_api::sst_entry::{ManifestSstEntry, StorageSstEntry};
+use store_api::sst_entry::{ManifestSstEntry, PuffinIndexMetaEntry, StorageSstEntry};
 use store_api::storage::{ScanRequest, TableId};
 
 use crate::CatalogManager;
 use crate::error::{ProjectSchemaSnafu, Result};
 use crate::information_schema::{
-    DatanodeInspectKind, DatanodeInspectRequest, InformationTable, SSTS_MANIFEST, SSTS_STORAGE,
+    DatanodeInspectKind, DatanodeInspectRequest, InformationTable, SSTS_INDEX_META, SSTS_MANIFEST,
+    SSTS_STORAGE,
 };
 use crate::system_schema::utils;
 
@@ -140,3 +142,58 @@ impl InformationTable for InformationSchemaSstsStorage {
         )))
     }
 }
+
+/// Information schema table for index metadata.
+pub struct InformationSchemaSstsIndexMeta {
+    schema: SchemaRef,
+    catalog_manager: Weak<dyn CatalogManager>,
+}
+
+impl InformationSchemaSstsIndexMeta {
+    pub(super) fn new(catalog_manager: Weak<dyn CatalogManager>) -> Self {
+        Self {
+            schema: PuffinIndexMetaEntry::schema(),
+            catalog_manager,
+        }
+    }
+}
+
+impl InformationTable for InformationSchemaSstsIndexMeta {
+    fn table_id(&self) -> TableId {
+        INFORMATION_SCHEMA_SSTS_INDEX_META_TABLE_ID
+    }
+
+    fn table_name(&self) -> &'static str {
+        SSTS_INDEX_META
+    }
+
+    fn schema(&self) -> SchemaRef {
+        self.schema.clone()
+    }
+
+    fn to_stream(&self, request: ScanRequest) -> Result<SendableRecordBatchStream> {
+        let schema = if let Some(p) = &request.projection {
+            Arc::new(self.schema.try_project(p).context(ProjectSchemaSnafu)?)
+        } else {
+            self.schema.clone()
+        };
+
+        let info_ext = utils::information_extension(&self.catalog_manager)?;
+        let req = DatanodeInspectRequest {
+            kind: DatanodeInspectKind::SstIndexMeta,
+            scan: request,
+        };
+
+        let future = async move {
+            info_ext
+                .inspect_datanode(req)
+                .await
+                .map_err(BoxedError::new)
+                .context(common_recordbatch::error::ExternalSnafu)
+        };
+        Ok(Box::pin(AsyncRecordBatchStreamAdapter::new(
+            schema,
+            Box::pin(future),
+        )))
+    }
+}

src/catalog/src/system_schema/information_schema/table_names.rs

@@ -50,3 +50,4 @@ pub const REGION_STATISTICS: &str = "region_statistics";
 pub const PROCESS_LIST: &str = "process_list";
 pub const SSTS_MANIFEST: &str = "ssts_manifest";
 pub const SSTS_STORAGE: &str = "ssts_storage";
+pub const SSTS_INDEX_META: &str = "ssts_index_meta";

src/catalog/src/system_schema/information_schema/tables.rs

@@ -371,7 +371,8 @@ impl InformationSchemaTablesBuilder {
         self.auto_increment.push(Some(0));
         self.row_format.push(Some("Fixed"));
         self.table_collation.push(Some("utf8_bin"));
-        self.update_time.push(None);
+        self.update_time
+            .push(Some(table_info.meta.updated_on.timestamp().into()));
         self.check_time.push(None);
         // use mariadb default table version number here
         self.version.push(Some(11));

src/catalog/src/system_schema/pg_catalog.rs

@@ -27,6 +27,7 @@ use datafusion::error::DataFusionError;
 use datafusion::execution::TaskContext;
 use datafusion::physical_plan::stream::RecordBatchStreamAdapter as DfRecordBatchStreamAdapter;
 use datafusion_pg_catalog::pg_catalog::catalog_info::CatalogInfo;
+use datafusion_pg_catalog::pg_catalog::context::EmptyContextProvider;
 use datafusion_pg_catalog::pg_catalog::{
     PG_CATALOG_TABLES, PgCatalogSchemaProvider, PgCatalogStaticTables, PgCatalogTable,
 };
@@ -44,7 +45,7 @@ use crate::system_schema::{
 /// [`PGCatalogProvider`] is the provider for a schema named `pg_catalog`, it is not a catalog.
 pub struct PGCatalogProvider {
     catalog_name: String,
-    inner: PgCatalogSchemaProvider<CatalogManagerWrapper>,
+    inner: PgCatalogSchemaProvider<CatalogManagerWrapper, EmptyContextProvider>,
     tables: HashMap<String, TableRef>,
     table_ids: HashMap<&'static str, u32>,
 }
@@ -69,6 +70,7 @@ impl PGCatalogProvider {
                 catalog_manager,
             },
             Arc::new(static_tables),
+            EmptyContextProvider,
         )
         .expect("Failed to initialize PgCatalogSchemaProvider");
 
@@ -166,7 +168,7 @@ impl CatalogInfo for CatalogManagerWrapper {
                 .await
                 .map_err(|e| DataFusionError::External(Box::new(e)))
         } else {
-            Ok(vec![self.catalog_name.to_string()])
+            Ok(vec![self.catalog_name.clone()])
         }
     }
 

src/catalog/src/table_source.rs

@@ -201,7 +201,7 @@ impl DfTableSourceProvider {
 
         Ok(Arc::new(ViewTable::new(
             logical_plan,
-            Some(view_info.definition.to_string()),
+            Some(view_info.definition.clone()),
         )))
     }
 }

src/cli/Cargo.toml

@@ -61,7 +61,6 @@ servers.workspace = true
 session.workspace = true
 snafu.workspace = true
 store-api.workspace = true
-substrait.workspace = true
 table.workspace = true
 tokio.workspace = true
 tracing-appender.workspace = true

src/cli/src/bench.rs

@@ -157,6 +157,7 @@ fn create_table_info(table_id: TableId, table_name: TableName) -> RawTableInfo {
         schema: RawSchema::new(column_schemas),
         engine: "mito".to_string(),
         created_on: chrono::DateTime::default(),
+        updated_on: chrono::DateTime::default(),
         primary_key_indices: vec![],
         next_column_id: columns as u32 + 1,
         value_indices: vec![],

src/cli/src/metadata/control/del/key.rs

@@ -41,7 +41,7 @@ impl DelKeyCommand {
     pub async fn build(&self) -> Result<Box<dyn Tool>, BoxedError> {
         let kv_backend = self.store.build().await?;
         Ok(Box::new(DelKeyTool {
-            key: self.key.to_string(),
+            key: self.key.clone(),
             prefix: self.prefix,
             key_deleter: KeyDeleter::new(kv_backend),
         }))

src/cli/src/metadata/repair.rs

@@ -138,13 +138,7 @@ impl RepairTool {
 
             let table_names = table_names
                 .iter()
-                .map(|table_name| {
-                    (
-                        catalog.to_string(),
-                        schema_name.to_string(),
-                        table_name.to_string(),
-                    )
-                })
+                .map(|table_name| (catalog.clone(), schema_name.clone(), table_name.clone()))
                 .collect::<Vec<_>>();
             return Ok(IteratorInput::new_table_names(table_names));
         } else if !self.table_ids.is_empty() {

src/cli/src/metadata/repair/alter_table.rs

@@ -32,9 +32,9 @@ pub fn generate_alter_table_expr_for_all_columns(
     let schema = &table_info.meta.schema;
 
     let mut alter_table_expr = AlterTableExpr {
-        catalog_name: table_info.catalog_name.to_string(),
-        schema_name: table_info.schema_name.to_string(),
-        table_name: table_info.name.to_string(),
+        catalog_name: table_info.catalog_name.clone(),
+        schema_name: table_info.schema_name.clone(),
+        table_name: table_info.name.clone(),
         ..Default::default()
     };
 

src/cli/src/metadata/repair/create_table.rs

@@ -44,9 +44,9 @@ pub fn generate_create_table_expr(table_info: &RawTableInfo) -> Result<CreateTab
     let table_options = HashMap::from(&table_info.meta.options);
 
     Ok(CreateTableExpr {
-        catalog_name: table_info.catalog_name.to_string(),
-        schema_name: table_info.schema_name.to_string(),
-        table_name: table_info.name.to_string(),
+        catalog_name: table_info.catalog_name.clone(),
+        schema_name: table_info.schema_name.clone(),
+        table_name: table_info.name.clone(),
         desc: String::default(),
         column_defs,
         time_index,
@@ -54,7 +54,7 @@ pub fn generate_create_table_expr(table_info: &RawTableInfo) -> Result<CreateTab
         create_if_not_exists: true,
         table_options,
         table_id: None,
-        engine: table_info.meta.engine.to_string(),
+        engine: table_info.meta.engine.clone(),
     })
 }
 

src/client/src/error.rs

@@ -18,7 +18,7 @@ use common_error::define_from_tonic_status;
 use common_error::ext::{BoxedError, ErrorExt};
 use common_error::status_code::StatusCode;
 use common_macro::stack_trace_debug;
-use snafu::{Location, Snafu, location};
+use snafu::{Location, Snafu};
 use tonic::Code;
 use tonic::metadata::errors::InvalidMetadataValue;
 

src/cmd/Cargo.toml

@@ -82,7 +82,6 @@ similar-asserts.workspace = true
 snafu.workspace = true
 common-stat.workspace = true
 store-api.workspace = true
-substrait.workspace = true
 table.workspace = true
 tokio.workspace = true
 toml.workspace = true

src/cmd/src/error.rs

@@ -316,6 +316,13 @@ pub enum Error {
         location: Location,
         source: standalone::error::Error,
     },
+
+    #[snafu(display("Invalid WAL provider"))]
+    InvalidWalProvider {
+        #[snafu(implicit)]
+        location: Location,
+        source: common_wal::error::Error,
+    },
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -373,6 +380,7 @@ impl ErrorExt for Error {
             }
             Error::MetaClientInit { source, .. } => source.status_code(),
             Error::SchemaNotFound { .. } => StatusCode::DatabaseNotFound,
+            Error::InvalidWalProvider { .. } => StatusCode::InvalidArguments,
         }
     }
 

src/cmd/src/flownode.rs

@@ -30,6 +30,7 @@ use common_meta::heartbeat::handler::invalidate_table_cache::InvalidateCacheHand
 use common_meta::heartbeat::handler::parse_mailbox_message::ParseMailboxMessageHandler;
 use common_meta::key::TableMetadataManager;
 use common_meta::key::flow::FlowMetadataManager;
+use common_stat::ResourceStatImpl;
 use common_telemetry::info;
 use common_telemetry::logging::{DEFAULT_LOGGING_DIR, TracingOptions};
 use common_version::{short_version, verbose_version};
@@ -372,11 +373,15 @@ impl StartCommand {
             Arc::new(InvalidateCacheHandler::new(layered_cache_registry.clone())),
         ]);
 
+        let mut resource_stat = ResourceStatImpl::default();
+        resource_stat.start_collect_cpu_usage();
+
         let heartbeat_task = flow::heartbeat::HeartbeatTask::new(
             &opts,
             meta_client.clone(),
             opts.heartbeat.clone(),
             Arc::new(executor),
+            Arc::new(resource_stat),
         );
 
         let flow_metadata_manager = Arc::new(FlowMetadataManager::new(cached_meta_backend.clone()));

src/cmd/src/frontend.rs

@@ -25,11 +25,14 @@ use clap::Parser;
 use client::client_manager::NodeClients;
 use common_base::Plugins;
 use common_config::{Configurable, DEFAULT_DATA_HOME};
+use common_error::ext::BoxedError;
 use common_grpc::channel_manager::ChannelConfig;
 use common_meta::cache::{CacheRegistryBuilder, LayeredCacheRegistryBuilder};
 use common_meta::heartbeat::handler::HandlerGroupExecutor;
 use common_meta::heartbeat::handler::invalidate_table_cache::InvalidateCacheHandler;
 use common_meta::heartbeat::handler::parse_mailbox_message::ParseMailboxMessageHandler;
+use common_query::prelude::set_default_prefix;
+use common_stat::ResourceStatImpl;
 use common_telemetry::info;
 use common_telemetry::logging::{DEFAULT_LOGGING_DIR, TracingOptions};
 use common_time::timezone::set_default_timezone;
@@ -252,10 +255,10 @@ impl StartCommand {
 
         if let Some(addr) = &self.internal_rpc_bind_addr {
             if let Some(internal_grpc) = &mut opts.internal_grpc {
-                internal_grpc.bind_addr = addr.to_string();
+                internal_grpc.bind_addr = addr.clone();
             } else {
                 let grpc_options = GrpcOptions {
-                    bind_addr: addr.to_string(),
+                    bind_addr: addr.clone(),
                     ..Default::default()
                 };
 
@@ -265,10 +268,10 @@ impl StartCommand {
 
         if let Some(addr) = &self.internal_rpc_server_addr {
             if let Some(internal_grpc) = &mut opts.internal_grpc {
-                internal_grpc.server_addr = addr.to_string();
+                internal_grpc.server_addr = addr.clone();
             } else {
                 let grpc_options = GrpcOptions {
-                    server_addr: addr.to_string(),
+                    server_addr: addr.clone(),
                     ..Default::default()
                 };
                 opts.internal_grpc = Some(grpc_options);
@@ -332,6 +335,9 @@ impl StartCommand {
             .context(error::StartFrontendSnafu)?;
 
         set_default_timezone(opts.default_timezone.as_deref()).context(error::InitTimezoneSnafu)?;
+        set_default_prefix(opts.default_column_prefix.as_deref())
+            .map_err(BoxedError::new)
+            .context(error::BuildCliSnafu)?;
 
         let meta_client_options = opts
             .meta_client
@@ -421,11 +427,15 @@ impl StartCommand {
             Arc::new(InvalidateCacheHandler::new(layered_cache_registry.clone())),
         ]);
 
+        let mut resource_stat = ResourceStatImpl::default();
+        resource_stat.start_collect_cpu_usage();
+
         let heartbeat_task = HeartbeatTask::new(
             &opts,
             meta_client.clone(),
             opts.heartbeat.clone(),
             Arc::new(executor),
+            Arc::new(resource_stat),
         );
         let heartbeat_task = Some(heartbeat_task);
 

src/cmd/src/lib.rs

@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(assert_matches, let_chains)]
+#![feature(assert_matches)]
 
 use async_trait::async_trait;
 use common_error::ext::ErrorExt;
 use common_error::status_code::StatusCode;
 use common_mem_prof::activate_heap_profile;
-use common_stat::{get_cpu_limit, get_memory_limit};
+use common_stat::{get_total_cpu_millicores, get_total_memory_bytes};
 use common_telemetry::{error, info, warn};
 
 use crate::error::Result;
@@ -125,7 +125,8 @@ pub fn log_versions(version: &str, short_version: &str, app: &str) {
 }
 
 pub fn create_resource_limit_metrics(app: &str) {
-    if let Some(cpu_limit) = get_cpu_limit() {
+    let cpu_limit = get_total_cpu_millicores();
+    if cpu_limit > 0 {
         info!(
             "GreptimeDB start with cpu limit in millicores: {}",
             cpu_limit
@@ -133,7 +134,8 @@ pub fn create_resource_limit_metrics(app: &str) {
         CPU_LIMIT.with_label_values(&[app]).set(cpu_limit);
     }
 
-    if let Some(memory_limit) = get_memory_limit() {
+    let memory_limit = get_total_memory_bytes();
+    if memory_limit > 0 {
         info!(
             "GreptimeDB start with memory limit in bytes: {}",
             memory_limit

src/cmd/src/standalone.rs

@@ -19,6 +19,7 @@ use std::{fs, path};
 
 use async_trait::async_trait;
 use cache::{build_fundamental_cache_registry, with_default_composite_cache_registry};
+use catalog::information_schema::InformationExtensionRef;
 use catalog::kvbackend::KvBackendCatalogManagerBuilder;
 use catalog::process_manager::ProcessManager;
 use clap::Parser;
@@ -40,6 +41,7 @@ use common_meta::region_registry::LeaderRegionRegistry;
 use common_meta::sequence::SequenceBuilder;
 use common_meta::wal_options_allocator::{WalOptionsAllocatorRef, build_wal_options_allocator};
 use common_procedure::ProcedureManagerRef;
+use common_query::prelude::set_default_prefix;
 use common_telemetry::info;
 use common_telemetry::logging::{DEFAULT_LOGGING_DIR, TracingOptions};
 use common_time::timezone::set_default_timezone;
@@ -354,6 +356,10 @@ impl StartCommand {
         let mut plugins = Plugins::new();
         let plugin_opts = opts.plugins;
         let mut opts = opts.component;
+        set_default_prefix(opts.default_column_prefix.as_deref())
+            .map_err(BoxedError::new)
+            .context(error::BuildCliSnafu)?;
+
         opts.grpc.detect_server_addr();
         let fe_opts = opts.frontend_options();
         let dn_opts = opts.datanode_options();
@@ -404,6 +410,8 @@ impl StartCommand {
             procedure_manager.clone(),
         ));
 
+        plugins.insert::<InformationExtensionRef>(information_extension.clone());
+
         let process_manager = Arc::new(ProcessManager::new(opts.grpc.server_addr.clone(), None));
         let builder = KvBackendCatalogManagerBuilder::new(
             information_extension.clone(),
@@ -473,7 +481,11 @@ impl StartCommand {
                 .step(10)
                 .build(),
         );
-        let kafka_options = opts.wal.clone().into();
+        let kafka_options = opts
+            .wal
+            .clone()
+            .try_into()
+            .context(error::InvalidWalProviderSnafu)?;
         let wal_options_allocator = build_wal_options_allocator(&kafka_options, kv_backend.clone())
             .await
             .context(error::BuildWalOptionsAllocatorSnafu)?;

src/cmd/tests/load_config_test.rs

@@ -48,6 +48,7 @@ fn test_load_datanode_example_config() {
     let expected = GreptimeOptions::<DatanodeOptions> {
         component: DatanodeOptions {
             node_id: Some(42),
+            default_column_prefix: Some("greptime".to_string()),
             meta_client: Some(MetaClientOptions {
                 metasrv_addrs: vec!["127.0.0.1:3002".to_string()],
                 timeout: Duration::from_secs(3),
@@ -113,6 +114,7 @@ fn test_load_frontend_example_config() {
     let expected = GreptimeOptions::<FrontendOptions> {
         component: FrontendOptions {
             default_timezone: Some("UTC".to_string()),
+            default_column_prefix: Some("greptime".to_string()),
             meta_client: Some(MetaClientOptions {
                 metasrv_addrs: vec!["127.0.0.1:3002".to_string()],
                 timeout: Duration::from_secs(3),
@@ -273,6 +275,7 @@ fn test_load_standalone_example_config() {
     let expected = GreptimeOptions::<StandaloneOptions> {
         component: StandaloneOptions {
             default_timezone: Some("UTC".to_string()),
+            default_column_prefix: Some("greptime".to_string()),
             wal: DatanodeWalConfig::RaftEngine(RaftEngineConfig {
                 dir: Some(format!("{}/{}", DEFAULT_DATA_HOME, WAL_DIR)),
                 sync_period: Some(Duration::from_secs(10)),

src/common/base/Cargo.toml

@@ -18,9 +18,11 @@ bytes.workspace = true
 common-error.workspace = true
 common-macro.workspace = true
 futures.workspace = true
+lazy_static.workspace = true
 paste.workspace = true
 pin-project.workspace = true
 rand.workspace = true
+regex.workspace = true
 serde = { version = "1.0", features = ["derive"] }
 snafu.workspace = true
 tokio.workspace = true

src/common/base/src/lib.rs

@@ -19,6 +19,7 @@ pub mod plugins;
 pub mod range_read;
 #[allow(clippy::all)]
 pub mod readable_size;
+pub mod regex_pattern;
 pub mod secrets;
 pub mod serde;
 

src/common/base/src/plugins.rs

@@ -75,11 +75,11 @@ impl Plugins {
         self.read().is_empty()
     }
 
-    fn read(&self) -> RwLockReadGuard<SendSyncAnyMap> {
+    fn read(&self) -> RwLockReadGuard<'_, SendSyncAnyMap> {
         self.inner.read().unwrap()
     }
 
-    fn write(&self) -> RwLockWriteGuard<SendSyncAnyMap> {
+    fn write(&self) -> RwLockWriteGuard<'_, SendSyncAnyMap> {
         self.inner.write().unwrap()
     }
 }

src/common/base/src/regex_pattern.rs

@@ -0,0 +1,22 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use lazy_static::lazy_static;
+use regex::Regex;
+
+pub const NAME_PATTERN: &str = r"[a-zA-Z_:-][a-zA-Z0-9_:\-\.@#]*";
+
+lazy_static! {
+    pub static ref NAME_PATTERN_REG: Regex = Regex::new(&format!("^{NAME_PATTERN}$")).unwrap();
+}

src/common/catalog/src/consts.rs

@@ -108,6 +108,8 @@ pub const INFORMATION_SCHEMA_PROCESS_LIST_TABLE_ID: u32 = 36;
 pub const INFORMATION_SCHEMA_SSTS_MANIFEST_TABLE_ID: u32 = 37;
 /// id for information_schema.ssts_storage
 pub const INFORMATION_SCHEMA_SSTS_STORAGE_TABLE_ID: u32 = 38;
+/// id for information_schema.ssts_index_meta
+pub const INFORMATION_SCHEMA_SSTS_INDEX_META_TABLE_ID: u32 = 39;
 
 // ----- End of information_schema tables -----
 
@@ -148,4 +150,9 @@ pub const TRACE_TABLE_NAME_SESSION_KEY: &str = "trace_table_name";
 pub fn trace_services_table_name(trace_table_name: &str) -> String {
     format!("{}_services", trace_table_name)
 }
+
+/// Generate the trace operations table name from the trace table name by adding `_operations` suffix.
+pub fn trace_operations_table_name(trace_table_name: &str) -> String {
+    format!("{}_operations", trace_table_name)
+}
 // ---- End of special table and fields ----

src/common/config/Cargo.toml

@@ -13,13 +13,11 @@ common-error.workspace = true
 common-macro.workspace = true
 config.workspace = true
 humantime-serde.workspace = true
-num_cpus.workspace = true
 object-store.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 serde_with.workspace = true
 snafu.workspace = true
-sysinfo.workspace = true
 toml.workspace = true
 
 [dev-dependencies]

src/common/config/src/lib.rs

@@ -14,7 +14,6 @@
 
 pub mod config;
 pub mod error;
-pub mod utils;
 
 use std::time::Duration;
 

src/common/config/src/utils.rs

@@ -1,73 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use common_base::readable_size::ReadableSize;
-use sysinfo::System;
-
-/// Get the CPU core number of system, aware of cgroups.
-pub fn get_cpus() -> usize {
-    // This function will check cgroups
-    num_cpus::get()
-}
-
-/// Get the total memory of the system.
-/// If `cgroup_limits` is enabled, it will also check it.
-pub fn get_sys_total_memory() -> Option<ReadableSize> {
-    if sysinfo::IS_SUPPORTED_SYSTEM {
-        let mut sys_info = System::new();
-        sys_info.refresh_memory();
-        let mut total_memory = sys_info.total_memory();
-        // Compare with cgroups memory limit, use smaller values
-        // This method is only implemented for Linux. It always returns None for all other systems.
-        if let Some(cgroup_limits) = sys_info.cgroup_limits() {
-            total_memory = total_memory.min(cgroup_limits.total_memory)
-        }
-        Some(ReadableSize(total_memory))
-    } else {
-        None
-    }
-}
-
-/// `ResourceSpec` holds the static resource specifications of a node,
-/// such as CPU cores and memory capacity. These values are fixed
-/// at startup and do not change dynamically during runtime.
-#[derive(Debug, Clone, Copy)]
-pub struct ResourceSpec {
-    pub cpus: usize,
-    pub memory: Option<ReadableSize>,
-}
-
-impl Default for ResourceSpec {
-    fn default() -> Self {
-        Self {
-            cpus: get_cpus(),
-            memory: get_sys_total_memory(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_get_cpus() {
-        assert!(get_cpus() > 0);
-    }
-
-    #[test]
-    fn test_get_sys_total_memory() {
-        assert!(get_sys_total_memory().unwrap() > ReadableSize::mb(0));
-    }
-}

src/common/datasource/Cargo.toml

@@ -36,7 +36,7 @@ object_store_opendal.workspace = true
 orc-rust = { version = "0.6.3", default-features = false, features = ["async"] }
 parquet.workspace = true
 paste.workspace = true
-regex = "1.7"
+regex.workspace = true
 serde.workspace = true
 snafu.workspace = true
 strum.workspace = true

src/common/datasource/src/buffered_writer.rs

@@ -150,7 +150,7 @@ impl<
         if let Some(ref mut writer) = self.writer {
             Ok(writer)
         } else {
-            let writer = (self.writer_factory)(self.path.to_string()).await?;
+            let writer = (self.writer_factory)(self.path.clone()).await?;
             Ok(self.writer.insert(writer))
         }
     }

src/common/datasource/src/file_format.rs

@@ -33,7 +33,7 @@ use bytes::{Buf, Bytes};
 use datafusion::datasource::physical_plan::FileOpenFuture;
 use datafusion::error::{DataFusionError, Result as DataFusionResult};
 use datafusion::physical_plan::SendableRecordBatchStream;
-use futures::StreamExt;
+use futures::{StreamExt, TryStreamExt};
 use object_store::ObjectStore;
 use snafu::ResultExt;
 use tokio_util::compat::FuturesAsyncWriteCompatExt;
@@ -179,7 +179,7 @@ pub fn open_with_decoder<T: ArrowDecoder, F: Fn() -> DataFusionResult<T>>(
             Poll::Ready(decoder.flush().transpose())
         });
 
-        Ok(stream.boxed())
+        Ok(stream.map_err(Into::into).boxed())
     }))
 }
 

src/common/datasource/src/test_util.rs

@@ -87,7 +87,7 @@ pub(crate) fn scan_config(
 ) -> FileScanConfig {
     // object_store only recognize the Unix style path, so make it happy.
     let filename = &filename.replace('\\', "/");
-    let file_group = FileGroup::new(vec![PartitionedFile::new(filename.to_string(), 4096)]);
+    let file_group = FileGroup::new(vec![PartitionedFile::new(filename.clone(), 4096)]);
 
     FileScanConfigBuilder::new(ObjectStoreUrl::local_filesystem(), file_schema, file_source)
         .with_file_group(file_group)

src/common/function/Cargo.toml

@@ -51,6 +51,7 @@ nalgebra.workspace = true
 num = "0.4"
 num-traits = "0.2"
 paste.workspace = true
+regex.workspace = true
 s2 = { version = "0.0.12", optional = true }
 serde.workspace = true
 serde_json.workspace = true

src/common/function/src/admin/flush_compact_table.rs

@@ -37,6 +37,8 @@ const COMPACT_TYPE_STRICT_WINDOW: &str = "strict_window";
 /// Compact type: strict window (short name).
 const COMPACT_TYPE_STRICT_WINDOW_SHORT: &str = "swcs";
 
+const DEFAULT_COMPACTION_PARALLELISM: u32 = 1;
+
 #[admin_fn(
     name = FlushTableFunction,
     display_name = flush_table,
@@ -95,7 +97,7 @@ pub(crate) async fn compact_table(
     query_ctx: &QueryContextRef,
     params: &[ValueRef<'_>],
 ) -> Result<Value> {
-    let request = parse_compact_params(params, query_ctx)?;
+    let request = parse_compact_request(params, query_ctx)?;
     info!("Compact table request: {:?}", request);
 
     let affected_rows = table_mutation_handler
@@ -117,37 +119,46 @@ fn compact_signature() -> Signature {
 /// - `[<table_name>]`: only tables name provided, using default compaction type: regular
 /// - `[<table_name>, <type>]`: specify table name and compaction type. The compaction options will be default.
 /// - `[<table_name>, <type>, <options>]`: provides both type and type-specific options.
-fn parse_compact_params(
+///   - For `twcs`, it accepts `parallelism=[N]` where N is an unsigned 32 bits number
+///   - For `swcs`, it accepts two numeric parameter: `parallelism` and `window`.
+fn parse_compact_request(
     params: &[ValueRef<'_>],
     query_ctx: &QueryContextRef,
 ) -> Result<CompactTableRequest> {
     ensure!(
-        !params.is_empty(),
+        !params.is_empty() && params.len() <= 3,
         InvalidFuncArgsSnafu {
-            err_msg: "Args cannot be empty",
+            err_msg: format!(
+                "The length of the args is not correct, expect 1-4, have: {}",
+                params.len()
+            ),
         }
     );
 
-    let (table_name, compact_type) = match params {
+    let (table_name, compact_type, parallelism) = match params {
+        // 1. Only table name, strategy defaults to twcs and default parallelism.
         [ValueRef::String(table_name)] => (
             table_name,
             compact_request::Options::Regular(Default::default()),
+            DEFAULT_COMPACTION_PARALLELISM,
         ),
+        // 2. Both table name and strategy are provided.
         [
             ValueRef::String(table_name),
             ValueRef::String(compact_ty_str),
         ] => {
-            let compact_type = parse_compact_type(compact_ty_str, None)?;
-            (table_name, compact_type)
+            let (compact_type, parallelism) = parse_compact_options(compact_ty_str, None)?;
+            (table_name, compact_type, parallelism)
         }
-
+        // 3. Table name, strategy and strategy specific options
         [
             ValueRef::String(table_name),
             ValueRef::String(compact_ty_str),
             ValueRef::String(options_str),
         ] => {
-            let compact_type = parse_compact_type(compact_ty_str, Some(options_str))?;
-            (table_name, compact_type)
+            let (compact_type, parallelism) =
+                parse_compact_options(compact_ty_str, Some(options_str))?;
+            (table_name, compact_type, parallelism)
         }
         _ => {
             return UnsupportedInputDataTypeSnafu {
@@ -167,35 +178,126 @@ fn parse_compact_params(
         schema_name,
         table_name,
         compact_options: compact_type,
+        parallelism,
     })
 }
 
-/// Parses compaction strategy type. For `strict_window` or `swcs` strict window compaction is chose,
+/// Parses compaction strategy type. For `strict_window` or `swcs` strict window compaction is chosen,
 /// otherwise choose regular (TWCS) compaction.
-fn parse_compact_type(type_str: &str, option: Option<&str>) -> Result<compact_request::Options> {
+fn parse_compact_options(
+    type_str: &str,
+    option: Option<&str>,
+) -> Result<(compact_request::Options, u32)> {
     if type_str.eq_ignore_ascii_case(COMPACT_TYPE_STRICT_WINDOW)
         | type_str.eq_ignore_ascii_case(COMPACT_TYPE_STRICT_WINDOW_SHORT)
     {
-        let window_seconds = option
-            .map(|v| {
-                i64::from_str(v).map_err(|_| {
-                    InvalidFuncArgsSnafu {
-                        err_msg: format!(
-                            "Compact window is expected to be a valid number, provided: {}",
-                            v
-                        ),
-                    }
-                    .build()
-                })
-            })
-            .transpose()?
-            .unwrap_or(0);
+        let Some(option_str) = option else {
+            return Ok((
+                compact_request::Options::StrictWindow(StrictWindow { window_seconds: 0 }),
+                DEFAULT_COMPACTION_PARALLELISM,
+            ));
+        };
 
-        Ok(compact_request::Options::StrictWindow(StrictWindow {
-            window_seconds,
-        }))
+        // For compatibility, accepts single number as window size.
+        if let Ok(window_seconds) = i64::from_str(option_str) {
+            return Ok((
+                compact_request::Options::StrictWindow(StrictWindow { window_seconds }),
+                DEFAULT_COMPACTION_PARALLELISM,
+            ));
+        };
+
+        // Parse keyword arguments in forms: `key1=value1,key2=value2`
+        let mut window_seconds = 0i64;
+        let mut parallelism = DEFAULT_COMPACTION_PARALLELISM;
+
+        let pairs: Vec<&str> = option_str.split(',').collect();
+        for pair in pairs {
+            let kv: Vec<&str> = pair.trim().split('=').collect();
+            if kv.len() != 2 {
+                return InvalidFuncArgsSnafu {
+                    err_msg: format!("Invalid key-value pair: {}", pair.trim()),
+                }
+                .fail();
+            }
+
+            let key = kv[0].trim();
+            let value = kv[1].trim();
+
+            match key {
+                "window" | "window_seconds" => {
+                    window_seconds = i64::from_str(value).map_err(|_| {
+                        InvalidFuncArgsSnafu {
+                            err_msg: format!("Invalid value for window: {}", value),
+                        }
+                        .build()
+                    })?;
+                }
+                "parallelism" => {
+                    parallelism = value.parse::<u32>().map_err(|_| {
+                        InvalidFuncArgsSnafu {
+                            err_msg: format!("Invalid value for parallelism: {}", value),
+                        }
+                        .build()
+                    })?;
+                }
+                _ => {
+                    return InvalidFuncArgsSnafu {
+                        err_msg: format!("Unknown parameter: {}", key),
+                    }
+                    .fail();
+                }
+            }
+        }
+
+        Ok((
+            compact_request::Options::StrictWindow(StrictWindow { window_seconds }),
+            parallelism,
+        ))
     } else {
-        Ok(compact_request::Options::Regular(Default::default()))
+        // TWCS strategy
+        let Some(option_str) = option else {
+            return Ok((
+                compact_request::Options::Regular(Default::default()),
+                DEFAULT_COMPACTION_PARALLELISM,
+            ));
+        };
+
+        let mut parallelism = DEFAULT_COMPACTION_PARALLELISM;
+        let pairs: Vec<&str> = option_str.split(',').collect();
+        for pair in pairs {
+            let kv: Vec<&str> = pair.trim().split('=').collect();
+            if kv.len() != 2 {
+                return InvalidFuncArgsSnafu {
+                    err_msg: format!("Invalid key-value pair: {}", pair.trim()),
+                }
+                .fail();
+            }
+
+            let key = kv[0].trim();
+            let value = kv[1].trim();
+
+            match key {
+                "parallelism" => {
+                    parallelism = value.parse::<u32>().map_err(|_| {
+                        InvalidFuncArgsSnafu {
+                            err_msg: format!("Invalid value for parallelism: {}", value),
+                        }
+                        .build()
+                    })?;
+                }
+                _ => {
+                    return InvalidFuncArgsSnafu {
+                        err_msg: format!("Unknown parameter: {}", key),
+                    }
+                    .fail();
+                }
+            }
+        }
+
+        Ok((
+            compact_request::Options::Regular(Default::default()),
+            parallelism,
+        ))
     }
 }
 
@@ -301,7 +403,7 @@ mod tests {
 
             assert_eq!(
                 expected,
-                &parse_compact_params(&params, &QueryContext::arc()).unwrap()
+                &parse_compact_request(&params, &QueryContext::arc()).unwrap()
             );
         }
     }
@@ -316,6 +418,7 @@ mod tests {
                     schema_name: DEFAULT_SCHEMA_NAME.to_string(),
                     table_name: "table".to_string(),
                     compact_options: Options::Regular(Default::default()),
+                    parallelism: 1,
                 },
             ),
             (
@@ -325,6 +428,7 @@ mod tests {
                     schema_name: DEFAULT_SCHEMA_NAME.to_string(),
                     table_name: "table".to_string(),
                     compact_options: Options::Regular(Default::default()),
+                    parallelism: 1,
                 },
             ),
             (
@@ -337,6 +441,7 @@ mod tests {
                     schema_name: DEFAULT_SCHEMA_NAME.to_string(),
                     table_name: "table".to_string(),
                     compact_options: Options::Regular(Default::default()),
+                    parallelism: 1,
                 },
             ),
             (
@@ -346,6 +451,7 @@ mod tests {
                     schema_name: DEFAULT_SCHEMA_NAME.to_string(),
                     table_name: "table".to_string(),
                     compact_options: Options::Regular(Default::default()),
+                    parallelism: 1,
                 },
             ),
             (
@@ -355,6 +461,7 @@ mod tests {
                     schema_name: DEFAULT_SCHEMA_NAME.to_string(),
                     table_name: "table".to_string(),
                     compact_options: Options::StrictWindow(StrictWindow { window_seconds: 0 }),
+                    parallelism: 1,
                 },
             ),
             (
@@ -366,15 +473,7 @@ mod tests {
                     compact_options: Options::StrictWindow(StrictWindow {
                         window_seconds: 3600,
                     }),
-                },
-            ),
-            (
-                &["table", "regular", "abcd"],
-                CompactTableRequest {
-                    catalog_name: DEFAULT_CATALOG_NAME.to_string(),
-                    schema_name: DEFAULT_SCHEMA_NAME.to_string(),
-                    table_name: "table".to_string(),
-                    compact_options: Options::Regular(Default::default()),
+                    parallelism: 1,
                 },
             ),
             (
@@ -386,12 +485,82 @@ mod tests {
                     compact_options: Options::StrictWindow(StrictWindow {
                         window_seconds: 120,
                     }),
+                    parallelism: 1,
+                },
+            ),
+            // Test with parallelism parameter
+            (
+                &["table", "regular", "parallelism=4"],
+                CompactTableRequest {
+                    catalog_name: DEFAULT_CATALOG_NAME.to_string(),
+                    schema_name: DEFAULT_SCHEMA_NAME.to_string(),
+                    table_name: "table".to_string(),
+                    compact_options: Options::Regular(Default::default()),
+                    parallelism: 4,
+                },
+            ),
+            (
+                &["table", "strict_window", "window=3600,parallelism=2"],
+                CompactTableRequest {
+                    catalog_name: DEFAULT_CATALOG_NAME.to_string(),
+                    schema_name: DEFAULT_SCHEMA_NAME.to_string(),
+                    table_name: "table".to_string(),
+                    compact_options: Options::StrictWindow(StrictWindow {
+                        window_seconds: 3600,
+                    }),
+                    parallelism: 2,
+                },
+            ),
+            (
+                &["table", "strict_window", "window=3600"],
+                CompactTableRequest {
+                    catalog_name: DEFAULT_CATALOG_NAME.to_string(),
+                    schema_name: DEFAULT_SCHEMA_NAME.to_string(),
+                    table_name: "table".to_string(),
+                    compact_options: Options::StrictWindow(StrictWindow {
+                        window_seconds: 3600,
+                    }),
+                    parallelism: 1,
+                },
+            ),
+            (
+                &["table", "strict_window", "window_seconds=7200"],
+                CompactTableRequest {
+                    catalog_name: DEFAULT_CATALOG_NAME.to_string(),
+                    schema_name: DEFAULT_SCHEMA_NAME.to_string(),
+                    table_name: "table".to_string(),
+                    compact_options: Options::StrictWindow(StrictWindow {
+                        window_seconds: 7200,
+                    }),
+                    parallelism: 1,
+                },
+            ),
+            (
+                &["table", "strict_window", "window=1800"],
+                CompactTableRequest {
+                    catalog_name: DEFAULT_CATALOG_NAME.to_string(),
+                    schema_name: DEFAULT_SCHEMA_NAME.to_string(),
+                    table_name: "table".to_string(),
+                    compact_options: Options::StrictWindow(StrictWindow {
+                        window_seconds: 1800,
+                    }),
+                    parallelism: 1,
+                },
+            ),
+            (
+                &["table", "regular", "parallelism=8"],
+                CompactTableRequest {
+                    catalog_name: DEFAULT_CATALOG_NAME.to_string(),
+                    schema_name: DEFAULT_SCHEMA_NAME.to_string(),
+                    table_name: "table".to_string(),
+                    compact_options: Options::Regular(Default::default()),
+                    parallelism: 8,
                 },
             ),
         ]);
 
         assert!(
-            parse_compact_params(
+            parse_compact_request(
                 &["table", "strict_window", "abc"]
                     .into_iter()
                     .map(ValueRef::String)
@@ -402,7 +571,7 @@ mod tests {
         );
 
         assert!(
-            parse_compact_params(
+            parse_compact_request(
                 &["a.b.table", "strict_window", "abc"]
                     .into_iter()
                     .map(ValueRef::String)
@@ -411,5 +580,88 @@ mod tests {
             )
             .is_err()
         );
+
+        // Test invalid parallelism
+        assert!(
+            parse_compact_request(
+                &["table", "regular", "options", "invalid"]
+                    .into_iter()
+                    .map(ValueRef::String)
+                    .collect::<Vec<_>>(),
+                &QueryContext::arc(),
+            )
+            .is_err()
+        );
+
+        // Test too many parameters
+        assert!(
+            parse_compact_request(
+                &["table", "regular", "options", "4", "extra"]
+                    .into_iter()
+                    .map(ValueRef::String)
+                    .collect::<Vec<_>>(),
+                &QueryContext::arc(),
+            )
+            .is_err()
+        );
+
+        // Test invalid keyword argument format
+        assert!(
+            parse_compact_request(
+                &["table", "strict_window", "window"]
+                    .into_iter()
+                    .map(ValueRef::String)
+                    .collect::<Vec<_>>(),
+                &QueryContext::arc(),
+            )
+            .is_err()
+        );
+
+        // Test invalid keyword
+        assert!(
+            parse_compact_request(
+                &["table", "strict_window", "invalid_key=123"]
+                    .into_iter()
+                    .map(ValueRef::String)
+                    .collect::<Vec<_>>(),
+                &QueryContext::arc(),
+            )
+            .is_err()
+        );
+
+        assert!(
+            parse_compact_request(
+                &["table", "regular", "abcd"]
+                    .into_iter()
+                    .map(ValueRef::String)
+                    .collect::<Vec<_>>(),
+                &QueryContext::arc(),
+            )
+            .is_err()
+        );
+
+        // Test invalid window value
+        assert!(
+            parse_compact_request(
+                &["table", "strict_window", "window=abc"]
+                    .into_iter()
+                    .map(ValueRef::String)
+                    .collect::<Vec<_>>(),
+                &QueryContext::arc(),
+            )
+            .is_err()
+        );
+
+        // Test invalid parallelism in options string
+        assert!(
+            parse_compact_request(
+                &["table", "strict_window", "parallelism=abc"]
+                    .into_iter()
+                    .map(ValueRef::String)
+                    .collect::<Vec<_>>(),
+                &QueryContext::arc(),
+            )
+            .is_err()
+        );
     }
 }

src/common/function/src/aggrs/aggr_wrapper.rs

@@ -22,12 +22,15 @@
 //! `foo_merge`'s input arg is the same as `foo_state`'s output, and its output is the same as `foo`'s input.
 //!
 
+use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 
 use arrow::array::StructArray;
 use arrow_schema::{FieldRef, Fields};
 use common_telemetry::debug;
 use datafusion::functions_aggregate::all_default_aggregate_functions;
+use datafusion::functions_aggregate::count::Count;
+use datafusion::functions_aggregate::min_max::{Max, Min};
 use datafusion::optimizer::AnalyzerRule;
 use datafusion::optimizer::analyzer::type_coercion::TypeCoercion;
 use datafusion::physical_planner::create_aggregate_expr_and_maybe_filter;
@@ -272,7 +275,7 @@ impl StateMergeHelper {
 }
 
 /// Wrapper to make an aggregate function out of a state function.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StateWrapper {
     inner: AggregateUDF,
     name: String,
@@ -412,6 +415,51 @@ impl AggregateUDFImpl for StateWrapper {
     fn coerce_types(&self, arg_types: &[DataType]) -> datafusion_common::Result<Vec<DataType>> {
         self.inner.coerce_types(arg_types)
     }
+
+    fn value_from_stats(
+        &self,
+        statistics_args: &datafusion_expr::StatisticsArgs,
+    ) -> Option<ScalarValue> {
+        let inner = self.inner().inner().as_any();
+        // only count/min/max need special handling here, for getting result from statistics
+        // the result of count/min/max is also the result of count_state so can return directly
+        let can_use_stat = inner.is::<Count>() || inner.is::<Max>() || inner.is::<Min>();
+        if !can_use_stat {
+            return None;
+        }
+
+        // fix return type by extract the first field's data type from the struct type
+        let state_type = if let DataType::Struct(fields) = &statistics_args.return_type {
+            if fields.is_empty() {
+                return None;
+            }
+            fields[0].data_type().clone()
+        } else {
+            return None;
+        };
+
+        let fixed_args = datafusion_expr::StatisticsArgs {
+            statistics: statistics_args.statistics,
+            return_type: &state_type,
+            is_distinct: statistics_args.is_distinct,
+            exprs: statistics_args.exprs,
+        };
+
+        let ret = self.inner().value_from_stats(&fixed_args)?;
+
+        // wrap the result into struct scalar value
+        let fields = if let DataType::Struct(fields) = &statistics_args.return_type {
+            fields
+        } else {
+            return None;
+        };
+
+        let array = ret.to_array().ok()?;
+
+        let struct_array = StructArray::new(fields.clone(), vec![array], None);
+        let ret = ScalarValue::Struct(Arc::new(struct_array));
+        Some(ret)
+    }
 }
 
 /// The wrapper's input is the same as the original aggregate function's input,
@@ -616,6 +664,20 @@ impl AggregateUDFImpl for MergeWrapper {
     }
 }
 
+impl PartialEq for MergeWrapper {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner == other.inner
+    }
+}
+
+impl Eq for MergeWrapper {}
+
+impl Hash for MergeWrapper {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.inner.hash(state);
+    }
+}
+
 /// The merge accumulator, which modify `update_batch`'s behavior to accept one struct array which
 /// include the state fields of original aggregate function, and merge said states into original accumulator
 /// the output is the same as original aggregate function

src/common/function/src/aggrs/aggr_wrapper/tests.rs

@@ -39,8 +39,7 @@ use datafusion::prelude::SessionContext;
 use datafusion_common::arrow::array::AsArray;
 use datafusion_common::arrow::datatypes::{Float64Type, UInt64Type};
 use datafusion_common::{Column, TableReference};
-use datafusion_expr::expr::AggregateFunction;
-use datafusion_expr::sqlparser::ast::NullTreatment;
+use datafusion_expr::expr::{AggregateFunction, NullTreatment};
 use datafusion_expr::{
     Aggregate, ColumnarValue, Expr, LogicalPlan, ScalarFunctionArgs, SortExpr, TableScan, lit,
 };

src/common/function/src/aggrs/count_hash.rs

@@ -68,7 +68,7 @@ impl CountHash {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct CountHash {
     signature: Signature,
 }

src/common/function/src/aggrs/vector/product.rs

@@ -15,7 +15,7 @@
 use std::borrow::Cow;
 use std::sync::Arc;
 
-use arrow::array::{Array, ArrayRef, AsArray, BinaryArray, StringArray};
+use arrow::array::{Array, ArrayRef, AsArray, BinaryArray, LargeStringArray, StringArray};
 use arrow_schema::{DataType, Field};
 use datafusion::logical_expr::{Signature, TypeSignature, Volatility};
 use datafusion_common::{Result, ScalarValue};
@@ -63,7 +63,7 @@ impl VectorProduct {
         }
 
         let t = args.schema.field(0).data_type();
-        if !matches!(t, DataType::Utf8 | DataType::Binary) {
+        if !matches!(t, DataType::Utf8 | DataType::LargeUtf8 | DataType::Binary) {
             return Err(datafusion_common::DataFusionError::Internal(format!(
                 "unexpected input datatype {t} when creating `VEC_PRODUCT`"
             )));
@@ -91,6 +91,13 @@ impl VectorProduct {
                     .map(|x| x.map(Cow::Owned))
                     .collect::<Result<Vec<_>>>()?
             }
+            DataType::LargeUtf8 => {
+                let arr: &LargeStringArray = values[0].as_string();
+                arr.iter()
+                    .filter_map(|x| x.map(|s| parse_veclit_from_strlit(s).map_err(Into::into)))
+                    .map(|x: Result<Vec<f32>>| x.map(Cow::Owned))
+                    .collect::<Result<Vec<_>>>()?
+            }
             DataType::Binary => {
                 let arr: &BinaryArray = values[0].as_binary();
                 arr.iter()

src/common/function/src/aggrs/vector/sum.rs

@@ -14,7 +14,7 @@
 
 use std::sync::Arc;
 
-use arrow::array::{Array, ArrayRef, AsArray, BinaryArray, StringArray};
+use arrow::array::{Array, ArrayRef, AsArray, BinaryArray, LargeStringArray, StringArray};
 use arrow_schema::{DataType, Field};
 use datafusion_common::{Result, ScalarValue};
 use datafusion_expr::{
@@ -63,7 +63,7 @@ impl VectorSum {
         }
 
         let t = args.schema.field(0).data_type();
-        if !matches!(t, DataType::Utf8 | DataType::Binary) {
+        if !matches!(t, DataType::Utf8 | DataType::LargeUtf8 | DataType::Binary) {
             return Err(datafusion_common::DataFusionError::Internal(format!(
                 "unexpected input datatype {t} when creating `VEC_SUM`"
             )));
@@ -98,6 +98,21 @@ impl VectorSum {
                     *self.inner(vec_column.len()) += vec_column;
                 }
             }
+            DataType::LargeUtf8 => {
+                let arr: &LargeStringArray = values[0].as_string();
+                for s in arr.iter() {
+                    let Some(s) = s else {
+                        if is_update {
+                            self.has_null = true;
+                            self.sum = None;
+                        }
+                        return Ok(());
+                    };
+                    let values = parse_veclit_from_strlit(s)?;
+                    let vec_column = DVectorView::from_slice(&values, values.len());
+                    *self.inner(vec_column.len()) += vec_column;
+                }
+            }
             DataType::Binary => {
                 let arr: &BinaryArray = values[0].as_binary();
                 for b in arr.iter() {

src/common/function/src/function_registry.rs

@@ -34,6 +34,7 @@ use crate::scalars::json::JsonFunction;
 use crate::scalars::matches::MatchesFunction;
 use crate::scalars::matches_term::MatchesTermFunction;
 use crate::scalars::math::MathFunction;
+use crate::scalars::string::register_string_functions;
 use crate::scalars::timestamp::TimestampFunction;
 use crate::scalars::uddsketch_calc::UddSketchCalcFunction;
 use crate::scalars::vector::VectorFunction as VectorScalarFunction;
@@ -71,7 +72,7 @@ impl FunctionRegistry {
         for alias in func.aliases() {
             let func: ScalarFunctionFactory = func.clone().into();
             let alias = ScalarFunctionFactory {
-                name: alias.to_string(),
+                name: alias.clone(),
                 ..func
             };
             self.register(alias);
@@ -154,6 +155,9 @@ pub static FUNCTION_REGISTRY: LazyLock<Arc<FunctionRegistry>> = LazyLock::new(||
     // Json related functions
     JsonFunction::register(&function_registry);
 
+    // String related functions
+    register_string_functions(&function_registry);
+
     // Vector related functions
     VectorScalarFunction::register(&function_registry);
     VectorAggrFunction::register(&function_registry);

src/common/function/src/helper.rs

@@ -38,7 +38,7 @@ pub(crate) fn one_of_sigs2(args1: Vec<DataType>, args2: Vec<DataType>) -> Signat
 
 /// Cast a [`ValueRef`] to u64, returns `None` if fails
 pub fn cast_u64(value: &ValueRef) -> Result<Option<u64>> {
-    cast((*value).into(), &ConcreteDataType::uint64_datatype())
+    cast(value.clone().into(), &ConcreteDataType::uint64_datatype())
         .context(InvalidInputTypeSnafu {
             err_msg: format!(
                 "Failed to cast input into uint64, actual type: {:#?}",
@@ -50,7 +50,7 @@ pub fn cast_u64(value: &ValueRef) -> Result<Option<u64>> {
 
 /// Cast a [`ValueRef`] to u32, returns `None` if fails
 pub fn cast_u32(value: &ValueRef) -> Result<Option<u32>> {
-    cast((*value).into(), &ConcreteDataType::uint32_datatype())
+    cast(value.clone().into(), &ConcreteDataType::uint32_datatype())
         .context(InvalidInputTypeSnafu {
             err_msg: format!(
                 "Failed to cast input into uint32, actual type: {:#?}",

src/common/function/src/lib.rs

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(let_chains)]
 #![feature(try_blocks)]
 #![feature(assert_matches)]
 

src/common/function/src/scalars.rs

@@ -20,6 +20,7 @@ pub mod json;
 pub mod matches;
 pub mod matches_term;
 pub mod math;
+pub(crate) mod string;
 pub mod vector;
 
 pub(crate) mod hll_count;

src/common/function/src/scalars/date/date_format.rs

@@ -20,7 +20,9 @@ use common_query::error;
 use common_time::{Date, Timestamp};
 use datafusion_common::DataFusionError;
 use datafusion_common::arrow::array::{Array, AsArray, StringViewBuilder};
-use datafusion_common::arrow::datatypes::{ArrowTimestampType, DataType, Date32Type, TimeUnit};
+use datafusion_common::arrow::datatypes::{
+    ArrowTimestampType, DataType, Date32Type, Date64Type, TimeUnit,
+};
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, Signature};
 use snafu::ResultExt;
 
@@ -40,6 +42,7 @@ impl Default for DateFormatFunction {
             signature: helper::one_of_sigs2(
                 vec![
                     DataType::Date32,
+                    DataType::Date64,
                     DataType::Timestamp(TimeUnit::Second, None),
                     DataType::Timestamp(TimeUnit::Millisecond, None),
                     DataType::Timestamp(TimeUnit::Microsecond, None),
@@ -115,6 +118,29 @@ impl Function for DateFormatFunction {
                     builder.append_option(result.as_deref());
                 }
             }
+            DataType::Date64 => {
+                let left = left.as_primitive::<Date64Type>();
+                for i in 0..size {
+                    let date = left.is_valid(i).then(|| {
+                        let ms = left.value(i);
+                        Timestamp::new_millisecond(ms)
+                    });
+                    let format = formats.is_valid(i).then(|| formats.value(i));
+
+                    let result = match (date, format) {
+                        (Some(ts), Some(fmt)) => {
+                            Some(ts.as_formatted_string(fmt, Some(timezone)).map_err(|e| {
+                                DataFusionError::Execution(format!(
+                                    "cannot format {ts:?} as '{fmt}': {e}"
+                                ))
+                            })?)
+                        }
+                        _ => None,
+                    };
+
+                    builder.append_option(result.as_deref());
+                }
+            }
             x => {
                 return Err(DataFusionError::Execution(format!(
                     "unsupported input data type {x}"
@@ -137,7 +163,9 @@ mod tests {
     use std::sync::Arc;
 
     use arrow_schema::Field;
-    use datafusion_common::arrow::array::{Date32Array, StringArray, TimestampSecondArray};
+    use datafusion_common::arrow::array::{
+        Date32Array, Date64Array, StringArray, TimestampSecondArray,
+    };
     use datafusion_common::config::ConfigOptions;
     use datafusion_expr::{TypeSignature, Volatility};
 
@@ -166,7 +194,7 @@ mod tests {
                          Signature {
                              type_signature: TypeSignature::OneOf(sigs),
                              volatility: Volatility::Immutable
-                         } if  sigs.len() == 5));
+                         } if  sigs.len() == 6));
     }
 
     #[test]
@@ -213,6 +241,50 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_date64_date_format() {
+        let f = DateFormatFunction::default();
+
+        let dates = vec![Some(123000), None, Some(42000), None];
+        let formats = vec![
+            "%Y-%m-%d %T.%3f",
+            "%Y-%m-%d %T.%3f",
+            "%Y-%m-%d %T.%3f",
+            "%Y-%m-%d %T.%3f",
+        ];
+        let results = [
+            Some("1970-01-01 00:02:03.000"),
+            None,
+            Some("1970-01-01 00:00:42.000"),
+            None,
+        ];
+
+        let mut config_options = ConfigOptions::default();
+        config_options.extensions.insert(FunctionContext::default());
+        let config_options = Arc::new(config_options);
+
+        let args = ScalarFunctionArgs {
+            args: vec![
+                ColumnarValue::Array(Arc::new(Date64Array::from(dates))),
+                ColumnarValue::Array(Arc::new(StringArray::from_iter_values(formats))),
+            ],
+            arg_fields: vec![],
+            number_rows: 4,
+            return_field: Arc::new(Field::new("x", DataType::Utf8View, false)),
+            config_options,
+        };
+        let result = f
+            .invoke_with_args(args)
+            .and_then(|x| x.to_array(4))
+            .unwrap();
+        let vector = result.as_string_view();
+
+        assert_eq!(4, vector.len());
+        for (actual, expect) in vector.iter().zip(results) {
+            assert_eq!(actual, expect);
+        }
+    }
+
     #[test]
     fn test_date_date_format() {
         let f = DateFormatFunction::default();

src/common/function/src/scalars/expression/binary.rs

@@ -41,7 +41,7 @@ where
             let right: &<R as Scalar>::VectorType = unsafe { Helper::static_cast(right.inner()) };
             let b = right.get_data(0);
 
-            let it = left.iter_data().map(|a| f(a, b, ctx));
+            let it = left.iter_data().map(|a| f(a, b.clone(), ctx));
             <O as Scalar>::VectorType::from_owned_iterator(it)
         }
 
@@ -62,7 +62,7 @@ where
             let a = left.get_data(0);
 
             let right: &<R as Scalar>::VectorType = unsafe { Helper::static_cast(r) };
-            let it = right.iter_data().map(|b| f(a, b, ctx));
+            let it = right.iter_data().map(|b| f(a.clone(), b, ctx));
             <O as Scalar>::VectorType::from_owned_iterator(it)
         }
 

src/common/function/src/scalars/geo/geohash.rs

@@ -76,7 +76,7 @@ impl Function for GeohashFunction {
     }
 
     fn return_type(&self, _: &[DataType]) -> datafusion_common::Result<DataType> {
-        Ok(DataType::Utf8)
+        Ok(DataType::Utf8View)
     }
 
     fn signature(&self) -> &Signature {
@@ -176,7 +176,7 @@ impl Function for GeohashNeighboursFunction {
         Ok(DataType::List(Arc::new(Field::new(
             "item",
             DataType::Utf8View,
-            false,
+            true,
         ))))
     }
 

src/common/function/src/scalars/geo/h3.rs

@@ -355,9 +355,9 @@ impl Function for H3CellCenterLatLng {
 
     fn return_type(&self, _: &[DataType]) -> datafusion_common::Result<DataType> {
         Ok(DataType::List(Arc::new(Field::new(
-            "x",
+            "item",
             DataType::Float64,
-            false,
+            true,
         ))))
     }
 

src/common/function/src/scalars/ip/range.rs

@@ -309,7 +309,7 @@ fn is_ipv6_in_range(ip: &Ipv6Addr, cidr_base: &Ipv6Addr, prefix_len: u8) -> Opti
     }
 
     // If there's a partial byte to check
-    if prefix_len % 8 != 0 && full_bytes < 16 {
+    if !prefix_len.is_multiple_of(8) && full_bytes < 16 {
         let bits_to_check = prefix_len % 8;
         let mask = 0xFF_u8 << (8 - bits_to_check);
 

src/common/function/src/scalars/string.rs

@@ -0,0 +1,26 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! String scalar functions
+
+mod regexp_extract;
+
+pub(crate) use regexp_extract::RegexpExtractFunction;
+
+use crate::function_registry::FunctionRegistry;
+
+/// Register all string functions
+pub fn register_string_functions(registry: &FunctionRegistry) {
+    RegexpExtractFunction::register(registry);
+}

src/common/function/src/scalars/string/regexp_extract.rs

@@ -0,0 +1,339 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Implementation of REGEXP_EXTRACT function
+use std::fmt;
+use std::sync::Arc;
+
+use datafusion_common::DataFusionError;
+use datafusion_common::arrow::array::{Array, AsArray, LargeStringBuilder};
+use datafusion_common::arrow::compute::cast;
+use datafusion_common::arrow::datatypes::DataType;
+use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, Signature, TypeSignature, Volatility};
+use regex::{Regex, RegexBuilder};
+
+use crate::function::Function;
+use crate::function_registry::FunctionRegistry;
+
+const NAME: &str = "regexp_extract";
+
+// Safety limits
+const MAX_REGEX_SIZE: usize = 1024 * 1024; // compiled regex heap cap
+const MAX_DFA_SIZE: usize = 2 * 1024 * 1024; // lazy DFA cap
+const MAX_TOTAL_RESULT_SIZE: usize = 64 * 1024 * 1024; // total batch cap
+const MAX_SINGLE_MATCH: usize = 1024 * 1024; // per-row cap
+const MAX_PATTERN_LEN: usize = 10_000; // pattern text length cap
+
+/// REGEXP_EXTRACT function implementation
+/// Extracts the first substring matching the given regular expression pattern.
+/// If no match is found, returns NULL.
+///
+#[derive(Debug)]
+pub struct RegexpExtractFunction {
+    signature: Signature,
+}
+
+impl RegexpExtractFunction {
+    pub fn register(registry: &FunctionRegistry) {
+        registry.register_scalar(RegexpExtractFunction::default());
+    }
+}
+
+impl Default for RegexpExtractFunction {
+    fn default() -> Self {
+        Self {
+            signature: Signature::one_of(
+                vec![
+                    TypeSignature::Exact(vec![DataType::Utf8View, DataType::Utf8]),
+                    TypeSignature::Exact(vec![DataType::Utf8View, DataType::Utf8View]),
+                    TypeSignature::Exact(vec![DataType::Utf8, DataType::Utf8View]),
+                    TypeSignature::Exact(vec![DataType::LargeUtf8, DataType::Utf8View]),
+                    TypeSignature::Exact(vec![DataType::Utf8View, DataType::LargeUtf8]),
+                    TypeSignature::Exact(vec![DataType::Utf8, DataType::Utf8]),
+                    TypeSignature::Exact(vec![DataType::LargeUtf8, DataType::Utf8]),
+                    TypeSignature::Exact(vec![DataType::Utf8, DataType::LargeUtf8]),
+                    TypeSignature::Exact(vec![DataType::LargeUtf8, DataType::LargeUtf8]),
+                ],
+                Volatility::Immutable,
+            ),
+        }
+    }
+}
+
+impl fmt::Display for RegexpExtractFunction {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", NAME.to_ascii_uppercase())
+    }
+}
+
+impl Function for RegexpExtractFunction {
+    fn name(&self) -> &str {
+        NAME
+    }
+
+    // Always return LargeUtf8 for simplicity and safety
+    fn return_type(&self, _: &[DataType]) -> datafusion_common::Result<DataType> {
+        Ok(DataType::LargeUtf8)
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn invoke_with_args(
+        &self,
+        args: ScalarFunctionArgs,
+    ) -> datafusion_common::Result<ColumnarValue> {
+        if args.args.len() != 2 {
+            return Err(DataFusionError::Execution(
+                "REGEXP_EXTRACT requires exactly two arguments (text, pattern)".to_string(),
+            ));
+        }
+
+        // Keep original ColumnarValue variants for scalar-pattern fast path
+        let pattern_is_scalar = matches!(args.args[1], ColumnarValue::Scalar(_));
+
+        let arrays = ColumnarValue::values_to_arrays(&args.args)?;
+        let text_array = &arrays[0];
+        let pattern_array = &arrays[1];
+
+        // Cast both to LargeUtf8 for uniform access (supports Utf8/Utf8View/Dictionary<String>)
+        let text_large = cast(text_array.as_ref(), &DataType::LargeUtf8).map_err(|e| {
+            DataFusionError::Execution(format!("REGEXP_EXTRACT: text cast failed: {e}"))
+        })?;
+        let pattern_large = cast(pattern_array.as_ref(), &DataType::LargeUtf8).map_err(|e| {
+            DataFusionError::Execution(format!("REGEXP_EXTRACT: pattern cast failed: {e}"))
+        })?;
+
+        let text = text_large.as_string::<i64>();
+        let pattern = pattern_large.as_string::<i64>();
+        let len = text.len();
+
+        // Pre-size result builder with conservative estimate
+        let mut estimated_total = 0usize;
+        for i in 0..len {
+            if !text.is_null(i) {
+                estimated_total = estimated_total.saturating_add(text.value_length(i) as usize);
+                if estimated_total > MAX_TOTAL_RESULT_SIZE {
+                    return Err(DataFusionError::ResourcesExhausted(format!(
+                        "REGEXP_EXTRACT total output exceeds {} bytes",
+                        MAX_TOTAL_RESULT_SIZE
+                    )));
+                }
+            }
+        }
+        let mut builder = LargeStringBuilder::with_capacity(len, estimated_total);
+
+        // Fast path: if pattern is scalar, compile once
+        let compiled_scalar: Option<Regex> = if pattern_is_scalar && len > 0 && !pattern.is_null(0)
+        {
+            Some(compile_regex_checked(pattern.value(0))?)
+        } else {
+            None
+        };
+
+        for i in 0..len {
+            if text.is_null(i) || pattern.is_null(i) {
+                builder.append_null();
+                continue;
+            }
+
+            let s = text.value(i);
+            let pat = pattern.value(i);
+
+            // Compile or reuse regex
+            let re = if let Some(ref compiled) = compiled_scalar {
+                compiled
+            } else {
+                // TODO: For performance-critical applications with repeating patterns,
+                // consider adding a small LRU cache here
+                &compile_regex_checked(pat)?
+            };
+
+            // First match only
+            if let Some(m) = re.find(s) {
+                let m_str = m.as_str();
+                if m_str.len() > MAX_SINGLE_MATCH {
+                    return Err(DataFusionError::Execution(
+                        "REGEXP_EXTRACT match exceeds per-row limit (1MB)".to_string(),
+                    ));
+                }
+                builder.append_value(m_str);
+            } else {
+                builder.append_null();
+            }
+        }
+
+        Ok(ColumnarValue::Array(Arc::new(builder.finish())))
+    }
+}
+
+// Compile a regex with safety checks
+fn compile_regex_checked(pattern: &str) -> datafusion_common::Result<Regex> {
+    if pattern.len() > MAX_PATTERN_LEN {
+        return Err(DataFusionError::Execution(format!(
+            "REGEXP_EXTRACT pattern too long (> {} chars)",
+            MAX_PATTERN_LEN
+        )));
+    }
+    RegexBuilder::new(pattern)
+        .size_limit(MAX_REGEX_SIZE)
+        .dfa_size_limit(MAX_DFA_SIZE)
+        .build()
+        .map_err(|e| {
+            DataFusionError::Execution(format!("REGEXP_EXTRACT invalid pattern '{}': {e}", pattern))
+        })
+}
+
+#[cfg(test)]
+mod tests {
+    use datafusion_common::arrow::array::StringArray;
+    use datafusion_common::arrow::datatypes::Field;
+    use datafusion_expr::ScalarFunctionArgs;
+
+    use super::*;
+
+    #[test]
+    fn test_regexp_extract_function_basic() {
+        let text_array = Arc::new(StringArray::from(vec!["version 1.2.3", "no match here"]));
+        let pattern_array = Arc::new(StringArray::from(vec!["\\d+\\.\\d+\\.\\d+", "\\d+"]));
+
+        let args = ScalarFunctionArgs {
+            args: vec![
+                ColumnarValue::Array(text_array),
+                ColumnarValue::Array(pattern_array),
+            ],
+            arg_fields: vec![
+                Arc::new(Field::new("arg_0", DataType::Utf8, false)),
+                Arc::new(Field::new("arg_1", DataType::Utf8, false)),
+            ],
+            return_field: Arc::new(Field::new("result", DataType::LargeUtf8, true)),
+            number_rows: 2,
+            config_options: Arc::new(datafusion_common::config::ConfigOptions::default()),
+        };
+
+        let function = RegexpExtractFunction::default();
+        let result = function.invoke_with_args(args).unwrap();
+
+        if let ColumnarValue::Array(array) = result {
+            let string_array = array.as_string::<i64>();
+            assert_eq!(string_array.value(0), "1.2.3");
+            assert!(string_array.is_null(1)); // no match should return NULL
+        } else {
+            panic!("Expected array result");
+        }
+    }
+
+    #[test]
+    fn test_regexp_extract_phone_number() {
+        let text_array = Arc::new(StringArray::from(vec!["Phone: 123-456-7890", "No phone"]));
+        let pattern_array = Arc::new(StringArray::from(vec![
+            "\\d{3}-\\d{3}-\\d{4}",
+            "\\d{3}-\\d{3}-\\d{4}",
+        ]));
+
+        let args = ScalarFunctionArgs {
+            args: vec![
+                ColumnarValue::Array(text_array),
+                ColumnarValue::Array(pattern_array),
+            ],
+            arg_fields: vec![
+                Arc::new(Field::new("arg_0", DataType::Utf8, false)),
+                Arc::new(Field::new("arg_1", DataType::Utf8, false)),
+            ],
+            return_field: Arc::new(Field::new("result", DataType::LargeUtf8, true)),
+            number_rows: 2,
+            config_options: Arc::new(datafusion_common::config::ConfigOptions::default()),
+        };
+
+        let function = RegexpExtractFunction::default();
+        let result = function.invoke_with_args(args).unwrap();
+
+        if let ColumnarValue::Array(array) = result {
+            let string_array = array.as_string::<i64>();
+            assert_eq!(string_array.value(0), "123-456-7890");
+            assert!(string_array.is_null(1)); // no match should return NULL
+        } else {
+            panic!("Expected array result");
+        }
+    }
+
+    #[test]
+    fn test_regexp_extract_email() {
+        let text_array = Arc::new(StringArray::from(vec![
+            "Email: user@domain.com",
+            "Invalid email",
+        ]));
+        let pattern_array = Arc::new(StringArray::from(vec![
+            "[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-Z]+",
+            "[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-Z]+",
+        ]));
+
+        let args = ScalarFunctionArgs {
+            args: vec![
+                ColumnarValue::Array(text_array),
+                ColumnarValue::Array(pattern_array),
+            ],
+            arg_fields: vec![
+                Arc::new(Field::new("arg_0", DataType::Utf8, false)),
+                Arc::new(Field::new("arg_1", DataType::Utf8, false)),
+            ],
+            return_field: Arc::new(Field::new("result", DataType::LargeUtf8, true)),
+            number_rows: 2,
+            config_options: Arc::new(datafusion_common::config::ConfigOptions::default()),
+        };
+
+        let function = RegexpExtractFunction::default();
+        let result = function.invoke_with_args(args).unwrap();
+
+        if let ColumnarValue::Array(array) = result {
+            let string_array = array.as_string::<i64>();
+            assert_eq!(string_array.value(0), "user@domain.com");
+            assert!(string_array.is_null(1)); // no match should return NULL
+        } else {
+            panic!("Expected array result");
+        }
+    }
+
+    #[test]
+    fn test_regexp_extract_with_nulls() {
+        let text_array = Arc::new(StringArray::from(vec![Some("test 123"), None]));
+        let pattern_array = Arc::new(StringArray::from(vec![Some("\\d+"), Some("\\d+")]));
+
+        let args = ScalarFunctionArgs {
+            args: vec![
+                ColumnarValue::Array(text_array),
+                ColumnarValue::Array(pattern_array),
+            ],
+            arg_fields: vec![
+                Arc::new(Field::new("arg_0", DataType::Utf8, true)),
+                Arc::new(Field::new("arg_1", DataType::Utf8, false)),
+            ],
+            return_field: Arc::new(Field::new("result", DataType::LargeUtf8, true)),
+            number_rows: 2,
+            config_options: Arc::new(datafusion_common::config::ConfigOptions::default()),
+        };
+
+        let function = RegexpExtractFunction::default();
+        let result = function.invoke_with_args(args).unwrap();
+
+        if let ColumnarValue::Array(array) = result {
+            let string_array = array.as_string::<i64>();
+            assert_eq!(string_array.value(0), "123");
+            assert!(string_array.is_null(1)); // NULL input should return NULL
+        } else {
+            panic!("Expected array result");
+        }
+    }
+}

src/common/function/src/scalars/udf.rs

@@ -14,6 +14,7 @@
 
 use std::any::Any;
 use std::fmt::{Debug, Formatter};
+use std::hash::{Hash, Hasher};
 
 use datafusion::arrow::datatypes::DataType;
 use datafusion::logical_expr::{ScalarFunctionArgs, ScalarUDFImpl};
@@ -33,6 +34,20 @@ impl Debug for ScalarUdf {
     }
 }
 
+impl PartialEq for ScalarUdf {
+    fn eq(&self, other: &Self) -> bool {
+        self.function.signature() == other.function.signature()
+    }
+}
+
+impl Eq for ScalarUdf {}
+
+impl Hash for ScalarUdf {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.function.signature().hash(state)
+    }
+}
+
 impl ScalarUDFImpl for ScalarUdf {
     fn as_any(&self) -> &dyn Any {
         self

src/common/function/src/scalars/vector/impl_conv.rs

@@ -36,7 +36,7 @@ pub fn as_veclit(arg: &ScalarValue) -> Result<Option<Cow<'_, [f32]>>> {
 
 /// Convert a u8 slice to a vector literal.
 pub fn binlit_as_veclit(bytes: &[u8]) -> Result<Cow<'_, [f32]>> {
-    if bytes.len() % std::mem::size_of::<f32>() != 0 {
+    if !bytes.len().is_multiple_of(size_of::<f32>()) {
         return InvalidFuncArgsSnafu {
             err_msg: format!("Invalid binary length of vector: {}", bytes.len()),
         }

src/common/function/src/system/pg_catalog.rs

@@ -32,10 +32,36 @@ use crate::system::define_nullary_udf;
 const CURRENT_SCHEMA_FUNCTION_NAME: &str = "current_schema";
 const CURRENT_SCHEMAS_FUNCTION_NAME: &str = "current_schemas";
 const SESSION_USER_FUNCTION_NAME: &str = "session_user";
+const CURRENT_DATABASE_FUNCTION_NAME: &str = "current_database";
 
 define_nullary_udf!(CurrentSchemaFunction);
 define_nullary_udf!(CurrentSchemasFunction);
 define_nullary_udf!(SessionUserFunction);
+define_nullary_udf!(CurrentDatabaseFunction);
+
+impl Function for CurrentDatabaseFunction {
+    fn name(&self) -> &str {
+        CURRENT_DATABASE_FUNCTION_NAME
+    }
+
+    fn return_type(&self, _: &[DataType]) -> datafusion_common::Result<DataType> {
+        Ok(DataType::Utf8View)
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn invoke_with_args(
+        &self,
+        args: ScalarFunctionArgs,
+    ) -> datafusion_common::Result<ColumnarValue> {
+        let func_ctx = find_function_context(&args)?;
+        let db = func_ctx.query_ctx.current_catalog().to_string();
+
+        Ok(ColumnarValue::Scalar(ScalarValue::Utf8View(Some(db))))
+    }
+}
 
 // Though "current_schema" can be aliased to "database", to not cause any breaking changes,
 // we are not doing it: not until https://github.com/apache/datafusion/issues/17469 is resolved.
@@ -141,6 +167,7 @@ impl PGCatalogFunction {
         registry.register_scalar(CurrentSchemaFunction::default());
         registry.register_scalar(CurrentSchemasFunction::default());
         registry.register_scalar(SessionUserFunction::default());
+        registry.register_scalar(CurrentDatabaseFunction::default());
         registry.register(pg_catalog::format_type::create_format_type_udf());
         registry.register(pg_catalog::create_pg_get_partkeydef_udf());
         registry.register(pg_catalog::has_privilege_udf::create_has_privilege_udf(

src/common/grpc-expr/src/delete.rs

@@ -1,123 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::collections::HashMap;
-
-use api::helper::ColumnDataTypeWrapper;
-use api::v1::{Column, DeleteRequest as GrpcDeleteRequest};
-use datatypes::prelude::ConcreteDataType;
-use snafu::{ResultExt, ensure};
-use table::requests::DeleteRequest;
-
-use crate::error::{ColumnDataTypeSnafu, IllegalDeleteRequestSnafu, Result};
-use crate::insert::add_values_to_builder;
-
-pub fn to_table_delete_request(
-    catalog_name: &str,
-    schema_name: &str,
-    request: GrpcDeleteRequest,
-) -> Result<DeleteRequest> {
-    let row_count = request.row_count as usize;
-
-    let mut key_column_values = HashMap::with_capacity(request.key_columns.len());
-    for Column {
-        column_name,
-        values,
-        null_mask,
-        datatype,
-        datatype_extension,
-        ..
-    } in request.key_columns
-    {
-        let Some(values) = values else { continue };
-
-        let datatype: ConcreteDataType =
-            ColumnDataTypeWrapper::try_new(datatype, datatype_extension)
-                .context(ColumnDataTypeSnafu)?
-                .into();
-        let vector = add_values_to_builder(datatype, values, row_count, null_mask)?;
-
-        ensure!(
-            key_column_values
-                .insert(column_name.clone(), vector)
-                .is_none(),
-            IllegalDeleteRequestSnafu {
-                reason: format!("Duplicated column '{column_name}' in delete request.")
-            }
-        );
-    }
-
-    Ok(DeleteRequest {
-        catalog_name: catalog_name.to_string(),
-        schema_name: schema_name.to_string(),
-        table_name: request.table_name,
-        key_column_values,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use api::v1::ColumnDataType;
-    use api::v1::column::Values;
-    use datatypes::prelude::{ScalarVector, VectorRef};
-    use datatypes::vectors::{Int32Vector, StringVector};
-
-    use super::*;
-
-    #[test]
-    fn test_to_table_delete_request() {
-        let grpc_request = GrpcDeleteRequest {
-            table_name: "foo".to_string(),
-            key_columns: vec![
-                Column {
-                    column_name: "id".to_string(),
-                    values: Some(Values {
-                        i32_values: vec![1, 2, 3],
-                        ..Default::default()
-                    }),
-                    datatype: ColumnDataType::Int32 as i32,
-                    ..Default::default()
-                },
-                Column {
-                    column_name: "name".to_string(),
-                    values: Some(Values {
-                        string_values: vec!["a".to_string(), "b".to_string(), "c".to_string()],
-                        ..Default::default()
-                    }),
-                    datatype: ColumnDataType::String as i32,
-                    ..Default::default()
-                },
-            ],
-            row_count: 3,
-        };
-
-        let mut request =
-            to_table_delete_request("foo_catalog", "foo_schema", grpc_request).unwrap();
-
-        assert_eq!(request.catalog_name, "foo_catalog");
-        assert_eq!(request.schema_name, "foo_schema");
-        assert_eq!(request.table_name, "foo");
-        assert_eq!(
-            Arc::new(Int32Vector::from_slice(vec![1, 2, 3])) as VectorRef,
-            request.key_column_values.remove("id").unwrap()
-        );
-        assert_eq!(
-            Arc::new(StringVector::from_slice(&["a", "b", "c"])) as VectorRef,
-            request.key_column_values.remove("name").unwrap()
-        );
-        assert!(request.key_column_values.is_empty());
-    }
-}

src/common/grpc-expr/src/error.rs

@@ -25,13 +25,6 @@ use store_api::metadata::MetadataError;
 #[snafu(visibility(pub))]
 #[stack_trace_debug]
 pub enum Error {
-    #[snafu(display("Illegal delete request, reason: {reason}"))]
-    IllegalDeleteRequest {
-        reason: String,
-        #[snafu(implicit)]
-        location: Location,
-    },
-
     #[snafu(display("Column datatype error"))]
     ColumnDataType {
         #[snafu(implicit)]
@@ -65,13 +58,6 @@ pub enum Error {
         location: Location,
     },
 
-    #[snafu(display("Failed to create vector"))]
-    CreateVector {
-        #[snafu(implicit)]
-        location: Location,
-        source: datatypes::error::Error,
-    },
-
     #[snafu(display("Missing required field in protobuf, field: {}", field))]
     MissingField {
         field: String,
@@ -87,13 +73,6 @@ pub enum Error {
         source: api::error::Error,
     },
 
-    #[snafu(display("Unexpected values length, reason: {}", reason))]
-    UnexpectedValuesLength {
-        reason: String,
-        #[snafu(implicit)]
-        location: Location,
-    },
-
     #[snafu(display("Unknown location type: {}", location_type))]
     UnknownLocationType {
         location_type: i32,
@@ -189,18 +168,13 @@ pub type Result<T> = std::result::Result<T, Error>;
 impl ErrorExt for Error {
     fn status_code(&self) -> StatusCode {
         match self {
-            Error::IllegalDeleteRequest { .. } => StatusCode::InvalidArguments,
-
             Error::ColumnDataType { .. } => StatusCode::Internal,
             Error::DuplicatedTimestampColumn { .. }
             | Error::DuplicatedColumnName { .. }
             | Error::MissingTimestampColumn { .. } => StatusCode::InvalidArguments,
-            Error::CreateVector { .. } => StatusCode::InvalidArguments,
             Error::MissingField { .. } => StatusCode::InvalidArguments,
             Error::InvalidColumnDef { source, .. } => source.status_code(),
-            Error::UnexpectedValuesLength { .. } | Error::UnknownLocationType { .. } => {
-                StatusCode::InvalidArguments
-            }
+            Error::UnknownLocationType { .. } => StatusCode::InvalidArguments,
 
             Error::UnknownColumnDataType { .. } | Error::InvalidStringIndexColumnType { .. } => {
                 StatusCode::InvalidArguments

src/common/grpc-expr/src/insert.rs

@@ -1,80 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use api::helper;
-use api::v1::column::Values;
-use common_base::BitVec;
-use datatypes::data_type::{ConcreteDataType, DataType};
-use datatypes::prelude::VectorRef;
-use snafu::{ResultExt, ensure};
-
-use crate::error::{CreateVectorSnafu, Result, UnexpectedValuesLengthSnafu};
-
-pub(crate) fn add_values_to_builder(
-    data_type: ConcreteDataType,
-    values: Values,
-    row_count: usize,
-    null_mask: Vec<u8>,
-) -> Result<VectorRef> {
-    if null_mask.is_empty() {
-        Ok(helper::pb_values_to_vector_ref(&data_type, values))
-    } else {
-        let builder = &mut data_type.create_mutable_vector(row_count);
-        let values = helper::pb_values_to_values(&data_type, values);
-        let null_mask = BitVec::from_vec(null_mask);
-        ensure!(
-            null_mask.count_ones() + values.len() == row_count,
-            UnexpectedValuesLengthSnafu {
-                reason: "If null_mask is not empty, the sum of the number of nulls and the length of values must be equal to row_count."
-            }
-        );
-
-        let mut idx_of_values = 0;
-        for idx in 0..row_count {
-            match is_null(&null_mask, idx) {
-                Some(true) => builder.push_null(),
-                _ => {
-                    builder
-                        .try_push_value_ref(values[idx_of_values].as_value_ref())
-                        .context(CreateVectorSnafu)?;
-                    idx_of_values += 1
-                }
-            }
-        }
-        Ok(builder.to_vector())
-    }
-}
-
-fn is_null(null_mask: &BitVec, idx: usize) -> Option<bool> {
-    null_mask.get(idx).as_deref().copied()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_is_null() {
-        let null_mask = BitVec::from_slice(&[0b0000_0001, 0b0000_1000]);
-
-        assert_eq!(Some(true), is_null(&null_mask, 0));
-        assert_eq!(Some(false), is_null(&null_mask, 1));
-        assert_eq!(Some(false), is_null(&null_mask, 10));
-        assert_eq!(Some(true), is_null(&null_mask, 11));
-        assert_eq!(Some(false), is_null(&null_mask, 12));
-
-        assert_eq!(None, is_null(&null_mask, 16));
-        assert_eq!(None, is_null(&null_mask, 99));
-    }
-}

src/common/grpc-expr/src/lib.rs

@@ -13,9 +13,7 @@
 // limitations under the License.
 
 mod alter;
-pub mod delete;
 pub mod error;
-pub mod insert;
 pub mod util;
 
 pub use alter::{alter_expr_to_request, create_table_schema};

src/common/grpc-expr/src/util.rs

@@ -167,7 +167,7 @@ pub fn build_create_table_expr(
             default_constraint: vec![],
             semantic_type,
             comment: String::new(),
-            datatype_extension: *datatype_extension,
+            datatype_extension: datatype_extension.clone(),
             options: options.clone(),
         });
     }
@@ -209,7 +209,7 @@ pub fn extract_new_columns(
                 default_constraint: vec![],
                 semantic_type: expr.semantic_type,
                 comment: String::new(),
-                datatype_extension: *expr.datatype_extension,
+                datatype_extension: expr.datatype_extension.clone(),
                 options: expr.options.clone(),
             });
             AddColumn {
@@ -425,7 +425,7 @@ mod tests {
             ConcreteDataType::from(
                 ColumnDataTypeWrapper::try_new(
                     decimal_column.data_type,
-                    decimal_column.datatype_extension,
+                    decimal_column.datatype_extension.clone(),
                 )
                 .unwrap()
             )
@@ -520,6 +520,7 @@ mod tests {
                         .as_ref()
                         .unwrap()
                         .datatype_extension
+                        .clone()
                 )
                 .unwrap()
             )

src/common/grpc/src/channel_manager.rs

@@ -479,7 +479,7 @@ impl Pool {
         })
     }
 
-    fn entry(&self, addr: String) -> Entry<String, Channel> {
+    fn entry(&self, addr: String) -> Entry<'_, String, Channel> {
         self.channels.entry(addr)
     }
 

src/common/macro/src/admin_fn.rs

@@ -325,7 +325,7 @@ fn build_struct(
                     let result = #fn_name(handler, query_ctx, &[]).await
                         .map_err(|e| datafusion_common::DataFusionError::Execution(format!("Function execution error: {}", e.output_msg())))?;
 
-                    builder.push_value_ref(result.as_value_ref());
+                    builder.push_value_ref(&result.as_value_ref());
                 } else {
                     for i in 0..rows_num {
                         let args: Vec<_> = columns.iter()
@@ -335,7 +335,7 @@ fn build_struct(
                         let result = #fn_name(handler, query_ctx, &args).await
                             .map_err(|e| datafusion_common::DataFusionError::Execution(format!("Function execution error: {}", e.output_msg())))?;
 
-                        builder.push_value_ref(result.as_value_ref());
+                        builder.push_value_ref(&result.as_value_ref());
                     }
                 }
 
@@ -345,6 +345,20 @@ fn build_struct(
                 Ok(datafusion_expr::ColumnarValue::Array(result_vector.to_arrow_array()))
             }
         }
+
+        impl PartialEq for #name {
+            fn eq(&self, other: &Self) -> bool {
+                self.signature == other.signature
+            }
+        }
+
+        impl Eq for #name {}
+
+        impl std::hash::Hash for #name {
+            fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+                self.signature.hash(state)
+            }
+        }
     }
     .into()
 }

src/common/macro/src/row/schema.rs

@@ -90,6 +90,31 @@ fn impl_schema_method(fields: &[ParsedField<'_>]) -> Result<TokenStream2> {
                                 Some(ColumnDataTypeExtension { type_ext: Some(TypeExt::VectorType(VectorTypeExtension { dim: #dim })) })
                             }
                         }
+                        // TODO(sunng87): revisit all these implementations
+                        Some(TypeExt::ListType(ext)) => {
+                            let item_type = syn::Ident::new(&ext.datatype.to_string(), ident.span());
+                            quote! {
+                                Some(ColumnDataTypeExtension { type_ext: Some(TypeExt::ListType(ListTypeExtension { item_type: #item_type })) })
+                            }
+                        }
+                        Some(TypeExt::StructType(ext)) => {
+                            let fields = ext.fields.iter().map(|field| {
+                                let field_name = syn::Ident::new(&field.name.clone(), ident.span());
+                                let field_type = syn::Ident::new(&field.datatype.to_string(), ident.span());
+                                quote! {
+                                    StructField { name: #field_name, type_: #field_type }
+                                }
+                            }).collect::<Vec<_>>();
+                            quote! {
+                                Some(ColumnDataTypeExtension { type_ext: Some(TypeExt::StructType(StructTypeExtension { fields: [#(#fields),*] })) })
+                            }
+                        }
+                        Some(TypeExt::JsonNativeType(ext)) => {
+                            let inner = syn::Ident::new(&ext.datatype.to_string(), ident.span());
+                            quote! {
+                                Some(ColumnDataTypeExtension { type_ext: Some(TypeExt::JsonNativeType(JsonNativeTypeExtension { datatype: #inner })) })
+                            }
+                        }
                         None => {
                             quote! { None }
                         }

src/common/macro/src/row/utils.rs

@@ -184,7 +184,7 @@ pub(crate) fn convert_semantic_type_to_proto_semantic_type(
     }
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub(crate) struct ColumnDataTypeWithExtension {
     pub(crate) data_type: ColumnDataType,
     pub(crate) extension: Option<ColumnDataTypeExtension>,
@@ -260,7 +260,10 @@ pub(crate) fn get_column_data_type(
     infer_column_data_type: &Option<ColumnDataTypeWithExtension>,
     attribute: &ColumnAttribute,
 ) -> Option<ColumnDataTypeWithExtension> {
-    attribute.datatype.or(*infer_column_data_type)
+    attribute
+        .datatype
+        .clone()
+        .or_else(|| infer_column_data_type.clone())
 }
 
 /// Convert a column data type to a value data ident.
@@ -304,5 +307,7 @@ pub(crate) fn convert_column_data_type_to_value_data_ident(
         // Json is a special case, it is actually a string column.
         ColumnDataType::Json => format_ident!("StringValue"),
         ColumnDataType::Vector => format_ident!("VectorValue"),
+        ColumnDataType::List => format_ident!("ListValue"),
+        ColumnDataType::Struct => format_ident!("StructValue"),
     }
 }

src/common/mem-prof/src/jemalloc.rs

@@ -32,6 +32,7 @@ use crate::error::{FlamegraphSnafu, ParseJeHeapSnafu, Result};
 const PROF_DUMP: &[u8] = b"prof.dump\0";
 const OPT_PROF: &[u8] = b"opt.prof\0";
 const PROF_ACTIVE: &[u8] = b"prof.active\0";
+const PROF_GDUMP: &[u8] = b"prof.gdump\0";
 
 pub async fn dump_profile() -> Result<Vec<u8>> {
     ensure!(is_prof_enabled()?, ProfilingNotEnabledSnafu);
@@ -119,3 +120,16 @@ fn is_prof_enabled() -> Result<bool> {
     // safety: OPT_PROF variable, if present, is always a boolean value.
     Ok(unsafe { tikv_jemalloc_ctl::raw::read::<bool>(OPT_PROF).context(ReadOptProfSnafu)? })
 }
+
+pub fn set_gdump_active(active: bool) -> Result<()> {
+    ensure!(is_prof_enabled()?, ProfilingNotEnabledSnafu);
+    unsafe {
+        tikv_jemalloc_ctl::raw::update(PROF_GDUMP, active).context(error::UpdateGdumpSnafu)?;
+    }
+    Ok(())
+}
+
+pub fn is_gdump_active() -> Result<bool> {
+    // safety: PROF_GDUMP, if present, is a boolean value.
+    unsafe { Ok(tikv_jemalloc_ctl::raw::read::<bool>(PROF_GDUMP).context(error::ReadGdumpSnafu)?) }
+}

src/common/mem-prof/src/jemalloc/error.rs

@@ -71,6 +71,18 @@ pub enum Error {
         #[snafu(source)]
         error: tikv_jemalloc_ctl::Error,
     },
+
+    #[snafu(display("Failed to read jemalloc gdump flag"))]
+    ReadGdump {
+        #[snafu(source)]
+        error: tikv_jemalloc_ctl::Error,
+    },
+
+    #[snafu(display("Failed to update jemalloc gdump flag"))]
+    UpdateGdump {
+        #[snafu(source)]
+        error: tikv_jemalloc_ctl::Error,
+    },
 }
 
 impl ErrorExt for Error {
@@ -84,6 +96,8 @@ impl ErrorExt for Error {
             Error::ActivateProf { .. } => StatusCode::Internal,
             Error::DeactivateProf { .. } => StatusCode::Internal,
             Error::ReadProfActive { .. } => StatusCode::Internal,
+            Error::ReadGdump { .. } => StatusCode::Internal,
+            Error::UpdateGdump { .. } => StatusCode::Internal,
         }
     }
 

src/common/mem-prof/src/lib.rs

@@ -19,7 +19,7 @@ mod jemalloc;
 #[cfg(not(windows))]
 pub use jemalloc::{
     activate_heap_profile, deactivate_heap_profile, dump_flamegraph, dump_pprof, dump_profile,
-    is_heap_profile_active,
+    is_gdump_active, is_heap_profile_active, set_gdump_active,
 };
 
 #[cfg(windows)]
@@ -51,3 +51,13 @@ pub fn deactivate_heap_profile() -> error::Result<()> {
 pub fn is_heap_profile_active() -> error::Result<bool> {
     error::ProfilingNotSupportedSnafu.fail()
 }
+
+#[cfg(windows)]
+pub fn is_gdump_active() -> error::Result<bool> {
+    error::ProfilingNotSupportedSnafu.fail()
+}
+
+#[cfg(windows)]
+pub fn set_gdump_active(_: bool) -> error::Result<()> {
+    error::ProfilingNotSupportedSnafu.fail()
+}

src/common/meta/src/cluster.rs

@@ -120,10 +120,19 @@ pub struct NodeInfo {
     pub start_time_ms: u64,
     // The node build cpus
     #[serde(default)]
-    pub cpus: u32,
+    pub total_cpu_millicores: i64,
     // The node build memory bytes
     #[serde(default)]
-    pub memory_bytes: u64,
+    pub total_memory_bytes: i64,
+    // The node build cpu usage millicores
+    #[serde(default)]
+    pub cpu_usage_millicores: i64,
+    // The node build memory usage bytes
+    #[serde(default)]
+    pub memory_usage_bytes: i64,
+    // The node build hostname
+    #[serde(default)]
+    pub hostname: String,
 }
 
 #[derive(Debug, Clone, Copy, Eq, Hash, PartialEq, Serialize, Deserialize)]
@@ -330,8 +339,11 @@ mod tests {
             version: "".to_string(),
             git_commit: "".to_string(),
             start_time_ms: 1,
-            cpus: 0,
-            memory_bytes: 0,
+            total_cpu_millicores: 0,
+            total_memory_bytes: 0,
+            cpu_usage_millicores: 0,
+            memory_usage_bytes: 0,
+            hostname: "test_hostname".to_string(),
         };
 
         let node_info_bytes: Vec<u8> = node_info.try_into().unwrap();

src/common/meta/src/datanode.rs

@@ -29,22 +29,17 @@ use crate::error;
 use crate::error::Result;
 use crate::heartbeat::utils::get_datanode_workloads;
 
-pub(crate) const DATANODE_LEASE_PREFIX: &str = "__meta_datanode_lease";
-const INACTIVE_REGION_PREFIX: &str = "__meta_inactive_region";
-
 const DATANODE_STAT_PREFIX: &str = "__meta_datanode_stat";
 
 pub const REGION_STATISTIC_KEY: &str = "__region_statistic";
 
 lazy_static! {
     pub(crate) static ref DATANODE_LEASE_KEY_PATTERN: Regex =
-        Regex::new(&format!("^{DATANODE_LEASE_PREFIX}-([0-9]+)-([0-9]+)$")).unwrap();
+        Regex::new("^__meta_datanode_lease-([0-9]+)-([0-9]+)$").unwrap();
     static ref DATANODE_STAT_KEY_PATTERN: Regex =
         Regex::new(&format!("^{DATANODE_STAT_PREFIX}-([0-9]+)-([0-9]+)$")).unwrap();
-    static ref INACTIVE_REGION_KEY_PATTERN: Regex = Regex::new(&format!(
-        "^{INACTIVE_REGION_PREFIX}-([0-9]+)-([0-9]+)-([0-9]+)$"
-    ))
-    .unwrap();
+    static ref INACTIVE_REGION_KEY_PATTERN: Regex =
+        Regex::new("^__meta_inactive_region-([0-9]+)-([0-9]+)-([0-9]+)$").unwrap();
 }
 
 /// The key of the datanode stat in the storage.
@@ -297,7 +292,7 @@ impl From<&api::v1::meta::RegionStat> for RegionStat {
             rcus: value.rcus,
             wcus: value.wcus,
             approximate_bytes: value.approximate_bytes as u64,
-            engine: value.engine.to_string(),
+            engine: value.engine.clone(),
             role: RegionRole::from(value.role()),
             num_rows: region_stat.num_rows,
             memtable_size: region_stat.memtable_size,

src/common/meta/src/ddl/alter_logical_tables/validator.rs

@@ -85,7 +85,7 @@ impl<'a> AlterLogicalTableValidator<'a> {
         Ok(())
     }
 
-    fn table_names(&self) -> Vec<TableReference> {
+    fn table_names(&self) -> Vec<TableReference<'_>> {
         self.alters
             .iter()
             .map(|alter| {

src/common/meta/src/ddl/alter_table.rs

@@ -75,7 +75,7 @@ fn build_executor_from_alter_expr(alter_data: &AlterTableData) -> AlterTableExec
     let table_id = alter_data.table_id;
     let alter_kind = alter_data.task.alter_table.kind.as_ref().unwrap();
     let new_table_name = if let Kind::RenameTable(RenameTable { new_table_name }) = alter_kind {
-        Some(new_table_name.to_string())
+        Some(new_table_name.clone())
     } else {
         None
     };
@@ -418,7 +418,7 @@ impl AlterTableData {
         }
     }
 
-    fn table_ref(&self) -> TableReference {
+    fn table_ref(&self) -> TableReference<'_> {
         self.task.table_ref()
     }
 

src/common/meta/src/ddl/alter_table/executor.rs

@@ -132,7 +132,7 @@ impl AlterTableExecutor {
             );
 
             table_metadata_manager
-                .rename_table(current_table_info_value, new_table_name.to_string())
+                .rename_table(current_table_info_value, new_table_name.clone())
                 .await?;
         } else {
             debug!(
@@ -293,7 +293,7 @@ fn build_new_table_info(
             new_info.meta.next_column_id += columns.len() as u32;
         }
         AlterKind::RenameTable { new_table_name } => {
-            new_info.name = new_table_name.to_string();
+            new_info.name = new_table_name.clone();
         }
         AlterKind::DropColumns { .. }
         | AlterKind::ModifyColumnTypes { .. }

src/common/meta/src/ddl/create_flow.rs

@@ -379,9 +379,10 @@ pub enum CreateFlowState {
 }
 
 /// The type of flow.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
 pub enum FlowType {
     /// The flow is a batching task.
+    #[default]
     Batching,
     /// The flow is a streaming task.
     Streaming,
@@ -393,12 +394,6 @@ impl FlowType {
     pub const FLOW_TYPE_KEY: &str = "flow_type";
 }
 
-impl Default for FlowType {
-    fn default() -> Self {
-        Self::Batching
-    }
-}
-
 impl fmt::Display for FlowType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

src/common/meta/src/ddl/create_logical_tables/check.rs

@@ -52,7 +52,7 @@ impl CreateLogicalTablesProcedure {
                 ensure!(
                     task.create_table.create_if_not_exists,
                     TableAlreadyExistsSnafu {
-                        table_name: task.create_table.table_name.to_string(),
+                        table_name: task.create_table.table_name.clone(),
                     }
                 );
                 continue;

src/common/meta/src/ddl/create_table_template.rs

@@ -90,7 +90,7 @@ pub(crate) fn build_template(create_table_expr: &CreateTableExpr) -> Result<Crea
                     default_constraint: c.default_constraint.clone(),
                     semantic_type: semantic_type as i32,
                     comment: String::new(),
-                    datatype_extension: c.datatype_extension,
+                    datatype_extension: c.datatype_extension.clone(),
                     options: c.options.clone(),
                 }),
                 column_id: i as u32,
@@ -119,7 +119,7 @@ pub(crate) fn build_template(create_table_expr: &CreateTableExpr) -> Result<Crea
 
     let template = CreateRequest {
         region_id: 0,
-        engine: create_table_expr.engine.to_string(),
+        engine: create_table_expr.engine.clone(),
         column_defs,
         primary_key,
         path: String::new(),