feat: support prometheus format_query endpoint (#2731)

* feat: support prometheus format_query endpoint

Signed-off-by: tison <wander4096@gmail.com>

* add test

Signed-off-by: tison <wander4096@gmail.com>

---------

Signed-off-by: tison <wander4096@gmail.com>

.github/actions/deploy-greptimedb/action.yml

@@ -0,0 +1,31 @@
+name: Deploy GreptimeDB cluster
+description: Deploy GreptimeDB cluster on Kubernetes
+inputs:
+  aws-ci-test-bucket:
+    description: 'AWS S3 bucket name for testing'
+    required: true
+  aws-region:
+    description: 'AWS region for testing'
+    required: true
+  data-root:
+    description: 'Data root for testing'
+    required: true
+  aws-access-key-id:
+    description: 'AWS access key id for testing'
+    required: true
+  aws-secret-access-key:
+    description: 'AWS secret access key for testing'
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Deploy GreptimeDB by Helm
+      shell: bash
+      env:
+        DATA_ROOT: ${{ inputs.data-root }}
+        AWS_CI_TEST_BUCKET: ${{ inputs.aws-ci-test-bucket }}
+        AWS_REGION: ${{ inputs.aws-region }}
+        AWS_ACCESS_KEY_ID: ${{ inputs.aws-access-key-id }}
+        AWS_SECRET_ACCESS_KEY: ${{ inputs.aws-secret-access-key }}
+      run: |
+        ./.github/scripts/deploy-greptimedb.sh

.github/actions/sqlness-test/action.yml

@@ -0,0 +1,59 @@
+name: Run sqlness test
+description: Run sqlness test on GreptimeDB
+
+inputs:
+  aws-ci-test-bucket:
+    description: 'AWS S3 bucket name for testing'
+    required: true
+  aws-region:
+    description: 'AWS region for testing'
+    required: true
+  data-root:
+    description: 'Data root for testing'
+    required: true
+  aws-access-key-id:
+    description: 'AWS access key id for testing'
+    required: true
+  aws-secret-access-key:
+    description: 'AWS secret access key for testing'
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - name: Deploy GreptimeDB cluster by Helm
+      uses: ./.github/actions/deploy-greptimedb
+      with:
+        data-root: ${{ inputs.data-root }}
+        aws-ci-test-bucket: ${{ inputs.aws-ci-test-bucket }}
+        aws-region: ${{ inputs.aws-region }}
+        aws-access-key-id: ${{ inputs.aws-access-key-id }}
+        aws-secret-access-key: ${{ inputs.aws-secret-access-key }}
+
+    # TODO(zyy17): The following tests will be replaced by the real sqlness test.
+    - name: Run tests on greptimedb cluster
+      shell: bash
+      run: |
+        mysql -h 127.0.0.1 -P 14002 -e "CREATE TABLE IF NOT EXISTS system_metrics (host VARCHAR(255), idc VARCHAR(255), cpu_util DOUBLE, memory_util DOUBLE, disk_util DOUBLE, ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY(host, idc), TIME INDEX(ts));" && \
+        mysql -h 127.0.0.1 -P 14002 -e "SHOW TABLES;"
+
+    - name: Run tests on greptimedb cluster that uses S3
+      shell: bash
+      run: |
+        mysql -h 127.0.0.1 -P 24002 -e "CREATE TABLE IF NOT EXISTS system_metrics (host VARCHAR(255), idc VARCHAR(255), cpu_util DOUBLE, memory_util DOUBLE, disk_util DOUBLE, ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY(host, idc), TIME INDEX(ts));" && \
+        mysql -h 127.0.0.1 -P 24002 -e "SHOW TABLES;"
+
+    - name: Run tests on standalone greptimedb
+      shell: bash
+      run: |
+        mysql -h 127.0.0.1 -P 34002 -e "CREATE TABLE IF NOT EXISTS system_metrics (host VARCHAR(255), idc VARCHAR(255), cpu_util DOUBLE, memory_util DOUBLE, disk_util DOUBLE, ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY(host, idc), TIME INDEX(ts));" && \
+        mysql -h 127.0.0.1 -P 34002 -e "SHOW TABLES;"
+
+    - name: Clean S3 data
+      shell: bash
+      env:
+        AWS_DEFAULT_REGION: ${{ inputs.aws-region }}
+        AWS_ACCESS_KEY_ID: ${{ inputs.aws-access-key-id }}
+        AWS_SECRET_ACCESS_KEY: ${{ inputs.aws-secret-access-key }}
+      run: |
+        aws s3 rm s3://${{ inputs.aws-ci-test-bucket }}/${{ inputs.data-root }} --recursive

.github/scripts/deploy-greptimedb.sh

@@ -0,0 +1,172 @@
+#!/usr/bin/env bash
+
+set -e
+set -o pipefail
+
+KUBERNETES_VERSION="${KUBERNETES_VERSION:-v1.24.0}"
+ENABLE_STANDALONE_MODE="${ENABLE_STANDALONE_MODE:-true}"
+DEFAULT_INSTALL_NAMESPACE=${DEFAULT_INSTALL_NAMESPACE:-default}
+GREPTIMEDB_IMAGE_TAG=${GREPTIMEDB_IMAGE_TAG:-latest}
+ETCD_CHART="oci://registry-1.docker.io/bitnamicharts/etcd"
+GREPTIME_CHART="https://greptimeteam.github.io/helm-charts/"
+
+# Ceate a cluster with 1 control-plane node and 5 workers.
+function create_kind_cluster() {
+  cat <<EOF | kind create cluster --name "${CLUSTER}" --image kindest/node:"$KUBERNETES_VERSION" --config=-
+kind: Cluster
+apiVersion: kind.x-k8s.io/v1alpha4
+nodes:
+- role: control-plane
+- role: worker
+- role: worker
+- role: worker
+- role: worker
+- role: worker
+EOF
+}
+
+# Add greptime Helm chart repo.
+function add_greptime_chart() {
+  helm repo add greptime "$GREPTIME_CHART"
+  helm repo update
+}
+
+# Deploy a etcd cluster with 3 members.
+function deploy_etcd_cluster() {
+  local namespace="$1"
+
+  helm install etcd "$ETCD_CHART" \
+    --set replicaCount=3 \
+    --set auth.rbac.create=false \
+    --set auth.rbac.token.enabled=false \
+    -n "$namespace"
+
+  # Wait for etcd cluster to be ready.
+  kubectl rollout status statefulset/etcd -n "$namespace"
+}
+
+# Deploy greptimedb-operator.
+function deploy_greptimedb_operator() {
+  # Use the latest chart and image.
+  helm install greptimedb-operator greptime/greptimedb-operator \
+    --set image.tag=latest \
+    -n "$DEFAULT_INSTALL_NAMESPACE"
+
+  # Wait for greptimedb-operator to be ready.
+  kubectl rollout status deployment/greptimedb-operator -n "$DEFAULT_INSTALL_NAMESPACE"
+}
+
+# Deploy greptimedb cluster by using local storage.
+# It will expose cluster service ports as '14000', '14001', '14002', '14003' to local access.
+function deploy_greptimedb_cluster() {
+  local cluster_name=$1
+  local install_namespace=$2
+
+  kubectl create ns "$install_namespace"
+
+  deploy_etcd_cluster "$install_namespace"
+
+  helm install "$cluster_name" greptime/greptimedb-cluster \
+    --set image.tag="$GREPTIMEDB_IMAGE_TAG" \
+    --set meta.etcdEndpoints="etcd.$install_namespace:2379" \
+    -n "$install_namespace"
+
+  # Wait for greptimedb cluster to be ready.
+  while true; do
+    PHASE=$(kubectl -n "$install_namespace" get gtc "$cluster_name" -o jsonpath='{.status.clusterPhase}')
+    if [ "$PHASE" == "Running" ]; then
+      echo "Cluster is ready"
+      break
+    else
+      echo "Cluster is not ready yet: Current phase: $PHASE"
+      sleep 5 # wait for 5 seconds before check again.
+    fi
+  done
+
+  # Expose greptimedb cluster to local access.
+  kubectl -n "$install_namespace" port-forward svc/"$cluster_name"-frontend \
+    14000:4000 \
+    14001:4001 \
+    14002:4002 \
+    14003:4003 > /tmp/connections.out &
+}
+
+# Deploy greptimedb cluster by using S3.
+# It will expose cluster service ports as '24000', '24001', '24002', '24003' to local access.
+function deploy_greptimedb_cluster_with_s3_storage() {
+  local cluster_name=$1
+  local install_namespace=$2
+
+  kubectl create ns "$install_namespace"
+
+  deploy_etcd_cluster "$install_namespace"
+
+  helm install "$cluster_name" greptime/greptimedb-cluster -n "$install_namespace" \
+    --set image.tag="$GREPTIMEDB_IMAGE_TAG" \
+    --set meta.etcdEndpoints="etcd.$install_namespace:2379" \
+    --set storage.s3.bucket="$AWS_CI_TEST_BUCKET" \
+    --set storage.s3.region="$AWS_REGION" \
+    --set storage.s3.root="$DATA_ROOT" \
+    --set storage.s3.secretName=s3-credentials \
+    --set storage.credentials.secretName=s3-credentials \
+    --set storage.credentials.secretCreation.enabled=true \
+    --set storage.credentials.secretCreation.enableEncryption=false \
+    --set storage.credentials.secretCreation.data.access-key-id="$AWS_ACCESS_KEY_ID" \
+    --set storage.credentials.secretCreation.data.secret-access-key="$AWS_SECRET_ACCESS_KEY"
+
+  # Wait for greptimedb cluster to be ready.
+  while true; do
+    PHASE=$(kubectl -n "$install_namespace" get gtc "$cluster_name" -o jsonpath='{.status.clusterPhase}')
+    if [ "$PHASE" == "Running" ]; then
+      echo "Cluster is ready"
+      break
+    else
+      echo "Cluster is not ready yet: Current phase: $PHASE"
+      sleep 5 # wait for 5 seconds before check again.
+    fi
+  done
+
+  # Expose greptimedb cluster to local access.
+  kubectl -n "$install_namespace" port-forward svc/"$cluster_name"-frontend \
+    24000:4000 \
+    24001:4001 \
+    24002:4002 \
+    24003:4003 > /tmp/connections.out &
+}
+
+# Deploy standalone greptimedb.
+# It will expose cluster service ports as '34000', '34001', '34002', '34003' to local access.
+function deploy_standalone_greptimedb() {
+  helm install greptimedb-standalone greptime/greptimedb-standalone \
+    --set image.tag="$GREPTIMEDB_IMAGE_TAG" \
+    -n "$DEFAULT_INSTALL_NAMESPACE"
+
+  # Wait for etcd cluster to be ready.
+  kubectl rollout status statefulset/greptimedb-standalone -n "$DEFAULT_INSTALL_NAMESPACE"
+
+  # Expose greptimedb to local access.
+  kubectl -n "$DEFAULT_INSTALL_NAMESPACE" port-forward svc/greptimedb-standalone \
+    34000:4000 \
+    34001:4001 \
+    34002:4002 \
+    34003:4003 > /tmp/connections.out &
+}
+
+# Entrypoint of the script.
+function main() {
+  create_kind_cluster
+  add_greptime_chart
+
+  # Deploy standalone greptimedb in the same K8s.
+  if [ "$ENABLE_STANDALONE_MODE" == "true" ]; then
+    deploy_standalone_greptimedb
+  fi
+
+  deploy_greptimedb_operator
+  deploy_greptimedb_cluster testcluster testcluster
+  deploy_greptimedb_cluster_with_s3_storage testcluster-s3 testcluster-s3
+}
+
+# Usages:
+# - Deploy greptimedb cluster: ./deploy-greptimedb.sh
+main

.github/workflows/license.yaml

@@ -13,4 +13,4 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - name: Check License Header
-      uses: apache/skywalking-eyes/header@df70871af1a8109c9a5b1dc824faaf65246c5236
+      uses: korandoru/hawkeye@v3

.github/workflows/nightly-funtional-tests.yml

@@ -0,0 +1,26 @@
+name: Nightly functional tests
+
+on:
+  schedule:
+    # At 00:00 on Tuesday.
+    - cron: '0 0 * * 2'
+  workflow_dispatch:
+
+jobs:
+  sqlness-test:
+    name: Run sqlness test
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Run sqlness test
+        uses: ./.github/actions/sqlness-test
+        with:
+          data-root: sqlness-test
+          aws-ci-test-bucket: ${{ vars.AWS_CI_TEST_BUCKET }}
+          aws-region: ${{ vars.AWS_CI_TEST_BUCKET_REGION }}
+          aws-access-key-id: ${{ secrets.AWS_CI_TEST_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_CI_TEST_SECRET_ACCESS_KEY }}

.licenserc.yaml

@@ -1,14 +0,0 @@
-header:
-  license:
-    spdx-id: Apache-2.0
-    copyright-owner: Greptime Team
-
-  paths:
-    - "**/*.rs"
-    - "**/*.py"
-
-  comment: on-failure
-
-dependency:
-  files:
-    - Cargo.toml

CONTRIBUTING.md

@@ -2,7 +2,7 @@
 
 Thanks a lot for considering contributing to GreptimeDB. We believe people like you would make GreptimeDB a great product. We intend to build a community where individuals can have open talks, show respect for one another, and speak with true ❤️. Meanwhile, we are to keep transparency and make your effort count here.
 
-Read the guidelines, and they can help you get started. Communicate with respect to developers maintaining and developing the project. In return, they should reciprocate that respect by addressing your issue, reviewing changes, as well as helping finalize and merge your pull requests.
+Please read the guidelines, and they can help you get started. Communicate with respect to developers maintaining and developing the project. In return, they should reciprocate that respect by addressing your issue, reviewing changes, as well as helping finalize and merge your pull requests.
 
 Follow our [README](https://github.com/GreptimeTeam/greptimedb#readme) to get the whole picture of the project. To learn about the design of GreptimeDB, please refer to the [design docs](https://github.com/GrepTimeTeam/docs).
 
@@ -21,7 +21,7 @@ Pull requests are great, but we accept all kinds of other help if you like. Such
 - Write tutorials or blog posts. Blog, speak about, or create tutorials about one of GreptimeDB's many features. Mention [@greptime](https://twitter.com/greptime) on Twitter and email info@greptime.com so we can give pointers and tips and help you spread the word by promoting your content on Greptime communication channels.
 - Improve the documentation. [Submit documentation](http://github.com/greptimeTeam/docs/) updates, enhancements, designs, or bug fixes, and fixing any spelling or grammar errors will be very much appreciated.
 - Present at meetups and conferences about your GreptimeDB projects. Your unique challenges and successes in building things with GreptimeDB can provide great speaking material. We'd love to review your talk abstract, so get in touch with us if you'd like some help!
-- Submit bug reports. To report a bug or a security issue, you can [open a new GitHub issue](https://github.com/GrepTimeTeam/greptimedb/issues/new).
+- Submitting bug reports. To report a bug or a security issue, you can [open a new GitHub issue](https://github.com/GrepTimeTeam/greptimedb/issues/new).
 - Speak up feature requests. Send feedback is a great way for us to understand your different use cases of GreptimeDB better. If you want to share your experience with GreptimeDB, or if you want to discuss any ideas, you can start a discussion on [GitHub discussions](https://github.com/GreptimeTeam/greptimedb/discussions), chat with the Greptime team on [Slack](https://greptime.com/slack), or you can tweet [@greptime](https://twitter.com/greptime) on Twitter.
 
 ## Code of Conduct
@@ -49,6 +49,7 @@ GreptimeDB uses the [Apache 2.0 license](https://github.com/GreptimeTeam/greptim
 ### Before PR
 
 - To ensure that community is free and confident in its ability to use your contributions, please sign the Contributor License Agreement (CLA) which will be incorporated in the pull request process.
+- Make sure all files have proper license header (running `docker run --rm -v $(pwd):/github/workspace ghcr.io/korandoru/hawkeye-native:v3 format` from the project root).
 - Make sure all your codes are formatted and follow the [coding style](https://pingcap.github.io/style-guide/rust/).
 - Make sure all unit tests are passed (using `cargo test --workspace` or [nextest](https://nexte.st/index.html) `cargo nextest run`).
 - Make sure all clippy warnings are fixed (you can check it locally by running `cargo clippy --workspace --all-targets -- -D warnings`).
@@ -81,7 +82,7 @@ Now, `pre-commit` will run automatically on `git commit`.
 ### Title
 
 The titles of pull requests should be prefixed with category names listed in [Conventional Commits specification](https://www.conventionalcommits.org/en/v1.0.0)
-like `feat`/`fix`/`docs`, with a concise summary of code change following. DO NOT use last commit message as pull request title.
+like `feat`/`fix`/`docs`, with a concise summary of code change following. AVOID using the last commit message as pull request title.
 
 ### Description
 
@@ -100,7 +101,7 @@ of what you were trying to do and what went wrong. You can also reach for help i
 
 ## Community
 
-The core team will be thrilled if you participate in any way you like. When you are stuck, try ask for help by filing an issue, with a detailed description of what you were trying to do and what went wrong. If you have any questions or if you would like to get involved in our community, please check out:
+The core team will be thrilled if you would like to participate in any way you like. When you are stuck, try to ask for help by filing an issue, with a detailed description of what you were trying to do and what went wrong. If you have any questions or if you would like to get involved in our community, please check out:
 
 - [GreptimeDB Community Slack](https://greptime.com/slack)
 - [GreptimeDB Github Discussions](https://github.com/GreptimeTeam/greptimedb/discussions)

Cargo.toml

@@ -27,6 +27,7 @@ members = [
     "src/common/telemetry",
     "src/common/test-util",
     "src/common/time",
+    "src/common/decimal",
     "src/common/version",
     "src/datanode",
     "src/datatypes",
@@ -35,6 +36,7 @@ members = [
     "src/log-store",
     "src/meta-client",
     "src/meta-srv",
+    "src/metric-engine",
     "src/mito2",
     "src/object-store",
     "src/operator",
@@ -61,36 +63,42 @@ license = "Apache-2.0"
 
 [workspace.dependencies]
 aquamarine = "0.3"
-arrow = { version = "43.0" }
-arrow-array = "43.0"
-arrow-flight = "43.0"
-arrow-schema = { version = "43.0", features = ["serde"] }
+arrow = { version = "47.0" }
+arrow-array = "47.0"
+arrow-flight = "47.0"
+arrow-schema = { version = "47.0", features = ["serde"] }
 async-stream = "0.3"
 async-trait = "0.1"
+base64 = "0.21"
+bigdecimal = "0.4.2"
 chrono = { version = "0.4", features = ["serde"] }
-datafusion = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "b6f3b28b6fe91924cc8dd3d83726b766f2a706ec" }
-datafusion-common = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "b6f3b28b6fe91924cc8dd3d83726b766f2a706ec" }
-datafusion-expr = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "b6f3b28b6fe91924cc8dd3d83726b766f2a706ec" }
-datafusion-optimizer = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "b6f3b28b6fe91924cc8dd3d83726b766f2a706ec" }
-datafusion-physical-expr = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "b6f3b28b6fe91924cc8dd3d83726b766f2a706ec" }
-datafusion-sql = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "b6f3b28b6fe91924cc8dd3d83726b766f2a706ec" }
-datafusion-substrait = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "b6f3b28b6fe91924cc8dd3d83726b766f2a706ec" }
+datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
+datafusion-common = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
+datafusion-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
+datafusion-optimizer = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
+datafusion-physical-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
+datafusion-sql = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
+datafusion-substrait = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
 derive_builder = "0.12"
-etcd-client = "0.11"
+etcd-client = "0.12"
 futures = "0.3"
 futures-util = "0.3"
-greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "1f1dd532a111e3834cc3019c5605e2993ffb9dc3" }
+greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "7eb2e78be7a104d2582fbea0bcb1e019407da702" }
 humantime-serde = "1.1"
 itertools = "0.10"
 lazy_static = "1.4"
 meter-core = { git = "https://github.com/GreptimeTeam/greptime-meter.git", rev = "abbd357c1e193cd270ea65ee7652334a150b628f" }
-metrics = "0.20"
 moka = "0.12"
 once_cell = "1.18"
-opentelemetry-proto = { version = "0.2", features = ["gen-tonic", "metrics", "traces"] }
-parquet = "43.0"
+opentelemetry-proto = { git = "https://github.com/waynexia/opentelemetry-rust.git", rev = "33841b38dda79b15f2024952be5f32533325ca02", features = [
+    "gen-tonic",
+    "metrics",
+    "trace",
+] }
+parquet = "47.0"
 paste = "1.0"
-prost = "0.11"
+prometheus = { version = "0.13.3", features = ["process"] }
+prost = "0.12"
 raft-engine = { git = "https://github.com/tikv/raft-engine.git", rev = "22dfb426cd994602b57725ef080287d3e53db479" }
 rand = "0.8"
 regex = "1.8"
@@ -99,11 +107,13 @@ reqwest = { version = "0.11", default-features = false, features = [
     "rustls-tls-native-roots",
     "stream",
 ] }
+rust_decimal = "1.32.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 smallvec = "1"
-snafu = { version = "0.7", features = ["backtraces"] }
-sqlparser = { git = "https://github.com/GreptimeTeam/sqlparser-rs.git", rev = "6cf9d23d5b8fbecd65efc1d9afb7e80ad7a424da", features = [
+snafu = "0.7"
+# on branch v0.38.x
+sqlparser = { git = "https://github.com/GreptimeTeam/sqlparser-rs.git", rev = "0fbae07d0c46dc18e3381c406d8b9b8abef6b1fd", features = [
     "visitor",
 ] }
 strum = { version = "0.25", features = ["derive"] }
@@ -111,8 +121,9 @@ tempfile = "3"
 tokio = { version = "1.28", features = ["full"] }
 tokio-util = { version = "0.7", features = ["io-util", "compat"] }
 toml = "0.7"
-tonic = { version = "0.9", features = ["tls"] }
+tonic = { version = "0.10", features = ["tls"] }
 uuid = { version = "1", features = ["serde", "v4", "fast-rng"] }
+
 ## workspaces members
 api = { path = "src/api" }
 auth = { path = "src/auth" }

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2022 Greptime Team
+   Copyright [yyyy] [name of copyright owner]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -184,6 +184,6 @@ Please refer to [contribution guidelines](CONTRIBUTING.md) for more information.
 ## Acknowledgement
 - GreptimeDB uses [Apache Arrow](https://arrow.apache.org/) as the memory model and [Apache Parquet](https://parquet.apache.org/) as the persistent file format.
 - GreptimeDB's query engine is powered by [Apache Arrow DataFusion](https://github.com/apache/arrow-datafusion).
-- [OpenDAL](https://github.com/datafuselabs/opendal) from [Datafuse Labs](https://github.com/datafuselabs) gives GreptimeDB a very general and elegant data access abstraction layer.
-- GreptimeDB’s meta service is based on [etcd](https://etcd.io/).
+- [Apache OpenDAL (incubating)](https://opendal.apache.org) gives GreptimeDB a very general and elegant data access abstraction layer.
+- GreptimeDB's meta service is based on [etcd](https://etcd.io/).
 - GreptimeDB uses [RustPython](https://github.com/RustPython/RustPython) for experimental embedded python scripting.

benchmarks/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 arrow.workspace = true
 chrono.workspace = true
 clap = { version = "4.0", features = ["derive"] }
-client = { workspace = true }
+client.workspace = true
 futures-util.workspace = true
 indicatif = "0.17.1"
 itertools.workspace = true

config/datanode.example.toml

@@ -101,6 +101,13 @@ auto_flush_interval = "1h"
 global_write_buffer_size = "1GB"
 # Global write buffer size threshold to reject write requests (default 2G).
 global_write_buffer_reject_size = "2GB"
+# Cache size for SST metadata (default 128MB). Setting it to 0 to disable the cache.
+sst_meta_cache_size = "128MB"
+# Cache size for vectors and arrow arrays (default 512MB). Setting it to 0 to disable the cache.
+vector_cache_size = "512MB"
+# Buffer size for SST writing.
+sst_write_buffer_size = "8MB"
+
 
 # Log options
 # [logging]

config/metasrv.example.toml

@@ -28,6 +28,13 @@ max_retry_times = 12
 # Initial retry delay of procedures, increases exponentially
 retry_delay = "500ms"
 
+# Failure detectors options.
+[failure_detector]
+threshold = 8.0
+min_std_deviation = "100ms"
+acceptable_heartbeat_pause = "3000ms"
+first_heartbeat_estimate = "1000ms"
+
 # # Datanode options.
 # [datanode]
 # # Datanode client options.

docs/rfcs/2023-11-03-inverted-index.md

@@ -0,0 +1,113 @@
+---
+Feature Name: Inverted Index for SST File
+Tracking Issue: TBD
+Date: 2023-11-03
+Author: "Zhong Zhenchi <zhongzc_arch@outlook.com>"
+---
+
+# Summary
+This RFC proposes an optimization towards the storage engine by introducing an inverted indexing methodology aimed at optimizing label selection queries specifically pertaining to Metrics with tag columns as the target for optimization.
+
+# Introduction
+In the current system setup, in the Mito Engine, the first column of Primary Keys has a Min-Max index, which significantly optimizes the outcome. However, there are limitations when it comes to other columns, primarily tags. This RFC suggests the implementation of an inverted index to provide enhanced filtering benefits to bridge these limitations and improve overall system performance.
+
+# Design Detail
+
+## Inverted Index
+
+The primary aim of the proposed inverted index is to optimize tag columns in the SST Parquet Files within the Mito Engine. The mapping and construction of an inverted index, from Tag Values to Row Groups, enables efficient logical structures that provide faster and more flexible queries.
+
+When scanning SST Files, pushed-down filters applied to a respective Tag's inverted index, determine the final Row Groups to be indexed and scanned, further bolstering the speed and efficiency of data retrieval processes.
+
+## Index Format
+
+The Inverted Index for each SST file follows the format shown below:
+
+```
+inverted_index₀ inverted_index₁ ... inverted_indexₙ footer
+```
+
+The structure inside each Inverted Index is as followed:
+
+```
+bitmap₀ bitmap₁ bitmap₂ ... bitmapₙ null_bitmap fst
+```
+
+The format is encapsulated by a footer:
+
+```
+footer_payload footer_payload_size
+```
+
+The `footer_payload` is presented in protobuf encoding of `InvertedIndexFooter`.
+
+The complete format is containerized in [Puffin](https://iceberg.apache.org/puffin-spec/) with the type defined as `greptime-inverted-index-v1`.
+
+## Protobuf Details
+
+The `InvertedIndexFooter` is defined in the following protobuf structure:
+
+```protobuf
+message InvertedIndexFooter {
+    repeated InvertedIndexMeta metas;
+}
+
+message InvertedIndexMeta {
+    string name;
+    uint64 row_count_in_group;
+    uint64 fst_offset;
+    uint64 fst_size;
+    uint64 null_bitmap_offset;
+    uint64 null_bitmap_size;
+    InvertedIndexStats stats;
+}
+
+message InvertedIndexStats {
+    uint64 null_count;
+    uint64 distinct_count;
+    bytes min_value;
+    bytes max_value;
+}
+```
+
+## Bitmap
+
+Bitmaps are used to represent indices of fixed-size groups. Rows are divided into groups of a fixed size, defined in the `InvertedIndexMeta` as `row_count_in_group`.
+
+For example, when `row_count_in_group` is `4096`, it means each group has `4096` rows. If there are a total of `10000` rows, there will be `3` groups in total. The first two groups will have `4096` rows each, and the last group will have `1808` rows. If the indexed values are found in row `200` and `9000`, they will correspond to groups `0` and `2`, respectively. Therefore, the bitmap should show `0` and `2`.
+
+Bitmap is implemented using [BitVec](https://docs.rs/bitvec/latest/bitvec/), selected due to its efficient representation of dense data arrays typical of indices of groups.
+
+
+## Finite State Transducer (FST)
+
+[FST](https://docs.rs/fst/latest/fst/) is a highly efficient data structure ideal for in-memory indexing. It represents ordered sets or maps where the keys are bytes. The choice of the FST effectively balances the need for performance, space efficiency, and the ability to perform complex analyses such as regular expression matching.
+
+The conventional usage of FST and `u64` values has been adapted to facilitate indirect indexing to row groups. As the row groups are represented as Bitmaps, we utilize the `u64` values split into bitmap's offset (higher 32 bits) and size (lower 32 bits) to represent the location of these Bitmaps. 
+
+## API Design
+
+Two APIs `InvertedIndexBuilder` for building indexes and  `InvertedIndexSearcher` for querying indexes are designed:
+
+```rust
+type Bytes = Vec<u8>;
+type GroupId = u64;
+
+trait InvertedIndexBuilder {
+    fn add(&mut self, name: &str, value: Option<&Bytes>, group_id: GroupId) -> Result<()>;
+    fn finish(&mut self) -> Result<()>;
+}
+
+enum Predicate {
+    Gt(Bytes),
+    GtEq(Bytes),
+    Lt(Bytes),
+    LtEq(Bytes),
+    InList(Vec<Bytes>),
+    RegexMatch(String),
+}
+
+trait InvertedIndexSearcher {
+    fn search(&mut self, name: &str, predicates: &[Predicate]) -> Result<impl IntoIterator<GroupId>>;
+}
+```

docs/rfcs/2023-11-07-region-migration.md

@@ -0,0 +1,169 @@
+---
+Feature Name: Region Migration Procedure
+Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/2700
+Date: 2023-11-03
+Author: "Xu Wenkang <wenymedia@gmail.com>"
+---
+
+# Summary
+This RFC proposes a way that brings the ability of Meta Server to move regions between the Datanodes.
+
+# Motivation
+Typically, We need this ability in the following scenarios:
+- Migrate hot-spot Regions to idle Datanode
+- Move the failure Regions to an available Datanode
+
+# Details
+
+```mermaid
+flowchart TD
+    style Start fill:#85CB90,color:#fff
+    style End fill:#85CB90,color:#fff
+    style SelectCandidate fill:#F38488,color:#fff
+    style OpenCandidate fill:#F38488,color:#fff
+    style UpdateMetadataDown fill:#F38488,color:#fff
+    style UpdateMetadataUp fill:#F38488,color:#fff
+    style UpdateMetadataRollback fill:#F38488,color:#fff
+    style DowngradeLeader fill:#F38488,color:#fff
+    style UpgradeCandidate fill:#F38488,color:#fff
+
+    Start[Start] 
+    SelectCandidate[Select Candidate] 
+    UpdateMetadataDown["`Update Metadata(Down)
+        1. Downgrade Leader
+    `"]
+    DowngradeLeader["`Downgrade Leader
+    1. Become Follower
+    2. Return **last_entry_id**
+    `"]
+    UpgradeCandidate["`Upgrade Candidate
+    1. Replay to **last_entry_id**
+    2. Become Leader
+    `"]
+    UpdateMetadataUp["`Update Metadata(Up)
+        1. Switch Leader
+        2.1. Remove Old Leader(Opt.)
+        2.2. Move Old Leader to Follower(Opt.)
+    `"]
+    UpdateMetadataRollback["`Update Metadata(Rollback)
+        1. Upgrade old Leader
+    `"]
+    End
+    AnyCandidate{Available?}
+    OpenCandidate["Open Candidate"]
+    CloseOldLeader["Close Old Leader"]
+
+    Start 
+    --> SelectCandidate
+    --> AnyCandidate
+    --> |Yes| UpdateMetadataDown 
+    --> I1["Invalid Frontend Cache"]
+    --> DowngradeLeader 
+    --> UpgradeCandidate
+    --> UpdateMetadataUp
+    --> I2["Invalid Frontend Cache"]
+    --> End
+    
+    UpgradeCandidate
+    --> UpdateMetadataRollback
+    --> I3["Invalid Frontend Cache"]
+    --> End
+
+    I2 
+    --> CloseOldLeader
+    --> End
+
+    AnyCandidate 
+    --> |No| OpenCandidate
+    --> UpdateMetadataDown
+```
+
+**Only the red nodes will persist state after it has succeeded**, and other nodes won't persist state. (excluding the Start and End nodes).
+
+## Steps
+
+**The persistent context:** It's shared in each step and available after recovering. It will only be updated/stored after the Red node has succeeded.
+
+Values: 
+- `region_id`: The target leader region.
+- `peer`: The target datanode.
+- `close_old_leader`: Indicates whether close the region. 
+- `leader_may_unreachable`: It's used to support the failover procedure.
+
+**The Volatile context:** It's shared in each step and available in executing (including retrying). It will be dropped if the procedure runner crashes.
+
+### Select Candidate
+
+The Persistent state: Selected Candidate Region.
+
+### Update Metadata(Down)
+
+**The Persistent context:**
+- The (latest/updated) `version` of `TableRouteValue`, It will be used in the step of `Update Metadata(Up)`.
+
+### Downgrade Leader
+This step sends an instruction via heartbeat and performs:
+1. Downgrades leader region.
+2. Retrieves the `last_entry_id` (if available).
+
+If the target leader region is not found: 
+- Sets `close_old_leader` to true.
+- Sets `leader_may_unreachable` to true.
+
+If the target Datanode is unreachable:
+- Waits for region lease expired.
+- Sets `close_old_leader` to true.
+- Sets `leader_may_unreachable` to true.
+
+**The Persistent context:**
+None
+
+**The Persistent state:** 
+- `last_entry_id`
+
+*Passes to next step.
+
+
+### Upgrade Candidate
+This step sends an instruction via heartbeat and performs:
+1. Replays the WAL to latest(`last_entry_id`).
+2. Upgrades the candidate region.
+
+If the target region is not found: 
+- Rollbacks.
+- Notifies the failover detector if `leader_may_unreachable` == true.
+- Exits procedure.
+
+If the target Datanode is unreachable:
+- Rollbacks.
+- Notifies the failover detector if `leader_may_unreachable` == true.
+- Exits procedure.
+
+**The Persistent context:**
+None
+
+### Update Metadata(Up)
+This step performs
+1. Switches Leader.
+2. Removes Old Leader(Opt.).
+3. Moves Old Leader to follower(Opt.).
+
+The `TableRouteValue` version should equal the `TableRouteValue`'s `version` in Persistent context. Otherwise, verifies whether `TableRouteValue` already updated.
+
+**The Persistent context:**
+None
+
+### Close Old Leader(Opt.)
+This step sends a close region instruction via heartbeat.
+
+If the target leader region is not found: 
+- Ignore.
+
+If the target Datanode is unreachable: 
+- Ignore.
+
+### Open Candidate(Opt.)
+This step sends an open region instruction via heartbeat and waits for conditions to be met (typically, the condition is that the `last_entry_id` of the Candidate Region is very close to that of the Leader Region or the latest).
+
+If the target Datanode is unreachable: 
+- Exits procedure.

licenserc.toml

@@ -0,0 +1,24 @@
+# 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.
+
+headerPath = "Apache-2.0.txt"
+
+includes = [
+    "*.rs",
+    "*.py",
+]
+
+[properties]
+inceptionYear = 2023
+copyrightOwner = "Greptime Team"

src/api/Cargo.toml

@@ -5,14 +5,14 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-common-base = { workspace = true }
-common-error = { workspace = true }
-common-macro = { workspace = true }
-common-time = { workspace = true }
-datatypes = { workspace = true }
+common-base.workspace = true
+common-error.workspace = true
+common-macro.workspace = true
+common-time.workspace = true
+datatypes.workspace = true
 greptime-proto.workspace = true
 prost.workspace = true
-snafu = { version = "0.7", features = ["backtraces"] }
+snafu.workspace = true
 tonic.workspace = true
 
 [build-dependencies]

src/api/src/error.rs

@@ -28,7 +28,12 @@ pub type Result<T> = std::result::Result<T, Error>;
 #[stack_trace_debug]
 pub enum Error {
     #[snafu(display("Unknown proto column datatype: {}", datatype))]
-    UnknownColumnDataType { datatype: i32, location: Location },
+    UnknownColumnDataType {
+        datatype: i32,
+        location: Location,
+        #[snafu(source)]
+        error: prost::DecodeError,
+    },
 
     #[snafu(display("Failed to create column datatype from {:?}", from))]
     IntoColumnDataType {

src/api/src/helper.rs

@@ -50,7 +50,7 @@ pub struct ColumnDataTypeWrapper(ColumnDataType);
 
 impl ColumnDataTypeWrapper {
     pub fn try_new(datatype: i32) -> Result<Self> {
-        let datatype = ColumnDataType::from_i32(datatype)
+        let datatype = ColumnDataType::try_from(datatype)
             .context(error::UnknownColumnDataTypeSnafu { datatype })?;
         Ok(Self(datatype))
     }
@@ -705,7 +705,7 @@ pub fn is_semantic_type_eq(type_value: i32, semantic_type: SemanticType) -> bool
 
 /// Returns true if the pb type value is valid.
 pub fn is_column_type_value_eq(type_value: i32, expect_type: &ConcreteDataType) -> bool {
-    let Some(column_type) = ColumnDataType::from_i32(type_value) else {
+    let Ok(column_type) = ColumnDataType::try_from(type_value) else {
         return false;
     };
 

src/auth/src/common.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/auth/src/error.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/auth/src/lib.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/auth/src/permission.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/auth/src/tests.rs

@@ -4,13 +4,14 @@
 // 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
+//     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 secrecy::ExposeSecret;
 
 use crate::error::{

src/auth/src/user_info.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/auth/src/user_provider.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/auth/tests/mod.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/catalog/Cargo.toml

@@ -8,46 +8,46 @@ license.workspace = true
 testing = []
 
 [dependencies]
-api = { workspace = true }
+api.workspace = true
 arc-swap = "1.0"
 arrow-schema.workspace = true
 async-stream.workspace = true
 async-trait = "0.1"
-common-catalog = { workspace = true }
-common-error = { workspace = true }
-common-grpc = { workspace = true }
-common-macro = { workspace = true }
-common-meta = { workspace = true }
-common-query = { workspace = true }
-common-recordbatch = { workspace = true }
-common-runtime = { workspace = true }
-common-telemetry = { workspace = true }
-common-time = { workspace = true }
+common-catalog.workspace = true
+common-error.workspace = true
+common-grpc.workspace = true
+common-macro.workspace = true
+common-meta.workspace = true
+common-query.workspace = true
+common-recordbatch.workspace = true
+common-runtime.workspace = true
+common-telemetry.workspace = true
+common-time.workspace = true
 dashmap = "5.4"
 datafusion.workspace = true
-datatypes = { workspace = true }
+datatypes.workspace = true
 futures = "0.3"
 futures-util.workspace = true
 lazy_static.workspace = true
-meta-client = { workspace = true }
-metrics.workspace = true
+meta-client.workspace = true
 moka = { workspace = true, features = ["future"] }
 parking_lot = "0.12"
 partition.workspace = true
+prometheus.workspace = true
 regex.workspace = true
 serde.workspace = true
 serde_json = "1.0"
-session = { workspace = true }
-snafu = { version = "0.7", features = ["backtraces"] }
-store-api = { workspace = true }
-table = { workspace = true }
+session.workspace = true
+snafu.workspace = true
+store-api.workspace = true
+table.workspace = true
 tokio.workspace = true
 
 [dev-dependencies]
 catalog = { workspace = true, features = ["testing"] }
 chrono.workspace = true
-common-test-util = { workspace = true }
-log-store = { workspace = true }
-object-store = { workspace = true }
-storage = { workspace = true }
+common-test-util.workspace = true
+log-store.workspace = true
+object-store.workspace = true
+storage.workspace = true
 tokio.workspace = true

src/catalog/src/kvbackend/client.rs

@@ -25,11 +25,10 @@ use common_meta::kv_backend::{KvBackend, KvBackendRef, TxnService};
 use common_meta::rpc::store::{
     BatchDeleteRequest, BatchDeleteResponse, BatchGetRequest, BatchGetResponse, BatchPutRequest,
     BatchPutResponse, CompareAndPutRequest, CompareAndPutResponse, DeleteRangeRequest,
-    DeleteRangeResponse, MoveValueRequest, MoveValueResponse, PutRequest, PutResponse,
-    RangeRequest, RangeResponse,
+    DeleteRangeResponse, PutRequest, PutResponse, RangeRequest, RangeResponse,
 };
 use common_meta::rpc::KeyValue;
-use common_telemetry::{debug, timer};
+use common_telemetry::debug;
 use meta_client::client::MetaClient;
 use moka::future::{Cache, CacheBuilder};
 use snafu::{OptionExt, ResultExt};
@@ -152,25 +151,11 @@ impl KvBackend for CachedMetaKvBackend {
         }
     }
 
-    async fn move_value(&self, req: MoveValueRequest) -> Result<MoveValueResponse> {
-        let from_key = &req.from_key.clone();
-        let to_key = &req.to_key.clone();
-
-        let ret = self.kv_backend.move_value(req).await;
-
-        if ret.is_ok() {
-            self.invalidate_key(from_key).await;
-            self.invalidate_key(to_key).await;
-        }
-
-        ret
-    }
-
     async fn get(&self, key: &[u8]) -> Result<Option<KeyValue>> {
-        let _timer = timer!(METRIC_CATALOG_KV_GET);
+        let _timer = METRIC_CATALOG_KV_GET.start_timer();
 
         let init = async {
-            let _timer = timer!(METRIC_CATALOG_KV_REMOTE_GET);
+            let _timer = METRIC_CATALOG_KV_REMOTE_GET.start_timer();
             self.kv_backend.get(key).await.map(|val| {
                 val.with_context(|| CacheNotGetSnafu {
                     key: String::from_utf8_lossy(key),
@@ -319,14 +304,6 @@ impl KvBackend for MetaKvBackend {
             .context(ExternalSnafu)
     }
 
-    async fn move_value(&self, req: MoveValueRequest) -> Result<MoveValueResponse> {
-        self.client
-            .move_value(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(ExternalSnafu)
-    }
-
     fn as_any(&self) -> &dyn Any {
         self
     }

src/catalog/src/memory/manager.rs

@@ -17,8 +17,8 @@ use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::sync::{Arc, RwLock, Weak};
 
+use common_catalog::build_db_string;
 use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, INFORMATION_SCHEMA_NAME};
-use metrics::{decrement_gauge, increment_gauge};
 use snafu::OptionExt;
 use table::TableRef;
 
@@ -166,7 +166,7 @@ impl MemoryCatalogManager {
                 let arc_self = Arc::new(self.clone());
                 let catalog = arc_self.create_catalog_entry(name);
                 e.insert(catalog);
-                increment_gauge!(crate::metrics::METRIC_CATALOG_MANAGER_CATALOG_COUNT, 1.0);
+                crate::metrics::METRIC_CATALOG_MANAGER_CATALOG_COUNT.inc();
                 Ok(true)
             }
             Entry::Occupied(_) => Ok(false),
@@ -187,11 +187,9 @@ impl MemoryCatalogManager {
             })?;
         let result = schema.remove(&request.table_name);
         if result.is_some() {
-            decrement_gauge!(
-                crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
-                1.0,
-                &[crate::metrics::db_label(&request.catalog, &request.schema)],
-            );
+            crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT
+                .with_label_values(&[build_db_string(&request.catalog, &request.schema).as_str()])
+                .dec();
         }
         Ok(())
     }
@@ -210,7 +208,7 @@ impl MemoryCatalogManager {
         match catalog.entry(request.schema) {
             Entry::Vacant(e) => {
                 e.insert(HashMap::new());
-                increment_gauge!(crate::metrics::METRIC_CATALOG_MANAGER_SCHEMA_COUNT, 1.0);
+                crate::metrics::METRIC_CATALOG_MANAGER_SCHEMA_COUNT.inc();
                 Ok(true)
             }
             Entry::Occupied(_) => Ok(false),
@@ -238,11 +236,9 @@ impl MemoryCatalogManager {
             .fail();
         }
         schema.insert(request.table_name, request.table);
-        increment_gauge!(
-            crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
-            1.0,
-            &[crate::metrics::db_label(&request.catalog, &request.schema)],
-        );
+        crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT
+            .with_label_values(&[build_db_string(&request.catalog, &request.schema).as_str()])
+            .inc();
         Ok(true)
     }
 

src/catalog/src/metrics.rs

@@ -12,18 +12,24 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use common_catalog::build_db_string;
-
 pub(crate) const METRIC_DB_LABEL: &str = "db";
 
-pub(crate) const METRIC_CATALOG_MANAGER_CATALOG_COUNT: &str = "catalog.catalog_count";
-pub(crate) const METRIC_CATALOG_MANAGER_SCHEMA_COUNT: &str = "catalog.schema_count";
-pub(crate) const METRIC_CATALOG_MANAGER_TABLE_COUNT: &str = "catalog.table_count";
+use lazy_static::lazy_static;
+use prometheus::*;
 
-pub(crate) const METRIC_CATALOG_KV_REMOTE_GET: &str = "catalog.kv.get.remote";
-pub(crate) const METRIC_CATALOG_KV_GET: &str = "catalog.kv.get";
-
-#[inline]
-pub(crate) fn db_label(catalog: &str, schema: &str) -> (&'static str, String) {
-    (METRIC_DB_LABEL, build_db_string(catalog, schema))
+lazy_static! {
+    pub static ref METRIC_CATALOG_MANAGER_CATALOG_COUNT: IntGauge =
+        register_int_gauge!("catalog_catalog_count", "catalog catalog count").unwrap();
+    pub static ref METRIC_CATALOG_MANAGER_SCHEMA_COUNT: IntGauge =
+        register_int_gauge!("catalog_schema_count", "catalog schema count").unwrap();
+    pub static ref METRIC_CATALOG_MANAGER_TABLE_COUNT: IntGaugeVec = register_int_gauge_vec!(
+        "catalog_table_count",
+        "catalog table count",
+        &[METRIC_DB_LABEL]
+    )
+    .unwrap();
+    pub static ref METRIC_CATALOG_KV_REMOTE_GET: Histogram =
+        register_histogram!("catalog_kv_get_remote", "catalog kv get remote").unwrap();
+    pub static ref METRIC_CATALOG_KV_GET: Histogram =
+        register_histogram!("catalog_kv_get", "catalog kv get").unwrap();
 }

src/client/Cargo.toml

@@ -8,44 +8,45 @@ license.workspace = true
 testing = []
 
 [dependencies]
-api = { workspace = true }
+api.workspace = true
 arrow-flight.workspace = true
 async-stream.workspace = true
 async-trait.workspace = true
-common-base = { workspace = true }
-common-catalog = { workspace = true }
-common-error = { workspace = true }
-common-grpc = { workspace = true }
-common-macro = { workspace = true }
-common-meta = { workspace = true }
-common-query = { workspace = true }
-common-recordbatch = { workspace = true }
-common-telemetry = { workspace = true }
-common-time = { workspace = true }
+common-base.workspace = true
+common-catalog.workspace = true
+common-error.workspace = true
+common-grpc.workspace = true
+common-macro.workspace = true
+common-meta.workspace = true
+common-query.workspace = true
+common-recordbatch.workspace = true
+common-telemetry.workspace = true
+common-time.workspace = true
 datafusion.workspace = true
-datatypes = { workspace = true }
+datatypes.workspace = true
 derive_builder.workspace = true
 enum_dispatch = "0.3"
 futures-util.workspace = true
+lazy_static.workspace = true
 moka = { workspace = true, features = ["future"] }
 parking_lot = "0.12"
+prometheus.workspace = true
 prost.workspace = true
 rand.workspace = true
-session = { workspace = true }
+session.workspace = true
 snafu.workspace = true
 tokio-stream = { version = "0.1", features = ["net"] }
 tokio.workspace = true
 tonic.workspace = true
 
 [dev-dependencies]
-common-grpc-expr = { workspace = true }
-datanode = { workspace = true }
+common-grpc-expr.workspace = true
+datanode.workspace = true
 derive-new = "0.5"
-prost.workspace = true
-substrait = { workspace = true }
+substrait.workspace = true
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
 [dev-dependencies.substrait_proto]
 package = "substrait"
-version = "0.7"
+version = "0.17"

src/client/src/database.rs

@@ -28,7 +28,7 @@ use common_grpc::flight::{FlightDecoder, FlightMessage};
 use common_query::Output;
 use common_recordbatch::error::ExternalSnafu;
 use common_recordbatch::RecordBatchStreamAdaptor;
-use common_telemetry::{logging, timer};
+use common_telemetry::logging;
 use futures_util::StreamExt;
 use prost::Message;
 use snafu::{ensure, ResultExt};
@@ -111,12 +111,12 @@ impl Database {
     }
 
     pub async fn insert(&self, requests: InsertRequests) -> Result<u32> {
-        let _timer = timer!(metrics::METRIC_GRPC_INSERT);
+        let _timer = metrics::METRIC_GRPC_INSERT.start_timer();
         self.handle(Request::Inserts(requests)).await
     }
 
     pub async fn row_insert(&self, requests: RowInsertRequests) -> Result<u32> {
-        let _timer = timer!(metrics::METRIC_GRPC_INSERT);
+        let _timer = metrics::METRIC_GRPC_INSERT.start_timer();
         self.handle(Request::RowInserts(requests)).await
     }
 
@@ -141,7 +141,7 @@ impl Database {
     }
 
     pub async fn delete(&self, request: DeleteRequests) -> Result<u32> {
-        let _timer = timer!(metrics::METRIC_GRPC_DELETE);
+        let _timer = metrics::METRIC_GRPC_DELETE.start_timer();
         self.handle(Request::Deletes(request)).await
     }
 
@@ -171,7 +171,7 @@ impl Database {
     where
         S: AsRef<str>,
     {
-        let _timer = timer!(metrics::METRIC_GRPC_SQL);
+        let _timer = metrics::METRIC_GRPC_SQL.start_timer();
         self.do_get(
             Request::Query(QueryRequest {
                 query: Some(Query::Sql(sql.as_ref().to_string())),
@@ -182,7 +182,7 @@ impl Database {
     }
 
     pub async fn logical_plan(&self, logical_plan: Vec<u8>, trace_id: u64) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_LOGICAL_PLAN);
+        let _timer = metrics::METRIC_GRPC_LOGICAL_PLAN.start_timer();
         self.do_get(
             Request::Query(QueryRequest {
                 query: Some(Query::LogicalPlan(logical_plan)),
@@ -199,7 +199,7 @@ impl Database {
         end: &str,
         step: &str,
     ) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_PROMQL_RANGE_QUERY);
+        let _timer = metrics::METRIC_GRPC_PROMQL_RANGE_QUERY.start_timer();
         self.do_get(
             Request::Query(QueryRequest {
                 query: Some(Query::PromRangeQuery(PromRangeQuery {
@@ -215,7 +215,7 @@ impl Database {
     }
 
     pub async fn create(&self, expr: CreateTableExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_CREATE_TABLE);
+        let _timer = metrics::METRIC_GRPC_CREATE_TABLE.start_timer();
         self.do_get(
             Request::Ddl(DdlRequest {
                 expr: Some(DdlExpr::CreateTable(expr)),
@@ -226,7 +226,7 @@ impl Database {
     }
 
     pub async fn alter(&self, expr: AlterExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_ALTER);
+        let _timer = metrics::METRIC_GRPC_ALTER.start_timer();
         self.do_get(
             Request::Ddl(DdlRequest {
                 expr: Some(DdlExpr::Alter(expr)),
@@ -237,7 +237,7 @@ impl Database {
     }
 
     pub async fn drop_table(&self, expr: DropTableExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_DROP_TABLE);
+        let _timer = metrics::METRIC_GRPC_DROP_TABLE.start_timer();
         self.do_get(
             Request::Ddl(DdlRequest {
                 expr: Some(DdlExpr::DropTable(expr)),
@@ -248,7 +248,7 @@ impl Database {
     }
 
     pub async fn truncate_table(&self, expr: TruncateTableExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_TRUNCATE_TABLE);
+        let _timer = metrics::METRIC_GRPC_TRUNCATE_TABLE.start_timer();
         self.do_get(
             Request::Ddl(DdlRequest {
                 expr: Some(DdlExpr::TruncateTable(expr)),
@@ -260,7 +260,7 @@ impl Database {
 
     async fn do_get(&self, request: Request, trace_id: u64) -> Result<Output> {
         // FIXME(paomian): should be added some labels for metrics
-        let _timer = timer!(metrics::METRIC_GRPC_DO_GET);
+        let _timer = metrics::METRIC_GRPC_DO_GET.start_timer();
         let request = self.to_rpc_request(request, trace_id);
         let request = Ticket {
             ticket: request.encode_to_vec().into(),

src/client/src/metrics.rs

@@ -12,15 +12,34 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! client metrics
-pub const METRIC_GRPC_CREATE_TABLE: &str = "grpc.create_table";
-pub const METRIC_GRPC_PROMQL_RANGE_QUERY: &str = "grpc.promql.range_query";
-pub const METRIC_GRPC_INSERT: &str = "grpc.insert";
-pub const METRIC_GRPC_DELETE: &str = "grpc.delete";
-pub const METRIC_GRPC_SQL: &str = "grpc.sql";
-pub const METRIC_GRPC_LOGICAL_PLAN: &str = "grpc.logical_plan";
-pub const METRIC_GRPC_ALTER: &str = "grpc.alter";
-pub const METRIC_GRPC_DROP_TABLE: &str = "grpc.drop_table";
-pub const METRIC_GRPC_TRUNCATE_TABLE: &str = "grpc.truncate_table";
-pub const METRIC_GRPC_DO_GET: &str = "grpc.do_get";
-pub(crate) const METRIC_REGION_REQUEST_GRPC: &str = "grpc.region_request";
+use lazy_static::lazy_static;
+use prometheus::*;
+
+lazy_static! {
+    pub static ref METRIC_GRPC_CREATE_TABLE: Histogram =
+        register_histogram!("grpc_create_table", "grpc create table").unwrap();
+    pub static ref METRIC_GRPC_PROMQL_RANGE_QUERY: Histogram =
+        register_histogram!("grpc_promql_range_query", "grpc promql range query").unwrap();
+    pub static ref METRIC_GRPC_INSERT: Histogram =
+        register_histogram!("grpc_insert", "grpc insert").unwrap();
+    pub static ref METRIC_GRPC_DELETE: Histogram =
+        register_histogram!("grpc_delete", "grpc delete").unwrap();
+    pub static ref METRIC_GRPC_SQL: Histogram =
+        register_histogram!("grpc_sql", "grpc sql").unwrap();
+    pub static ref METRIC_GRPC_LOGICAL_PLAN: Histogram =
+        register_histogram!("grpc_logical_plan", "grpc logical plan").unwrap();
+    pub static ref METRIC_GRPC_ALTER: Histogram =
+        register_histogram!("grpc_alter", "grpc alter").unwrap();
+    pub static ref METRIC_GRPC_DROP_TABLE: Histogram =
+        register_histogram!("grpc_drop_table", "grpc drop table").unwrap();
+    pub static ref METRIC_GRPC_TRUNCATE_TABLE: Histogram =
+        register_histogram!("grpc_truncate_table", "grpc truncate table").unwrap();
+    pub static ref METRIC_GRPC_DO_GET: Histogram =
+        register_histogram!("grpc_do_get", "grpc do get").unwrap();
+    pub static ref METRIC_REGION_REQUEST_GRPC: HistogramVec = register_histogram_vec!(
+        "grpc_region_request",
+        "grpc region request",
+        &["request_type"]
+    )
+    .unwrap();
+}

src/client/src/region.rs

@@ -24,7 +24,7 @@ use common_meta::datanode_manager::{AffectedRows, Datanode};
 use common_meta::error::{self as meta_error, Result as MetaResult};
 use common_recordbatch::error::ExternalSnafu;
 use common_recordbatch::{RecordBatchStreamAdaptor, SendableRecordBatchStream};
-use common_telemetry::{error, timer};
+use common_telemetry::error;
 use prost::Message;
 use snafu::{location, Location, OptionExt, ResultExt};
 use tokio_stream::StreamExt;
@@ -152,11 +152,9 @@ impl RegionRequester {
             .with_context(|| MissingFieldSnafu { field: "body" })?
             .as_ref()
             .to_string();
-
-        let _timer = timer!(
-            metrics::METRIC_REGION_REQUEST_GRPC,
-            &[("request_type", request_type)]
-        );
+        let _timer = metrics::METRIC_REGION_REQUEST_GRPC
+            .with_label_values(&[request_type.as_str()])
+            .start_timer();
 
         let mut client = self.client.raw_region_client()?;
 

src/cmd/Cargo.toml

@@ -10,71 +10,69 @@ name = "greptime"
 path = "src/bin/greptime.rs"
 
 [features]
-default = ["metrics-process"]
 tokio-console = ["common-telemetry/tokio-console"]
-metrics-process = ["servers/metrics-process"]
 
 [dependencies]
 anymap = "1.0.0-beta.2"
 async-trait.workspace = true
 auth.workspace = true
-catalog = { workspace = true }
+catalog.workspace = true
 chrono.workspace = true
 clap = { version = "3.1", features = ["derive"] }
-client = { workspace = true }
-common-base = { workspace = true }
-common-catalog = { workspace = true }
-common-config = { workspace = true }
-common-error = { workspace = true }
-common-macro = { workspace = true }
-common-meta = { workspace = true }
-common-procedure = { workspace = true }
-common-query = { workspace = true }
-common-recordbatch = { workspace = true }
+client.workspace = true
+common-base.workspace = true
+common-catalog.workspace = true
+common-config.workspace = true
+common-error.workspace = true
+common-macro.workspace = true
+common-meta.workspace = true
+common-procedure.workspace = true
+common-query.workspace = true
+common-recordbatch.workspace = true
 common-telemetry = { workspace = true, features = [
     "deadlock_detection",
 ] }
 config = "0.13"
-datanode = { workspace = true }
-datatypes = { workspace = true }
+datanode.workspace = true
+datatypes.workspace = true
 either = "1.8"
 etcd-client.workspace = true
-file-engine = { workspace = true }
-frontend = { workspace = true }
+file-engine.workspace = true
+frontend.workspace = true
 futures.workspace = true
 lazy_static.workspace = true
-meta-client = { workspace = true }
-meta-srv = { workspace = true }
-metrics.workspace = true
-mito2 = { workspace = true }
+meta-client.workspace = true
+meta-srv.workspace = true
+mito2.workspace = true
 nu-ansi-term = "0.46"
-partition = { workspace = true }
+partition.workspace = true
 plugins.workspace = true
+prometheus.workspace = true
 prost.workspace = true
-query = { workspace = true }
+query.workspace = true
 rand.workspace = true
 regex.workspace = true
 rustyline = "10.1"
 serde.workspace = true
 serde_json.workspace = true
-servers = { workspace = true }
-session = { workspace = true }
+servers.workspace = true
+session.workspace = true
 snafu.workspace = true
-substrait = { workspace = true }
-table = { workspace = true }
+substrait.workspace = true
+table.workspace = true
 tokio.workspace = true
+toml.workspace = true
 
 [target.'cfg(not(windows))'.dependencies]
 tikv-jemallocator = "0.5"
 
 [dev-dependencies]
-common-test-util = { workspace = true }
+common-test-util.workspace = true
 serde.workspace = true
 temp-env = "0.3"
-toml.workspace = true
 
 [target.'cfg(not(windows))'.dev-dependencies]
 rexpect = "0.5"
 
 [build-dependencies]
-common-version = { workspace = true }
+common-version.workspace = true

src/cmd/src/bin/greptime.rs

@@ -21,7 +21,11 @@ use cmd::error::Result;
 use cmd::options::{Options, TopLevelOptions};
 use cmd::{cli, datanode, frontend, metasrv, standalone};
 use common_telemetry::logging::{error, info, TracingOptions};
-use metrics::gauge;
+
+lazy_static::lazy_static! {
+    static ref APP_VERSION: prometheus::IntGaugeVec =
+        prometheus::register_int_gauge_vec!("app_version", "app version", &["short_version", "version"]).unwrap();
+}
 
 #[derive(Parser)]
 #[clap(name = "greptimedb", version = print_version())]
@@ -204,11 +208,12 @@ async fn main() -> Result<()> {
     };
 
     common_telemetry::set_panic_hook();
-    common_telemetry::init_default_metrics_recorder();
     let _guard = common_telemetry::init_global_logging(app_name, logging_opts, tracing_opts);
 
     // Report app version as gauge.
-    gauge!("app_version", 1.0, "short_version" => short_version(), "version" => full_version());
+    APP_VERSION
+        .with_label_values(&[short_version(), full_version()])
+        .inc();
 
     // Log version and argument flags.
     info!(

src/cmd/src/cli/bench.rs

@@ -20,14 +20,13 @@ use std::time::Duration;
 use async_trait::async_trait;
 use clap::Parser;
 use common_meta::key::{TableMetadataManager, TableMetadataManagerRef};
+use common_meta::kv_backend::etcd::EtcdStore;
 use common_meta::peer::Peer;
 use common_meta::rpc::router::{Region, RegionRoute};
 use common_meta::table_name::TableName;
 use common_telemetry::info;
 use datatypes::data_type::ConcreteDataType;
 use datatypes::schema::{ColumnSchema, RawSchema};
-use meta_srv::service::store::etcd::EtcdStore;
-use meta_srv::service::store::kv::KvBackendAdapter;
 use rand::Rng;
 use table::metadata::{RawTableInfo, RawTableMeta, TableId, TableIdent, TableType};
 
@@ -64,9 +63,7 @@ impl BenchTableMetadataCommand {
     pub async fn build(&self) -> Result<Instance> {
         let etcd_store = EtcdStore::with_endpoints([&self.etcd_addr]).await.unwrap();
 
-        let table_metadata_manager = Arc::new(TableMetadataManager::new(KvBackendAdapter::wrap(
-            etcd_store,
-        )));
+        let table_metadata_manager = Arc::new(TableMetadataManager::new(etcd_store));
 
         let tool = BenchTableMetadata {
             table_metadata_manager,
@@ -157,6 +154,7 @@ fn create_region_routes() -> Vec<RegionRoute> {
                 addr: String::new(),
             }),
             follower_peers: vec![],
+            leader_status: None,
         });
     }
 

src/cmd/src/cli/export.rs

@@ -17,6 +17,8 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use clap::{Parser, ValueEnum};
+use client::api::v1::auth_header::AuthScheme;
+use client::api::v1::Basic;
 use client::{Client, Database, DEFAULT_SCHEMA_NAME};
 use common_query::Output;
 use common_recordbatch::util::collect;
@@ -25,13 +27,14 @@ use datatypes::scalars::ScalarVector;
 use datatypes::vectors::{StringVector, Vector};
 use snafu::{OptionExt, ResultExt};
 use tokio::fs::File;
-use tokio::io::AsyncWriteExt;
+use tokio::io::{AsyncWriteExt, BufWriter};
 use tokio::sync::Semaphore;
 
 use crate::cli::{Instance, Tool};
 use crate::error::{
     CollectRecordBatchesSnafu, ConnectServerSnafu, EmptyResultSnafu, Error, FileIoSnafu,
-    InvalidDatabaseNameSnafu, NotDataFromOutputSnafu, RequestDatabaseSnafu, Result,
+    IllegalConfigSnafu, InvalidDatabaseNameSnafu, NotDataFromOutputSnafu, RequestDatabaseSnafu,
+    Result,
 };
 
 type TableReference = (String, String, String);
@@ -70,6 +73,10 @@ pub struct ExportCommand {
     /// Things to export
     #[clap(long, short = 't', value_enum)]
     target: ExportTarget,
+
+    /// basic authentication for connecting to the server
+    #[clap(long)]
+    auth_basic: Option<String>,
 }
 
 impl ExportCommand {
@@ -82,12 +89,22 @@ impl ExportCommand {
                 addr: self.addr.clone(),
             })?;
         let (catalog, schema) = split_database(&self.database)?;
-        let database_client = Database::new(
+        let mut database_client = Database::new(
             catalog.clone(),
             schema.clone().unwrap_or(DEFAULT_SCHEMA_NAME.to_string()),
             client,
         );
 
+        if let Some(auth_basic) = &self.auth_basic {
+            let (username, password) = auth_basic.split_once(':').context(IllegalConfigSnafu {
+                msg: "auth_basic cannot be split by ':'".to_string(),
+            })?;
+            database_client.set_auth(AuthScheme::Basic(Basic {
+                username: username.to_string(),
+                password: password.to_string(),
+            }));
+        }
+
         Ok(Instance::Tool(Box::new(Export {
             client: database_client,
             catalog,
@@ -141,6 +158,9 @@ impl Export {
             let mut result = Vec::with_capacity(schemas.len());
             for i in 0..schemas.len() {
                 let schema = schemas.get_data(i).unwrap().to_owned();
+                if schema == common_catalog::consts::INFORMATION_SCHEMA_NAME {
+                    continue;
+                }
                 result.push((self.catalog.clone(), schema));
             }
             Ok(result)
@@ -326,25 +346,30 @@ impl Export {
 
                 let copy_from_file =
                     Path::new(&self.output_dir).join(format!("{catalog}-{schema}_copy_from.sql"));
-                let mut file = File::create(copy_from_file).await.context(FileIoSnafu)?;
+                let mut writer =
+                    BufWriter::new(File::create(copy_from_file).await.context(FileIoSnafu)?);
 
-                let copy_from_sql = dir_filenames
-                    .into_iter()
-                    .map(|file| {
-                        let file = file.unwrap();
-                        let filename = file.file_name().into_string().unwrap();
+                for table_file in dir_filenames {
+                    let table_file = table_file.unwrap();
+                    let table_name = table_file
+                        .file_name()
+                        .into_string()
+                        .unwrap()
+                        .replace(".parquet", "");
 
-                        format!(
-                            "copy {} from '{}' with (format='parquet');\n",
-                            filename.replace(".parquet", ""),
-                            file.path().to_str().unwrap()
+                    writer
+                        .write(
+                            format!(
+                                "copy {} from '{}' with (format='parquet');\n",
+                                table_name,
+                                table_file.path().to_str().unwrap()
+                            )
+                            .as_bytes(),
                         )
-                    })
-                    .collect::<Vec<_>>()
-                    .join("");
-                file.write_all(copy_from_sql.as_bytes())
-                    .await
-                    .context(FileIoSnafu)?;
+                        .await
+                        .context(FileIoSnafu)?;
+                }
+                writer.flush().await.context(FileIoSnafu)?;
 
                 info!("finished exporting {catalog}.{schema} copy_from.sql");
 

src/cmd/src/cli/upgrade.rs

@@ -27,6 +27,8 @@ use common_meta::key::table_name::{TableNameKey, TableNameValue};
 use common_meta::key::table_region::{TableRegionKey, TableRegionValue};
 use common_meta::key::table_route::{TableRouteKey, TableRouteValue as NextTableRouteValue};
 use common_meta::key::{RegionDistribution, TableMetaKey};
+use common_meta::kv_backend::etcd::EtcdStore;
+use common_meta::kv_backend::KvBackendRef;
 use common_meta::range_stream::PaginationStream;
 use common_meta::rpc::router::TableRoute;
 use common_meta::rpc::store::{BatchDeleteRequest, BatchPutRequest, PutRequest, RangeRequest};
@@ -35,8 +37,6 @@ use common_meta::util::get_prefix_end_key;
 use common_telemetry::info;
 use etcd_client::Client;
 use futures::TryStreamExt;
-use meta_srv::service::store::etcd::EtcdStore;
-use meta_srv::service::store::kv::{KvBackendAdapter, KvStoreRef};
 use prost::Message;
 use snafu::ResultExt;
 use v1_helper::{CatalogKey as v1CatalogKey, SchemaKey as v1SchemaKey, TableGlobalValue};
@@ -81,7 +81,7 @@ impl UpgradeCommand {
 }
 
 struct MigrateTableMetadata {
-    etcd_store: KvStoreRef,
+    etcd_store: KvBackendRef,
     dryrun: bool,
 
     skip_table_global_keys: bool,
@@ -123,7 +123,7 @@ impl MigrateTableMetadata {
         info!("Start scanning key from: {}", String::from_utf8_lossy(&key));
 
         let mut stream = PaginationStream::new(
-            KvBackendAdapter::wrap(self.etcd_store.clone()),
+            self.etcd_store.clone(),
             RangeRequest::new().with_range(key, range_end),
             PAGE_SIZE,
             Arc::new(|kv: KeyValue| {
@@ -182,7 +182,7 @@ impl MigrateTableMetadata {
         let mut keys = Vec::new();
         info!("Start scanning key from: {}", String::from_utf8_lossy(&key));
         let mut stream = PaginationStream::new(
-            KvBackendAdapter::wrap(self.etcd_store.clone()),
+            self.etcd_store.clone(),
             RangeRequest::new().with_range(key, range_end),
             PAGE_SIZE,
             Arc::new(|kv: KeyValue| {
@@ -234,7 +234,7 @@ impl MigrateTableMetadata {
         let mut keys = Vec::new();
         info!("Start scanning key from: {}", String::from_utf8_lossy(&key));
         let mut stream = PaginationStream::new(
-            KvBackendAdapter::wrap(self.etcd_store.clone()),
+            self.etcd_store.clone(),
             RangeRequest::new().with_range(key, range_end),
             PAGE_SIZE,
             Arc::new(|kv: KeyValue| {
@@ -284,7 +284,7 @@ impl MigrateTableMetadata {
 
         info!("Start scanning key from: {}", String::from_utf8_lossy(&key));
         let mut stream = PaginationStream::new(
-            KvBackendAdapter::wrap(self.etcd_store.clone()),
+            self.etcd_store.clone(),
             RangeRequest::new().with_range(key, range_end.clone()),
             PAGE_SIZE,
             Arc::new(|kv: KeyValue| {

src/cmd/src/datanode.rs

@@ -191,7 +191,6 @@ mod tests {
     use std::io::Write;
     use std::time::Duration;
 
-    use common_base::readable_size::ReadableSize;
     use common_test_util::temp_dir::create_named_temp_file;
     use datanode::config::{CompactionConfig, FileConfig, ObjectStoreConfig, RegionManifestConfig};
     use servers::heartbeat_options::HeartbeatOptions;
@@ -300,7 +299,6 @@ mod tests {
                 max_inflight_tasks: 3,
                 max_files_in_level0: 7,
                 max_purge_tasks: 32,
-                sst_write_buffer_size: ReadableSize::mb(8),
             },
             options.storage.compaction,
         );

src/cmd/src/frontend.rs

@@ -188,6 +188,7 @@ impl StartCommand {
     }
 
     async fn build(self, mut opts: FrontendOptions) -> Result<Instance> {
+        #[allow(clippy::unnecessary_mut_passed)]
         let plugins = plugins::setup_frontend_plugins(&mut opts)
             .await
             .context(StartFrontendSnafu)?;
@@ -200,7 +201,7 @@ impl StartCommand {
             .context(StartFrontendSnafu)?;
 
         instance
-            .build_servers(&opts)
+            .build_servers(opts)
             .await
             .context(StartFrontendSnafu)?;
 
@@ -312,6 +313,7 @@ mod tests {
             ..Default::default()
         };
 
+        #[allow(clippy::unnecessary_mut_passed)]
         let plugins = plugins::setup_frontend_plugins(&mut fe_opts).await.unwrap();
 
         let provider = plugins.get::<UserProviderRef>().unwrap();

src/cmd/src/metasrv.rs

@@ -216,6 +216,12 @@ mod tests {
             [logging]
             level = "debug"
             dir = "/tmp/greptimedb/test/logs"
+            
+            [failure_detector]
+            threshold = 8.0
+            min_std_deviation = "100ms"
+            acceptable_heartbeat_pause = "3000ms"
+            first_heartbeat_estimate = "1000ms"
         "#;
         write!(file, "{}", toml_str).unwrap();
 
@@ -234,6 +240,25 @@ mod tests {
         assert_eq!(SelectorType::LeaseBased, options.selector);
         assert_eq!("debug", options.logging.level.as_ref().unwrap());
         assert_eq!("/tmp/greptimedb/test/logs".to_string(), options.logging.dir);
+        assert_eq!(8.0, options.failure_detector.threshold);
+        assert_eq!(
+            100.0,
+            options.failure_detector.min_std_deviation.as_millis() as f32
+        );
+        assert_eq!(
+            3000,
+            options
+                .failure_detector
+                .acceptable_heartbeat_pause
+                .as_millis()
+        );
+        assert_eq!(
+            1000,
+            options
+                .failure_detector
+                .first_heartbeat_estimate
+                .as_millis()
+        );
     }
 
     #[test]

src/cmd/src/options.rs

@@ -12,11 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use common_config::KvStoreConfig;
+use common_config::KvBackendConfig;
 use common_telemetry::logging::LoggingOptions;
 use config::{Config, Environment, File, FileFormat};
 use datanode::config::{DatanodeOptions, ProcedureConfig};
-use frontend::frontend::FrontendOptions;
+use frontend::error::{Result as FeResult, TomlFormatSnafu};
+use frontend::frontend::{FrontendOptions, TomlSerializable};
 use meta_srv::metasrv::MetaSrvOptions;
 use serde::{Deserialize, Serialize};
 use snafu::ResultExt;
@@ -27,15 +28,28 @@ pub const ENV_VAR_SEP: &str = "__";
 pub const ENV_LIST_SEP: &str = ",";
 
 /// Options mixed up from datanode, frontend and metasrv.
+#[derive(Serialize)]
 pub struct MixOptions {
     pub data_home: String,
     pub procedure: ProcedureConfig,
-    pub metadata_store: KvStoreConfig,
+    pub metadata_store: KvBackendConfig,
     pub frontend: FrontendOptions,
     pub datanode: DatanodeOptions,
     pub logging: LoggingOptions,
 }
 
+impl From<MixOptions> for FrontendOptions {
+    fn from(value: MixOptions) -> Self {
+        value.frontend
+    }
+}
+
+impl TomlSerializable for MixOptions {
+    fn to_toml(&self) -> FeResult<String> {
+        toml::to_string(self).context(TomlFormatSnafu)
+    }
+}
+
 pub enum Options {
     Datanode(Box<DatanodeOptions>),
     Frontend(Box<FrontendOptions>),

src/cmd/src/standalone.rs

@@ -19,7 +19,7 @@ use catalog::kvbackend::KvBackendCatalogManager;
 use catalog::CatalogManagerRef;
 use clap::Parser;
 use common_base::Plugins;
-use common_config::{metadata_store_dir, KvStoreConfig, WalConfig};
+use common_config::{metadata_store_dir, KvBackendConfig, WalConfig};
 use common_meta::cache_invalidator::DummyKvCacheInvalidator;
 use common_meta::kv_backend::KvBackendRef;
 use common_procedure::ProcedureManagerRef;
@@ -97,7 +97,7 @@ pub struct StandaloneOptions {
     pub prom_store: PromStoreOptions,
     pub wal: WalConfig,
     pub storage: StorageConfig,
-    pub metadata_store: KvStoreConfig,
+    pub metadata_store: KvBackendConfig,
     pub procedure: ProcedureConfig,
     pub logging: LoggingOptions,
     pub user_provider: Option<String>,
@@ -119,7 +119,7 @@ impl Default for StandaloneOptions {
             prom_store: PromStoreOptions::default(),
             wal: WalConfig::default(),
             storage: StorageConfig::default(),
-            metadata_store: KvStoreConfig::default(),
+            metadata_store: KvBackendConfig::default(),
             procedure: ProcedureConfig::default(),
             logging: LoggingOptions::default(),
             user_provider: None,
@@ -316,12 +316,13 @@ impl StartCommand {
     #[allow(unused_variables)]
     #[allow(clippy::diverging_sub_expression)]
     async fn build(self, opts: MixOptions) -> Result<Instance> {
-        let mut fe_opts = opts.frontend;
-        let fe_plugins = plugins::setup_frontend_plugins(&mut fe_opts)
+        let mut fe_opts = opts.frontend.clone();
+        #[allow(clippy::unnecessary_mut_passed)]
+        let fe_plugins = plugins::setup_frontend_plugins(&mut fe_opts) // mut ref is MUST, DO NOT change it
             .await
             .context(StartFrontendSnafu)?;
 
-        let dn_opts = opts.datanode;
+        let dn_opts = opts.datanode.clone();
 
         info!("Standalone start command: {:#?}", self);
         info!(
@@ -335,23 +336,26 @@ impl StartCommand {
         })?;
 
         let metadata_dir = metadata_store_dir(&opts.data_home);
-        let (kv_store, procedure_manager) = FeInstance::try_build_standalone_components(
+        let (kv_backend, procedure_manager) = FeInstance::try_build_standalone_components(
             metadata_dir,
-            opts.metadata_store,
-            opts.procedure,
+            opts.metadata_store.clone(),
+            opts.procedure.clone(),
         )
         .await
         .context(StartFrontendSnafu)?;
 
-        let datanode =
-            DatanodeBuilder::new(dn_opts.clone(), Some(kv_store.clone()), Default::default())
-                .build()
-                .await
-                .context(StartDatanodeSnafu)?;
+        let datanode = DatanodeBuilder::new(
+            dn_opts.clone(),
+            Some(kv_backend.clone()),
+            Default::default(),
+        )
+        .build()
+        .await
+        .context(StartDatanodeSnafu)?;
         let region_server = datanode.region_server();
 
         let catalog_manager = KvBackendCatalogManager::new(
-            kv_store.clone(),
+            kv_backend.clone(),
             Arc::new(DummyKvCacheInvalidator),
             Arc::new(StandaloneDatanodeManager(region_server.clone())),
         );
@@ -365,7 +369,7 @@ impl StartCommand {
         // TODO: build frontend instance like in distributed mode
         let mut frontend = build_frontend(
             fe_plugins,
-            kv_store,
+            kv_backend,
             procedure_manager.clone(),
             catalog_manager,
             region_server,
@@ -373,7 +377,7 @@ impl StartCommand {
         .await?;
 
         frontend
-            .build_servers(&fe_opts)
+            .build_servers(opts)
             .await
             .context(StartFrontendSnafu)?;
 
@@ -388,13 +392,13 @@ impl StartCommand {
 /// Build frontend instance in standalone mode
 async fn build_frontend(
     plugins: Plugins,
-    kv_store: KvBackendRef,
+    kv_backend: KvBackendRef,
     procedure_manager: ProcedureManagerRef,
     catalog_manager: CatalogManagerRef,
     region_server: RegionServer,
 ) -> Result<FeInstance> {
     let frontend_instance = FeInstance::try_new_standalone(
-        kv_store,
+        kv_backend,
         procedure_manager,
         catalog_manager,
         plugins,
@@ -426,6 +430,7 @@ mod tests {
             ..Default::default()
         };
 
+        #[allow(clippy::unnecessary_mut_passed)]
         let plugins = plugins::setup_frontend_plugins(&mut fe_opts).await.unwrap();
 
         let provider = plugins.get::<UserProviderRef>().unwrap();

src/common/base/Cargo.toml

@@ -8,8 +8,8 @@ license.workspace = true
 anymap = "1.0.0-beta.2"
 bitvec = "1.0"
 bytes = { version = "1.1", features = ["serde"] }
-common-error = { workspace = true }
-common-macro = { workspace = true }
+common-error.workspace = true
+common-macro.workspace = true
 paste = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 snafu.workspace = true

src/common/catalog/Cargo.toml

@@ -5,11 +5,9 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-common-error = { workspace = true }
-common-macro = { workspace = true }
-serde.workspace = true
-serde_json = "1.0"
-snafu = { version = "0.7", features = ["backtraces"] }
+common-error.workspace = true
+common-macro.workspace = true
+snafu.workspace = true
 
 [dev-dependencies]
 chrono.workspace = true

src/common/config/src/lib.rs

@@ -54,14 +54,14 @@ pub fn metadata_store_dir(store_dir: &str) -> String {
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(default)]
-pub struct KvStoreConfig {
+pub struct KvBackendConfig {
     // Kv file size in bytes
     pub file_size: ReadableSize,
     // Kv purge threshold in bytes
     pub purge_threshold: ReadableSize,
 }
 
-impl Default for KvStoreConfig {
+impl Default for KvBackendConfig {
     fn default() -> Self {
         Self {
             // log file size 256MB

src/common/datasource/Cargo.toml

@@ -17,14 +17,14 @@ async-compression = { version = "0.3", features = [
 ] }
 async-trait.workspace = true
 bytes = "1.1"
-common-error = { workspace = true }
-common-macro = { workspace = true }
-common-runtime = { workspace = true }
+common-error.workspace = true
+common-macro.workspace = true
+common-runtime.workspace = true
 datafusion.workspace = true
 derive_builder.workspace = true
 futures.workspace = true
 lazy_static.workspace = true
-object-store = { workspace = true }
+object-store.workspace = true
 orc-rust = "0.2"
 paste = "1.0"
 regex = "1.7"
@@ -36,4 +36,4 @@ tokio.workspace = true
 url = "2.3"
 
 [dev-dependencies]
-common-test-util = { workspace = true }
+common-test-util.workspace = true

src/common/datasource/tests/orc/write.py

@@ -4,7 +4,7 @@
 # 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
+#     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,

src/common/decimal/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "decimal"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+arrow.workspace = true
+bigdecimal.workspace = true
+common-error.workspace = true
+common-macro.workspace = true
+rust_decimal.workspace = true
+serde.workspace = true
+serde_json = "1.0"
+snafu.workspace = true

src/common/decimal/src/decimal128.rs

@@ -0,0 +1,394 @@
+// 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::fmt::Display;
+use std::hash::Hash;
+use std::str::FromStr;
+
+use bigdecimal::{BigDecimal, ToPrimitive};
+use rust_decimal::Decimal as RustDecimal;
+use serde::{Deserialize, Serialize};
+use snafu::ResultExt;
+
+use crate::error::{
+    self, BigDecimalOutOfRangeSnafu, Error, InvalidPrecisionOrScaleSnafu, ParseBigDecimalStrSnafu,
+    ParseRustDecimalStrSnafu,
+};
+
+/// The maximum precision for [Decimal128] values
+pub const DECIMAL128_MAX_PRECISION: u8 = 38;
+
+/// The maximum scale for [Decimal128] values
+pub const DECIMAL128_MAX_SCALE: i8 = 38;
+
+/// The default scale for [Decimal128] values
+pub const DECIMAL128_DEFAULT_SCALE: i8 = 10;
+
+/// The maximum bytes length that an accurate RustDecimal can represent
+const BYTES_TO_OVERFLOW_RUST_DECIMAL: usize = 28;
+
+/// 128bit decimal, using the i128 to represent the decimal.
+///
+/// **precision**: the total number of digits in the number, it's range is \[1, 38\].
+///
+/// **scale**: the number of digits to the right of the decimal point, it's range is \[0, precision\].
+#[derive(Debug, Default, Eq, Copy, Clone, Serialize, Deserialize)]
+pub struct Decimal128 {
+    value: i128,
+    precision: u8,
+    scale: i8,
+}
+
+impl Decimal128 {
+    /// Create a new Decimal128 from i128, precision and scale.
+    pub fn new_unchecked(value: i128, precision: u8, scale: i8) -> Self {
+        Self {
+            value,
+            precision,
+            scale,
+        }
+    }
+
+    pub fn try_new(value: i128, precision: u8, scale: i8) -> error::Result<Self> {
+        // make sure the precision and scale is valid.
+        valid_precision_and_scale(precision, scale)?;
+        Ok(Self {
+            value,
+            precision,
+            scale,
+        })
+    }
+
+    pub fn val(&self) -> i128 {
+        self.value
+    }
+
+    /// Returns the precision of this decimal.
+    pub fn precision(&self) -> u8 {
+        self.precision
+    }
+
+    /// Returns the scale of this decimal.
+    pub fn scale(&self) -> i8 {
+        self.scale
+    }
+
+    /// Convert to ScalarValue
+    pub fn to_scalar_value(&self) -> (Option<i128>, u8, i8) {
+        (Some(self.value), self.precision, self.scale)
+    }
+}
+
+impl PartialEq for Decimal128 {
+    fn eq(&self, other: &Self) -> bool {
+        self.precision.eq(&other.precision)
+            && self.scale.eq(&other.scale)
+            && self.value.eq(&other.value)
+    }
+}
+
+// Two decimal values can be compared if they have the same precision and scale.
+impl PartialOrd for Decimal128 {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        if self.precision == other.precision && self.scale == other.scale {
+            return self.value.partial_cmp(&other.value);
+        }
+        None
+    }
+}
+
+/// Convert from string to Decimal128
+/// If the string length is less than 28, the result of rust_decimal will underflow,
+/// In this case, use BigDecimal to get accurate result.
+impl FromStr for Decimal128 {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let len = s.as_bytes().len();
+        if len <= BYTES_TO_OVERFLOW_RUST_DECIMAL {
+            let rd = RustDecimal::from_str_exact(s).context(ParseRustDecimalStrSnafu { raw: s })?;
+            Ok(Self::from(rd))
+        } else {
+            let bd = BigDecimal::from_str(s).context(ParseBigDecimalStrSnafu { raw: s })?;
+            Self::try_from(bd)
+        }
+    }
+}
+
+impl Display for Decimal128 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            format_decimal_str(&self.value.to_string(), self.precision as usize, self.scale)
+        )
+    }
+}
+
+impl Hash for Decimal128 {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        state.write_i128(self.value);
+        state.write_u8(self.precision);
+        state.write_i8(self.scale);
+    }
+}
+
+impl From<Decimal128> for serde_json::Value {
+    fn from(decimal: Decimal128) -> Self {
+        serde_json::Value::String(decimal.to_string())
+    }
+}
+
+impl From<Decimal128> for i128 {
+    fn from(decimal: Decimal128) -> Self {
+        decimal.val()
+    }
+}
+
+impl From<i128> for Decimal128 {
+    fn from(value: i128) -> Self {
+        Self {
+            value,
+            precision: DECIMAL128_MAX_PRECISION,
+            scale: DECIMAL128_DEFAULT_SCALE,
+        }
+    }
+}
+
+/// Convert from RustDecimal to Decimal128
+/// RustDecimal can represent the range is smaller than Decimal128,
+/// it is safe to convert RustDecimal to Decimal128
+impl From<RustDecimal> for Decimal128 {
+    fn from(rd: RustDecimal) -> Self {
+        let s = rd.to_string();
+        let precision = (s.len() - s.matches(&['.', '-'][..]).count()) as u8;
+        Self {
+            value: rd.mantissa(),
+            precision,
+            scale: rd.scale() as i8,
+        }
+    }
+}
+
+/// Try from BigDecimal to Decimal128
+/// The range that BigDecimal can represent is larger than Decimal128,
+/// so it is not safe to convert BigDecimal to Decimal128,
+/// If the BigDecimal is out of range, return error.
+impl TryFrom<BigDecimal> for Decimal128 {
+    type Error = Error;
+
+    fn try_from(value: BigDecimal) -> Result<Self, Self::Error> {
+        let precision = value.digits();
+        let (big_int, scale) = value.as_bigint_and_exponent();
+        // convert big_int to i128, if convert failed, return error
+        big_int
+            .to_i128()
+            .map(|val| Self::try_new(val, precision as u8, scale as i8))
+            .unwrap_or_else(|| BigDecimalOutOfRangeSnafu { value }.fail())
+    }
+}
+
+/// Port from arrow-rs,
+/// see https://github.com/Apache/arrow-rs/blob/master/arrow-array/src/types.rs#L1323-L1344
+fn format_decimal_str(value_str: &str, precision: usize, scale: i8) -> String {
+    let (sign, rest) = match value_str.strip_prefix('-') {
+        Some(stripped) => ("-", stripped),
+        None => ("", value_str),
+    };
+
+    let bound = precision.min(rest.len()) + sign.len();
+    let value_str = &value_str[0..bound];
+
+    if scale == 0 {
+        value_str.to_string()
+    } else if scale < 0 {
+        let padding = value_str.len() + scale.unsigned_abs() as usize;
+        format!("{value_str:0<padding$}")
+    } else if rest.len() > scale as usize {
+        // Decimal separator is in the middle of the string
+        let (whole, decimal) = value_str.split_at(value_str.len() - scale as usize);
+        format!("{whole}.{decimal}")
+    } else {
+        // String has to be padded
+        format!("{}0.{:0>width$}", sign, rest, width = scale as usize)
+    }
+}
+
+/// check whether precision and scale is valid
+fn valid_precision_and_scale(precision: u8, scale: i8) -> error::Result<()> {
+    if precision == 0 {
+        return InvalidPrecisionOrScaleSnafu {
+            reason: format!(
+                "precision cannot be 0, has to be between [1, {}]",
+                DECIMAL128_MAX_PRECISION
+            ),
+        }
+        .fail();
+    }
+    if precision > DECIMAL128_MAX_PRECISION {
+        return InvalidPrecisionOrScaleSnafu {
+            reason: format!(
+                "precision {} is greater than max {}",
+                precision, DECIMAL128_MAX_PRECISION
+            ),
+        }
+        .fail();
+    }
+    if scale > DECIMAL128_MAX_SCALE {
+        return InvalidPrecisionOrScaleSnafu {
+            reason: format!(
+                "scale {} is greater than max {}",
+                scale, DECIMAL128_MAX_SCALE
+            ),
+        }
+        .fail();
+    }
+    if scale > 0 && scale > precision as i8 {
+        return InvalidPrecisionOrScaleSnafu {
+            reason: format!("scale {} is greater than precision {}", scale, precision),
+        }
+        .fail();
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_common_decimal128() {
+        let decimal = Decimal128::new_unchecked(123456789, 9, 3);
+        assert_eq!(decimal.to_string(), "123456.789");
+
+        let decimal = Decimal128::try_new(123456789, 9, 0);
+        assert_eq!(decimal.unwrap().to_string(), "123456789");
+
+        let decimal = Decimal128::try_new(123456789, 9, 2);
+        assert_eq!(decimal.unwrap().to_string(), "1234567.89");
+
+        let decimal = Decimal128::try_new(123, 3, -2);
+        assert_eq!(decimal.unwrap().to_string(), "12300");
+
+        // invalid precision or scale
+
+        // precision is 0
+        let decimal = Decimal128::try_new(123, 0, 0);
+        assert!(decimal.is_err());
+
+        // precision is greater than 38
+        let decimal = Decimal128::try_new(123, 39, 0);
+        assert!(decimal.is_err());
+
+        // scale is greater than 38
+        let decimal = Decimal128::try_new(123, 38, 39);
+        assert!(decimal.is_err());
+
+        // scale is greater than precision
+        let decimal = Decimal128::try_new(123, 3, 4);
+        assert!(decimal.is_err());
+    }
+
+    #[test]
+    fn test_decimal128_from_str() {
+        // 0 < precision <= 28
+        let decimal = Decimal128::from_str("1234567890.123456789").unwrap();
+        assert_eq!(decimal.to_string(), "1234567890.123456789");
+        assert_eq!(decimal.precision(), 19);
+        assert_eq!(decimal.scale(), 9);
+
+        let decimal = Decimal128::from_str("1234567890.123456789012345678").unwrap();
+        assert_eq!(decimal.to_string(), "1234567890.123456789012345678");
+        assert_eq!(decimal.precision(), 28);
+        assert_eq!(decimal.scale(), 18);
+
+        // 28 < precision <= 38
+        let decimal = Decimal128::from_str("1234567890.1234567890123456789012").unwrap();
+        assert_eq!(decimal.to_string(), "1234567890.1234567890123456789012");
+        assert_eq!(decimal.precision(), 32);
+        assert_eq!(decimal.scale(), 22);
+
+        let decimal = Decimal128::from_str("1234567890.1234567890123456789012345678").unwrap();
+        assert_eq!(
+            decimal.to_string(),
+            "1234567890.1234567890123456789012345678"
+        );
+        assert_eq!(decimal.precision(), 38);
+        assert_eq!(decimal.scale(), 28);
+
+        // precision > 38
+        let decimal = Decimal128::from_str("1234567890.12345678901234567890123456789");
+        assert!(decimal.is_err());
+    }
+
+    #[test]
+    #[ignore]
+    fn test_parse_decimal128_speed() {
+        // RustDecimal::from_str: 1.124855167s
+        for _ in 0..1500000 {
+            let _ = RustDecimal::from_str("1234567890.123456789012345678999").unwrap();
+        }
+
+        // BigDecimal::try_from: 6.799290042s
+        for _ in 0..1500000 {
+            let _ = BigDecimal::from_str("1234567890.123456789012345678999").unwrap();
+        }
+    }
+
+    #[test]
+    fn test_decimal128_precision_and_scale() {
+        // precision and scale from Deicmal(1,1) to Decimal(38,38)
+        for precision in 1..=38 {
+            for scale in 1..=precision {
+                let decimal_str = format!("0.{}", "1".repeat(scale as usize));
+                let decimal = Decimal128::from_str(&decimal_str).unwrap();
+                assert_eq!(decimal_str, decimal.to_string());
+            }
+        }
+    }
+
+    #[test]
+    fn test_decimal128_compare() {
+        // the same precision and scale
+        let decimal1 = Decimal128::from_str("1234567890.123456789012345678999").unwrap();
+        let decimal2 = Decimal128::from_str("1234567890.123456789012345678999").unwrap();
+        assert!(decimal1 == decimal2);
+
+        let decimal1 = Decimal128::from_str("1234567890.123456789012345678999").unwrap();
+        let decimal2 = Decimal128::from_str("1234567890.123456789012345678998").unwrap();
+        assert!(decimal1 > decimal2);
+
+        let decimal1 = Decimal128::from_str("1234567890.123456789012345678999").unwrap();
+        let decimal2 = Decimal128::from_str("1234567890.123456789012345678998").unwrap();
+        assert!(decimal2 < decimal1);
+
+        let decimal1 = Decimal128::from_str("1234567890.123456789012345678999").unwrap();
+        let decimal2 = Decimal128::from_str("1234567890.123456789012345678998").unwrap();
+        assert!(decimal1 >= decimal2);
+
+        let decimal1 = Decimal128::from_str("1234567890.123456789012345678999").unwrap();
+        let decimal2 = Decimal128::from_str("1234567890.123456789012345678998").unwrap();
+        assert!(decimal2 <= decimal1);
+
+        let decimal1 = Decimal128::from_str("1234567890.123456789012345678999").unwrap();
+        let decimal2 = Decimal128::from_str("1234567890.123456789012345678998").unwrap();
+        assert!(decimal1 != decimal2);
+
+        // different precision and scale cmp is None
+        let decimal1 = Decimal128::from_str("1234567890.123456789012345678999").unwrap();
+        let decimal2 = Decimal128::from_str("1234567890.123").unwrap();
+        assert_eq!(decimal1.partial_cmp(&decimal2), None);
+    }
+}

src/common/decimal/src/error.rs

@@ -0,0 +1,72 @@
+// 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 bigdecimal::BigDecimal;
+use common_error::ext::ErrorExt;
+use common_error::status_code::StatusCode;
+use common_macro::stack_trace_debug;
+use snafu::{Location, Snafu};
+
+#[derive(Snafu)]
+#[snafu(visibility(pub))]
+#[stack_trace_debug]
+pub enum Error {
+    #[snafu(display("Decimal out of range, decimal value: {}", value))]
+    BigDecimalOutOfRange {
+        value: BigDecimal,
+        location: Location,
+    },
+
+    #[snafu(display("Failed to parse string to rust decimal, raw: {}", raw))]
+    ParseRustDecimalStr {
+        raw: String,
+        #[snafu(source)]
+        error: rust_decimal::Error,
+    },
+
+    #[snafu(display("Failed to parse string to big decimal, raw: {}", raw))]
+    ParseBigDecimalStr {
+        raw: String,
+        #[snafu(source)]
+        error: bigdecimal::ParseBigDecimalError,
+    },
+
+    #[snafu(display("Invalid precision or scale, resion: {}", reason))]
+    InvalidPrecisionOrScale { reason: String, location: Location },
+}
+
+impl ErrorExt for Error {
+    fn status_code(&self) -> StatusCode {
+        match self {
+            Error::BigDecimalOutOfRange { .. } => StatusCode::Internal,
+            Error::ParseRustDecimalStr { .. }
+            | Error::InvalidPrecisionOrScale { .. }
+            | Error::ParseBigDecimalStr { .. } => StatusCode::InvalidArguments,
+        }
+    }
+
+    fn location_opt(&self) -> Option<common_error::snafu::Location> {
+        match self {
+            Error::BigDecimalOutOfRange { location, .. } => Some(*location),
+            Error::InvalidPrecisionOrScale { location, .. } => Some(*location),
+            Error::ParseRustDecimalStr { .. } | Error::ParseBigDecimalStr { .. } => None,
+        }
+    }
+
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+}
+
+pub type Result<T> = std::result::Result<T, Error>;

src/common/decimal/src/lib.rs

@@ -12,28 +12,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use common_meta::rpc::KeyValue;
-
-pub struct KvPair<'a>(&'a etcd_client::KeyValue);
-
-impl<'a> KvPair<'a> {
-    /// Creates a `KvPair` from etcd KeyValue
-    #[inline]
-    pub fn new(kv: &'a etcd_client::KeyValue) -> Self {
-        Self(kv)
-    }
-
-    #[inline]
-    pub fn from_etcd_kv(kv: &etcd_client::KeyValue) -> KeyValue {
-        KeyValue::from(KvPair::new(kv))
-    }
-}
-
-impl<'a> From<KvPair<'a>> for KeyValue {
-    fn from(kv: KvPair<'a>) -> Self {
-        Self {
-            key: kv.0.key().to_vec(),
-            value: kv.0.value().to_vec(),
-        }
-    }
-}
+pub mod decimal128;
+pub mod error;

src/common/error/Cargo.toml

@@ -5,5 +5,5 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-snafu = { version = "0.7", features = ["backtraces"] }
+snafu.workspace = true
 strum.workspace = true

src/common/error/src/ext.rs

@@ -40,7 +40,7 @@ pub trait ErrorExt: StackError {
         Self: Sized,
     {
         match self.status_code() {
-            StatusCode::Unknown | StatusCode::Unexpected | StatusCode::Internal => {
+            StatusCode::Unknown | StatusCode::Internal => {
                 // masks internal error from end user
                 format!("Internal error: {}", self.status_code() as u32)
             }

src/common/error/src/lib.rs

@@ -11,6 +11,7 @@
 // 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.
+
 #![feature(error_iter)]
 
 pub mod ext;

src/common/error/src/status_code.rs

@@ -14,10 +14,10 @@
 
 use std::fmt;
 
-use strum::EnumString;
+use strum::{AsRefStr, EnumString};
 
 /// Common status code for public API.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumString)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumString, AsRefStr)]
 pub enum StatusCode {
     // ====== Begin of common status code ==============
     /// Success.

src/common/function/Cargo.toml

@@ -7,12 +7,12 @@ license.workspace = true
 [dependencies]
 arc-swap = "1.0"
 chrono-tz = "0.6"
-common-error = { workspace = true }
-common-macro = { workspace = true }
-common-query = { workspace = true }
-common-time = { workspace = true }
+common-error.workspace = true
+common-macro.workspace = true
+common-query.workspace = true
+common-time.workspace = true
 datafusion.workspace = true
-datatypes = { workspace = true }
+datatypes.workspace = true
 libc = "0.2"
 num = "0.4"
 num-traits = "0.2"

src/common/function/src/scalars/math/rate.rs

@@ -16,7 +16,8 @@ use std::fmt;
 
 use common_query::error::{self, Result};
 use common_query::prelude::{Signature, Volatility};
-use datatypes::arrow::compute::kernels::{arithmetic, cast};
+use datafusion::arrow::compute::kernels::numeric;
+use datatypes::arrow::compute::kernels::cast;
 use datatypes::arrow::datatypes::DataType;
 use datatypes::prelude::*;
 use datatypes::vectors::{Helper, VectorRef};
@@ -51,11 +52,11 @@ impl Function for RateFunction {
         let val = &columns[0].to_arrow_array();
         let val_0 = val.slice(0, val.len() - 1);
         let val_1 = val.slice(1, val.len() - 1);
-        let dv = arithmetic::subtract_dyn(&val_1, &val_0).context(error::ArrowComputeSnafu)?;
+        let dv = numeric::sub(&val_1, &val_0).context(error::ArrowComputeSnafu)?;
         let ts = &columns[1].to_arrow_array();
         let ts_0 = ts.slice(0, ts.len() - 1);
         let ts_1 = ts.slice(1, ts.len() - 1);
-        let dt = arithmetic::subtract_dyn(&ts_1, &ts_0).context(error::ArrowComputeSnafu)?;
+        let dt = numeric::sub(&ts_1, &ts_0).context(error::ArrowComputeSnafu)?;
 
         let dv = cast::cast(&dv, &DataType::Float64).context(error::TypeCastSnafu {
             typ: DataType::Float64,
@@ -63,7 +64,7 @@ impl Function for RateFunction {
         let dt = cast::cast(&dt, &DataType::Float64).context(error::TypeCastSnafu {
             typ: DataType::Float64,
         })?;
-        let rate = arithmetic::divide_dyn(&dv, &dt).context(error::ArrowComputeSnafu)?;
+        let rate = numeric::div(&dv, &dt).context(error::ArrowComputeSnafu)?;
         let v = Helper::try_into_vector(&rate).context(error::FromArrowArraySnafu)?;
 
         Ok(v)

src/common/function/src/scalars/timestamp.rs

@@ -11,6 +11,7 @@
 // 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::sync::Arc;
 mod greatest;
 mod to_unixtime;

src/common/function/src/scalars/timestamp/greatest.rs

@@ -18,9 +18,9 @@ use common_query::error::{
     self, ArrowComputeSnafu, InvalidFuncArgsSnafu, Result, UnsupportedInputDataTypeSnafu,
 };
 use common_query::prelude::{Signature, Volatility};
+use datafusion::arrow::compute::kernels::cmp::gt;
 use datatypes::arrow::array::AsArray;
 use datatypes::arrow::compute::cast;
-use datatypes::arrow::compute::kernels::comparison::gt_dyn;
 use datatypes::arrow::compute::kernels::zip;
 use datatypes::arrow::datatypes::{DataType as ArrowDataType, Date32Type};
 use datatypes::prelude::ConcreteDataType;
@@ -72,7 +72,7 @@ impl Function for GreatestFunction {
                 let column2 = cast(&columns[1].to_arrow_array(), &ArrowDataType::Date32)
                     .context(ArrowComputeSnafu)?;
                 let column2 = column2.as_primitive::<Date32Type>();
-                let boolean_array = gt_dyn(&column1, &column2).context(ArrowComputeSnafu)?;
+                let boolean_array = gt(&column1, &column2).context(ArrowComputeSnafu)?;
                 let result =
                     zip::zip(&boolean_array, &column1, &column2).context(ArrowComputeSnafu)?;
                 Ok(Helper::try_into_vector(&result).context(error::FromArrowArraySnafu)?)
@@ -82,7 +82,7 @@ impl Function for GreatestFunction {
                 let column1 = column1.as_primitive::<Date32Type>();
                 let column2 = columns[1].to_arrow_array();
                 let column2 = column2.as_primitive::<Date32Type>();
-                let boolean_array = gt_dyn(&column1, &column2).context(ArrowComputeSnafu)?;
+                let boolean_array = gt(&column1, &column2).context(ArrowComputeSnafu)?;
                 let result =
                     zip::zip(&boolean_array, &column1, &column2).context(ArrowComputeSnafu)?;
                 Ok(Helper::try_into_vector(&result).context(error::FromArrowArraySnafu)?)

src/common/function/src/scalars/timestamp/to_unixtime.rs

@@ -18,36 +18,50 @@ use std::sync::Arc;
 
 use common_query::error::{InvalidFuncArgsSnafu, Result, UnsupportedInputDataTypeSnafu};
 use common_query::prelude::{Signature, Volatility};
-use common_time::timestamp::TimeUnit;
-use common_time::Timestamp;
+use common_time::{Date, DateTime, Timestamp};
 use datatypes::prelude::ConcreteDataType;
-use datatypes::types::TimestampType;
-use datatypes::vectors::{
-    Int64Vector, StringVector, TimestampMicrosecondVector, TimestampMillisecondVector,
-    TimestampNanosecondVector, TimestampSecondVector, Vector, VectorRef,
-};
+use datatypes::vectors::{Int64Vector, VectorRef};
 use snafu::ensure;
 
 use crate::scalars::function::{Function, FunctionContext};
 
+/// A function to convert the column into the unix timestamp in seconds.
 #[derive(Clone, Debug, Default)]
 pub struct ToUnixtimeFunction;
 
 const NAME: &str = "to_unixtime";
 
 fn convert_to_seconds(arg: &str) -> Option<i64> {
-    match Timestamp::from_str(arg) {
-        Ok(ts) => {
-            let sec_mul = (TimeUnit::Second.factor() / ts.unit().factor()) as i64;
-            Some(ts.value().div_euclid(sec_mul))
-        }
-        Err(_err) => None,
+    if let Ok(dt) = DateTime::from_str(arg) {
+        return Some(dt.val() / 1000);
     }
+
+    if let Ok(ts) = Timestamp::from_str(arg) {
+        return Some(ts.split().0);
+    }
+
+    if let Ok(date) = Date::from_str(arg) {
+        return Some(date.to_secs());
+    }
+
+    None
 }
 
-fn process_vector(vector: &dyn Vector) -> Vec<Option<i64>> {
+fn convert_timestamps_to_seconds(vector: &VectorRef) -> Vec<Option<i64>> {
     (0..vector.len())
-        .map(|i| paste::expr!((vector.get(i)).as_timestamp().map(|ts| ts.value())))
+        .map(|i| vector.get(i).as_timestamp().map(|ts| ts.split().0))
+        .collect::<Vec<Option<i64>>>()
+}
+
+fn convert_dates_to_seconds(vector: &VectorRef) -> Vec<Option<i64>> {
+    (0..vector.len())
+        .map(|i| vector.get(i).as_date().map(|dt| dt.to_secs()))
+        .collect::<Vec<Option<i64>>>()
+}
+
+fn convert_datetimes_to_seconds(vector: &VectorRef) -> Vec<Option<i64>> {
+    (0..vector.len())
+        .map(|i| vector.get(i).as_datetime().map(|dt| dt.val() / 1000))
         .collect::<Vec<Option<i64>>>()
 }
 
@@ -67,6 +81,8 @@ impl Function for ToUnixtimeFunction {
                 ConcreteDataType::string_datatype(),
                 ConcreteDataType::int32_datatype(),
                 ConcreteDataType::int64_datatype(),
+                ConcreteDataType::date_datatype(),
+                ConcreteDataType::datetime_datatype(),
                 ConcreteDataType::timestamp_second_datatype(),
                 ConcreteDataType::timestamp_millisecond_datatype(),
                 ConcreteDataType::timestamp_microsecond_datatype(),
@@ -87,51 +103,29 @@ impl Function for ToUnixtimeFunction {
             }
         );
 
+        let vector = &columns[0];
+
         match columns[0].data_type() {
-            ConcreteDataType::String(_) => {
-                let array = columns[0].to_arrow_array();
-                let vector = StringVector::try_from_arrow_array(&array).unwrap();
-                Ok(Arc::new(Int64Vector::from(
-                    (0..vector.len())
-                        .map(|i| convert_to_seconds(&vector.get(i).to_string()))
-                        .collect::<Vec<_>>(),
-                )))
-            }
+            ConcreteDataType::String(_) => Ok(Arc::new(Int64Vector::from(
+                (0..vector.len())
+                    .map(|i| convert_to_seconds(&vector.get(i).to_string()))
+                    .collect::<Vec<_>>(),
+            ))),
             ConcreteDataType::Int64(_) | ConcreteDataType::Int32(_) => {
-                let array = columns[0].to_arrow_array();
-                Ok(Arc::new(Int64Vector::try_from_arrow_array(&array).unwrap()))
+                // Safety: cast always successfully at here
+                Ok(vector.cast(&ConcreteDataType::int64_datatype()).unwrap())
             }
-            ConcreteDataType::Timestamp(ts) => {
-                let array = columns[0].to_arrow_array();
-                let value = match ts {
-                    TimestampType::Second(_) => {
-                        let vector = paste::expr!(TimestampSecondVector::try_from_arrow_array(
-                            array
-                        )
-                        .unwrap());
-                        process_vector(&vector)
-                    }
-                    TimestampType::Millisecond(_) => {
-                        let vector = paste::expr!(
-                            TimestampMillisecondVector::try_from_arrow_array(array).unwrap()
-                        );
-                        process_vector(&vector)
-                    }
-                    TimestampType::Microsecond(_) => {
-                        let vector = paste::expr!(
-                            TimestampMicrosecondVector::try_from_arrow_array(array).unwrap()
-                        );
-                        process_vector(&vector)
-                    }
-                    TimestampType::Nanosecond(_) => {
-                        let vector = paste::expr!(TimestampNanosecondVector::try_from_arrow_array(
-                            array
-                        )
-                        .unwrap());
-                        process_vector(&vector)
-                    }
-                };
-                Ok(Arc::new(Int64Vector::from(value)))
+            ConcreteDataType::Date(_) => {
+                let seconds = convert_dates_to_seconds(vector);
+                Ok(Arc::new(Int64Vector::from(seconds)))
+            }
+            ConcreteDataType::DateTime(_) => {
+                let seconds = convert_datetimes_to_seconds(vector);
+                Ok(Arc::new(Int64Vector::from(seconds)))
+            }
+            ConcreteDataType::Timestamp(_) => {
+                let seconds = convert_timestamps_to_seconds(vector);
+                Ok(Arc::new(Int64Vector::from(seconds)))
             }
             _ => UnsupportedInputDataTypeSnafu {
                 function: NAME,
@@ -151,11 +145,11 @@ impl fmt::Display for ToUnixtimeFunction {
 #[cfg(test)]
 mod tests {
     use common_query::prelude::TypeSignature;
-    use datatypes::prelude::{ConcreteDataType, ScalarVectorBuilder};
-    use datatypes::scalars::ScalarVector;
-    use datatypes::timestamp::TimestampSecond;
+    use datatypes::prelude::ConcreteDataType;
     use datatypes::value::Value;
-    use datatypes::vectors::{StringVector, TimestampSecondVector};
+    use datatypes::vectors::{
+        DateTimeVector, DateVector, StringVector, TimestampMillisecondVector, TimestampSecondVector,
+    };
 
     use super::{ToUnixtimeFunction, *};
     use crate::scalars::Function;
@@ -170,18 +164,20 @@ mod tests {
         );
 
         assert!(matches!(f.signature(),
-        Signature {
-                type_signature: TypeSignature::Uniform(1, valid_types),
-                volatility: Volatility::Immutable
-            } if  valid_types == vec![
-                ConcreteDataType::string_datatype(),
-                ConcreteDataType::int32_datatype(),
-                ConcreteDataType::int64_datatype(),
-                ConcreteDataType::timestamp_second_datatype(),
-                ConcreteDataType::timestamp_millisecond_datatype(),
-                ConcreteDataType::timestamp_microsecond_datatype(),
-                ConcreteDataType::timestamp_nanosecond_datatype(),
-            ]
+                         Signature {
+                             type_signature: TypeSignature::Uniform(1, valid_types),
+                             volatility: Volatility::Immutable
+                         } if  valid_types == vec![
+                             ConcreteDataType::string_datatype(),
+                             ConcreteDataType::int32_datatype(),
+                             ConcreteDataType::int64_datatype(),
+                             ConcreteDataType::date_datatype(),
+                             ConcreteDataType::datetime_datatype(),
+                             ConcreteDataType::timestamp_second_datatype(),
+                             ConcreteDataType::timestamp_millisecond_datatype(),
+                             ConcreteDataType::timestamp_microsecond_datatype(),
+                             ConcreteDataType::timestamp_nanosecond_datatype(),
+                         ]
         ));
 
         let times = vec![
@@ -212,26 +208,6 @@ mod tests {
     #[test]
     fn test_int_to_unixtime() {
         let f = ToUnixtimeFunction;
-        assert_eq!("to_unixtime", f.name());
-        assert_eq!(
-            ConcreteDataType::int64_datatype(),
-            f.return_type(&[]).unwrap()
-        );
-
-        assert!(matches!(f.signature(),
-        Signature {
-                type_signature: TypeSignature::Uniform(1, valid_types),
-                volatility: Volatility::Immutable
-            } if  valid_types == vec![
-                ConcreteDataType::string_datatype(),
-                ConcreteDataType::int32_datatype(),
-                ConcreteDataType::int64_datatype(),
-                ConcreteDataType::timestamp_second_datatype(),
-                ConcreteDataType::timestamp_millisecond_datatype(),
-                ConcreteDataType::timestamp_microsecond_datatype(),
-                ConcreteDataType::timestamp_nanosecond_datatype(),
-            ]
-        ));
 
         let times = vec![Some(3_i64), None, Some(5_i64), None];
         let results = [Some(3), None, Some(5), None];
@@ -254,38 +230,13 @@ mod tests {
     }
 
     #[test]
-    fn test_timestamp_to_unixtime() {
+    fn test_date_to_unixtime() {
         let f = ToUnixtimeFunction;
-        assert_eq!("to_unixtime", f.name());
-        assert_eq!(
-            ConcreteDataType::int64_datatype(),
-            f.return_type(&[]).unwrap()
-        );
 
-        assert!(matches!(f.signature(),
-        Signature {
-                type_signature: TypeSignature::Uniform(1, valid_types),
-                volatility: Volatility::Immutable
-            } if  valid_types == vec![
-                ConcreteDataType::string_datatype(),
-                ConcreteDataType::int32_datatype(),
-                ConcreteDataType::int64_datatype(),
-                ConcreteDataType::timestamp_second_datatype(),
-                ConcreteDataType::timestamp_millisecond_datatype(),
-                ConcreteDataType::timestamp_microsecond_datatype(),
-                ConcreteDataType::timestamp_nanosecond_datatype(),
-            ]
-        ));
-
-        let times: Vec<Option<TimestampSecond>> = vec![
-            Some(TimestampSecond::new(123)),
-            None,
-            Some(TimestampSecond::new(42)),
-            None,
-        ];
-        let results = [Some(123), None, Some(42), None];
-        let ts_vector: TimestampSecondVector = build_vector_from_slice(&times);
-        let args: Vec<VectorRef> = vec![Arc::new(ts_vector)];
+        let times = vec![Some(123), None, Some(42), None];
+        let results = [Some(10627200), None, Some(3628800), None];
+        let date_vector = DateVector::from(times.clone());
+        let args: Vec<VectorRef> = vec![Arc::new(date_vector)];
         let vector = f.eval(FunctionContext::default(), &args).unwrap();
         assert_eq!(4, vector.len());
         for (i, _t) in times.iter().enumerate() {
@@ -303,11 +254,73 @@ mod tests {
         }
     }
 
-    fn build_vector_from_slice<T: ScalarVector>(items: &[Option<T::RefItem<'_>>]) -> T {
-        let mut builder = T::Builder::with_capacity(items.len());
-        for item in items {
-            builder.push(*item);
+    #[test]
+    fn test_datetime_to_unixtime() {
+        let f = ToUnixtimeFunction;
+
+        let times = vec![Some(123000), None, Some(42000), None];
+        let results = [Some(123), None, Some(42), None];
+        let date_vector = DateTimeVector::from(times.clone());
+        let args: Vec<VectorRef> = vec![Arc::new(date_vector)];
+        let vector = f.eval(FunctionContext::default(), &args).unwrap();
+        assert_eq!(4, vector.len());
+        for (i, _t) in times.iter().enumerate() {
+            let v = vector.get(i);
+            if i == 1 || i == 3 {
+                assert_eq!(Value::Null, v);
+                continue;
+            }
+            match v {
+                Value::Int64(ts) => {
+                    assert_eq!(ts, (*results.get(i).unwrap()).unwrap());
+                }
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[test]
+    fn test_timestamp_to_unixtime() {
+        let f = ToUnixtimeFunction;
+
+        let times = vec![Some(123), None, Some(42), None];
+        let results = [Some(123), None, Some(42), None];
+        let ts_vector = TimestampSecondVector::from(times.clone());
+        let args: Vec<VectorRef> = vec![Arc::new(ts_vector)];
+        let vector = f.eval(FunctionContext::default(), &args).unwrap();
+        assert_eq!(4, vector.len());
+        for (i, _t) in times.iter().enumerate() {
+            let v = vector.get(i);
+            if i == 1 || i == 3 {
+                assert_eq!(Value::Null, v);
+                continue;
+            }
+            match v {
+                Value::Int64(ts) => {
+                    assert_eq!(ts, (*results.get(i).unwrap()).unwrap());
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        let times = vec![Some(123000), None, Some(42000), None];
+        let results = [Some(123), None, Some(42), None];
+        let ts_vector = TimestampMillisecondVector::from(times.clone());
+        let args: Vec<VectorRef> = vec![Arc::new(ts_vector)];
+        let vector = f.eval(FunctionContext::default(), &args).unwrap();
+        assert_eq!(4, vector.len());
+        for (i, _t) in times.iter().enumerate() {
+            let v = vector.get(i);
+            if i == 1 || i == 3 {
+                assert_eq!(Value::Null, v);
+                continue;
+            }
+            match v {
+                Value::Int64(ts) => {
+                    assert_eq!(ts, (*results.get(i).unwrap()).unwrap());
+                }
+                _ => unreachable!(),
+            }
         }
-        builder.finish()
     }
 }

src/common/greptimedb-telemetry/Cargo.toml

@@ -6,19 +6,19 @@ license.workspace = true
 
 [dependencies]
 async-trait.workspace = true
-common-error = { workspace = true }
-common-runtime = { workspace = true }
-common-telemetry = { workspace = true }
-reqwest = { workspace = true }
+common-error.workspace = true
+common-runtime.workspace = true
+common-telemetry.workspace = true
+reqwest.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 tokio.workspace = true
 uuid.workspace = true
 
 [dev-dependencies]
-common-test-util = { workspace = true }
+common-test-util.workspace = true
 hyper = { version = "0.14", features = ["full"] }
 tempfile.workspace = true
 
 [build-dependencies]
-common-version = { workspace = true }
+common-version.workspace = true

src/common/greptimedb-telemetry/src/lib.rs

@@ -210,6 +210,7 @@ pub struct GreptimeDBTelemetry {
     working_home: Option<String>,
     telemetry_url: &'static str,
     should_report: Arc<AtomicBool>,
+    report_times: usize,
 }
 
 #[async_trait::async_trait]
@@ -242,6 +243,7 @@ impl GreptimeDBTelemetry {
             client: client.ok(),
             telemetry_url: TELEMETRY_URL,
             should_report,
+            report_times: 0,
         }
     }
 
@@ -259,8 +261,11 @@ impl GreptimeDBTelemetry {
                 };
 
                 if let Some(client) = self.client.as_ref() {
-                    info!("reporting greptimedb version: {:?}", data);
+                    if self.report_times == 0 {
+                        info!("reporting greptimedb version: {:?}", data);
+                    }
                     let result = client.post(self.telemetry_url).json(&data).send().await;
+                    self.report_times += 1;
                     debug!("report version result: {:?}", result);
                     result.ok()
                 } else {

src/common/grpc-expr/Cargo.toml

@@ -5,18 +5,18 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-api = { workspace = true }
+api.workspace = true
 async-trait.workspace = true
-common-base = { workspace = true }
-common-catalog = { workspace = true }
-common-error = { workspace = true }
-common-macro = { workspace = true }
-common-query = { workspace = true }
-common-telemetry = { workspace = true }
-common-time = { workspace = true }
-datatypes = { workspace = true }
-snafu = { version = "0.7", features = ["backtraces"] }
-table = { workspace = true }
+common-base.workspace = true
+common-catalog.workspace = true
+common-error.workspace = true
+common-macro.workspace = true
+common-query.workspace = true
+common-telemetry.workspace = true
+common-time.workspace = true
+datatypes.workspace = true
+snafu.workspace = true
+table.workspace = true
 
 [dev-dependencies]
 paste = "1.0"

src/common/grpc/Cargo.toml

@@ -5,25 +5,25 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-api = { workspace = true }
+api.workspace = true
 arrow-flight.workspace = true
 async-trait = "0.1"
 backtrace = "0.3"
-common-base = { workspace = true }
-common-error = { workspace = true }
-common-macro = { workspace = true }
-common-recordbatch = { workspace = true }
-common-runtime = { workspace = true }
-common-telemetry = { workspace = true }
-common-time = { workspace = true }
+common-base.workspace = true
+common-error.workspace = true
+common-macro.workspace = true
+common-recordbatch.workspace = true
+common-runtime.workspace = true
+common-telemetry.workspace = true
+common-time.workspace = true
 dashmap = "5.4"
 datafusion.workspace = true
-datatypes = { workspace = true }
+datatypes.workspace = true
 flatbuffers = "23.1"
 futures = "0.3"
 lazy_static.workspace = true
 prost.workspace = true
-snafu = { version = "0.7", features = ["backtraces"] }
+snafu.workspace = true
 tokio.workspace = true
 tonic.workspace = true
 tower = "0.4"

src/common/grpc/src/channel_manager.rs

@@ -163,7 +163,14 @@ impl ChannelManager {
     }
 
     fn build_endpoint(&self, addr: &str) -> Result<Endpoint> {
-        let mut endpoint = Endpoint::new(format!("http://{addr}")).context(CreateChannelSnafu)?;
+        let http_prefix = if self.client_tls_config.is_some() {
+            "https"
+        } else {
+            "http"
+        };
+
+        let mut endpoint =
+            Endpoint::new(format!("{http_prefix}://{addr}")).context(CreateChannelSnafu)?;
 
         if let Some(dur) = self.config.timeout {
             endpoint = endpoint.timeout(dur);

src/common/grpc/src/flight.rs

@@ -241,7 +241,7 @@ mod test {
         .unwrap();
 
         let flight_data = batches_to_flight_data(
-            arrow_schema,
+            &arrow_schema,
             vec![
                 batch1.clone().into_df_record_batch(),
                 batch2.clone().into_df_record_batch(),

src/common/grpc/tests/mod.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/common/macro/Cargo.toml

@@ -8,8 +8,6 @@ license.workspace = true
 proc-macro = true
 
 [dependencies]
-backtrace = "0.3"
-common-telemetry = { workspace = true }
 proc-macro2 = "1.0.66"
 quote = "1.0"
 syn = "1.0"
@@ -25,7 +23,7 @@ syn2 = { version = "2.0", package = "syn", features = [
 
 [dev-dependencies]
 arc-swap = "1.0"
-common-query = { workspace = true }
-datatypes = { workspace = true }
+common-query.workspace = true
+datatypes.workspace = true
 snafu.workspace = true
 static_assertions = "1.1.0"

src/common/mem-prof/Cargo.toml

@@ -5,8 +5,8 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-common-error = { workspace = true }
-common-macro = { workspace = true }
+common-error.workspace = true
+common-macro.workspace = true
 snafu.workspace = true
 tempfile = "3.4"
 tokio.workspace = true

src/common/meta/Cargo.toml

@@ -8,38 +8,39 @@ license.workspace = true
 testing = []
 
 [dependencies]
-api = { workspace = true }
-arrow-flight.workspace = true
+api.workspace = true
+async-recursion = "1.0"
 async-stream.workspace = true
 async-trait.workspace = true
-base64 = "0.21"
+base64.workspace = true
 bytes = "1.4"
-common-catalog = { workspace = true }
-common-error = { workspace = true }
+common-catalog.workspace = true
+common-error.workspace = true
 common-grpc-expr.workspace = true
-common-macro = { workspace = true }
-common-procedure = { workspace = true }
-common-recordbatch = { workspace = true }
-common-runtime = { workspace = true }
-common-telemetry = { workspace = true }
-common-time = { workspace = true }
-datatypes = { workspace = true }
+common-macro.workspace = true
+common-procedure.workspace = true
+common-recordbatch.workspace = true
+common-runtime.workspace = true
+common-telemetry.workspace = true
+common-time.workspace = true
+datatypes.workspace = true
 etcd-client.workspace = true
 futures.workspace = true
 humantime-serde.workspace = true
 lazy_static.workspace = true
-metrics.workspace = true
+prometheus.workspace = true
 prost.workspace = true
 regex.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 snafu.workspace = true
-store-api = { workspace = true }
+store-api.workspace = true
 strum.workspace = true
-table = { workspace = true }
+table.workspace = true
 tokio.workspace = true
+tonic.workspace = true
 
 [dev-dependencies]
 chrono.workspace = true
-datatypes = { workspace = true }
+datatypes.workspace = true
 hyper = { version = "0.14", features = ["full"] }

src/common/meta/src/cache_invalidator.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/common/meta/src/datanode_manager.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

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

@@ -374,10 +374,11 @@ impl Procedure for AlterTableProcedure {
 
         let state = &self.data.state;
 
-        let _timer = common_telemetry::timer!(
-            metrics::METRIC_META_PROCEDURE_ALTER_TABLE,
-            &[("step", state.as_ref().to_string())]
-        );
+        let step = state.as_ref();
+
+        let _timer = metrics::METRIC_META_PROCEDURE_ALTER_TABLE
+            .with_label_values(&[step])
+            .start_timer();
 
         match state {
             AlterTableState::Prepare => self.on_prepare().await,

src/common/meta/src/ddl/create_table.rs

@@ -251,10 +251,9 @@ impl Procedure for CreateTableProcedure {
     async fn execute(&mut self, _ctx: &ProcedureContext) -> ProcedureResult<Status> {
         let state = &self.creator.data.state;
 
-        let _timer = common_telemetry::timer!(
-            metrics::METRIC_META_PROCEDURE_CREATE_TABLE,
-            &[("step", state.as_ref().to_string())]
-        );
+        let _timer = metrics::METRIC_META_PROCEDURE_CREATE_TABLE
+            .with_label_values(&[state.as_ref()])
+            .start_timer();
 
         match state {
             CreateTableState::Prepare => self.on_prepare().await,

src/common/meta/src/ddl/drop_table.rs

@@ -197,10 +197,9 @@ impl Procedure for DropTableProcedure {
     async fn execute(&mut self, _ctx: &ProcedureContext) -> ProcedureResult<Status> {
         let state = &self.data.state;
 
-        let _timer = common_telemetry::timer!(
-            metrics::METRIC_META_PROCEDURE_DROP_TABLE,
-            &[("step", state.as_ref().to_string())]
-        );
+        let _timer = metrics::METRIC_META_PROCEDURE_DROP_TABLE
+            .with_label_values(&[state.as_ref()])
+            .start_timer();
 
         match self.data.state {
             DropTableState::Prepare => self.on_prepare().await,

src/common/meta/src/ddl/truncate_table.rs

@@ -55,10 +55,9 @@ impl Procedure for TruncateTableProcedure {
     async fn execute(&mut self, _ctx: &ProcedureContext) -> ProcedureResult<Status> {
         let state = &self.data.state;
 
-        let _timer = common_telemetry::timer!(
-            metrics::METRIC_META_PROCEDURE_TRUNCATE_TABLE,
-            &[("step", state.as_ref().to_string())]
-        );
+        let _timer = metrics::METRIC_META_PROCEDURE_TRUNCATE_TABLE
+            .with_label_values(&[state.as_ref()])
+            .start_timer();
 
         match self.data.state {
             TruncateTableState::Prepare => self.on_prepare().await,

src/common/meta/src/distributed_time_constants.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/common/meta/src/error.rs

@@ -28,6 +28,26 @@ use crate::peer::Peer;
 #[snafu(visibility(pub))]
 #[stack_trace_debug]
 pub enum Error {
+    #[snafu(display("Empty key is not allowed"))]
+    EmptyKey { location: Location },
+
+    #[snafu(display("Invalid result with a txn response: {}", err_msg))]
+    InvalidTxnResult { err_msg: String, location: Location },
+
+    #[snafu(display("Failed to connect to Etcd"))]
+    ConnectEtcd {
+        #[snafu(source)]
+        error: etcd_client::Error,
+        location: Location,
+    },
+
+    #[snafu(display("Failed to execute via Etcd"))]
+    EtcdFailed {
+        #[snafu(source)]
+        error: etcd_client::Error,
+        location: Location,
+    },
+
     #[snafu(display("Failed to get sequence: {}", err_msg))]
     NextSequence { err_msg: String, location: Location },
 
@@ -254,7 +274,10 @@ impl ErrorExt for Error {
     fn status_code(&self) -> StatusCode {
         use Error::*;
         match self {
-            IllegalServerState { .. } | EtcdTxnOpResponse { .. } => StatusCode::Internal,
+            IllegalServerState { .. }
+            | EtcdTxnOpResponse { .. }
+            | EtcdFailed { .. }
+            | ConnectEtcd { .. } => StatusCode::Internal,
 
             SerdeJson { .. }
             | ParseOption { .. }
@@ -267,7 +290,8 @@ impl ErrorExt for Error {
             | NextSequence { .. }
             | SequenceOutOfRange { .. }
             | UnexpectedSequenceValue { .. }
-            | InvalidHeartbeatResponse { .. } => StatusCode::Unexpected,
+            | InvalidHeartbeatResponse { .. }
+            | InvalidTxnResult { .. } => StatusCode::Unexpected,
 
             SendMessage { .. }
             | GetKvCache { .. }
@@ -277,7 +301,7 @@ impl ErrorExt for Error {
             | RenameTable { .. }
             | Unsupported { .. } => StatusCode::Internal,
 
-            PrimaryKeyNotFound { .. } => StatusCode::InvalidArguments,
+            PrimaryKeyNotFound { .. } | &EmptyKey { .. } => StatusCode::InvalidArguments,
 
             TableNotFound { .. } => StatusCode::TableNotFound,
             TableAlreadyExists { .. } => StatusCode::TableAlreadyExists,
@@ -319,4 +343,16 @@ impl Error {
     pub fn is_retry_later(&self) -> bool {
         matches!(self, Error::RetryLater { .. })
     }
+
+    /// Returns true if the response exceeds the size limit.
+    pub fn is_exceeded_size_limit(&self) -> bool {
+        if let Error::EtcdFailed {
+            error: etcd_client::Error::GRpcStatus(status),
+            ..
+        } = self
+        {
+            return status.code() == tonic::Code::OutOfRange;
+        }
+        false
+    }
 }

src/common/meta/src/instruction.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/common/meta/src/key.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,
@@ -54,6 +54,8 @@ pub mod table_region;
 // TODO(weny): removes it.
 #[allow(deprecated)]
 pub mod table_route;
+#[cfg(any(test, feature = "testing"))]
+pub mod test_utils;
 
 use std::collections::{BTreeMap, HashMap};
 use std::fmt::Debug;
@@ -62,6 +64,7 @@ use std::sync::Arc;
 
 use bytes::Bytes;
 use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
+use common_telemetry::warn;
 use datanode_table::{DatanodeTableKey, DatanodeTableManager, DatanodeTableValue};
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -81,7 +84,7 @@ use crate::ddl::utils::region_storage_path;
 use crate::error::{self, Result, SerdeJsonSnafu};
 use crate::kv_backend::txn::Txn;
 use crate::kv_backend::KvBackendRef;
-use crate::rpc::router::{region_distribution, RegionRoute};
+use crate::rpc::router::{region_distribution, RegionRoute, RegionStatus};
 use crate::DatanodeId;
 
 pub const REMOVED_PREFIX: &str = "__removed";
@@ -89,12 +92,20 @@ pub const REMOVED_PREFIX: &str = "__removed";
 const NAME_PATTERN: &str = r"[a-zA-Z_:-][a-zA-Z0-9_:\-\.]*";
 
 const DATANODE_TABLE_KEY_PREFIX: &str = "__dn_table";
-const TABLE_INFO_KEY_PREFIX: &str = "__table_info";
-const TABLE_NAME_KEY_PREFIX: &str = "__table_name";
 const TABLE_REGION_KEY_PREFIX: &str = "__table_region";
-const CATALOG_NAME_KEY_PREFIX: &str = "__catalog_name";
-const SCHEMA_NAME_KEY_PREFIX: &str = "__schema_name";
-const TABLE_ROUTE_PREFIX: &str = "__table_route";
+
+pub const TABLE_INFO_KEY_PREFIX: &str = "__table_info";
+pub const TABLE_NAME_KEY_PREFIX: &str = "__table_name";
+pub const CATALOG_NAME_KEY_PREFIX: &str = "__catalog_name";
+pub const SCHEMA_NAME_KEY_PREFIX: &str = "__schema_name";
+pub const TABLE_ROUTE_PREFIX: &str = "__table_route";
+
+pub const CACHE_KEY_PREFIXES: [&str; 4] = [
+    TABLE_NAME_KEY_PREFIX,
+    CATALOG_NAME_KEY_PREFIX,
+    SCHEMA_NAME_KEY_PREFIX,
+    TABLE_ROUTE_PREFIX,
+];
 
 pub type RegionDistribution = BTreeMap<DatanodeId, Vec<RegionNumber>>;
 
@@ -615,6 +626,58 @@ impl TableMetadataManager {
 
         Ok(())
     }
+
+    /// Updates the leader status of the [RegionRoute].
+    pub async fn update_leader_region_status<F>(
+        &self,
+        table_id: TableId,
+        current_table_route_value: DeserializedValueWithBytes<TableRouteValue>,
+        next_region_route_status: F,
+    ) -> Result<()>
+    where
+        F: Fn(&RegionRoute) -> Option<Option<RegionStatus>>,
+    {
+        let mut new_region_routes = current_table_route_value.region_routes.clone();
+
+        let mut updated = 0;
+        for route in &mut new_region_routes {
+            if let Some(status) = next_region_route_status(route) {
+                if route.set_leader_status(status) {
+                    updated += 1;
+                }
+            }
+        }
+
+        if updated == 0 {
+            warn!("No leader status updated");
+            return Ok(());
+        }
+
+        // Updates the table_route.
+        let new_table_route_value = current_table_route_value.update(new_region_routes);
+
+        let (update_table_route_txn, on_update_table_route_failure) = self
+            .table_route_manager()
+            .build_update_txn(table_id, &current_table_route_value, &new_table_route_value)?;
+
+        let txn = Txn::merge_all(vec![update_table_route_txn]);
+
+        let r = self.kv_backend.txn(txn).await?;
+
+        // Checks whether metadata was already updated.
+        if !r.succeeded {
+            let remote_table_route = on_update_table_route_failure(&r.responses)?
+                .context(error::UnexpectedSnafu {
+                    err_msg: "Reads the empty table route during the updating leader region status",
+                })?
+                .into_inner();
+
+            let op_name = "the updating leader region status";
+            ensure_values!(remote_table_route, new_table_route_value, op_name);
+        }
+
+        Ok(())
+    }
 }
 
 #[macro_export]
@@ -684,12 +747,11 @@ mod tests {
     use std::sync::Arc;
 
     use bytes::Bytes;
-    use datatypes::prelude::ConcreteDataType;
-    use datatypes::schema::{ColumnSchema, SchemaBuilder};
     use futures::TryStreamExt;
-    use table::metadata::{RawTableInfo, TableInfo, TableInfoBuilder, TableMetaBuilder};
+    use table::metadata::{RawTableInfo, TableInfo};
 
     use super::datanode_table::DatanodeTableKey;
+    use super::test_utils;
     use crate::ddl::utils::region_storage_path;
     use crate::key::datanode_table::RegionInfo;
     use crate::key::table_info::TableInfoValue;
@@ -698,7 +760,7 @@ mod tests {
     use crate::key::{to_removed_key, DeserializedValueWithBytes, TableMetadataManager};
     use crate::kv_backend::memory::MemoryKvBackend;
     use crate::peer::Peer;
-    use crate::rpc::router::{region_distribution, Region, RegionRoute};
+    use crate::rpc::router::{region_distribution, Region, RegionRoute, RegionStatus};
 
     #[test]
     fn test_deserialized_value_with_bytes() {
@@ -735,40 +797,6 @@ mod tests {
         assert_eq!(removed, to_removed_key(key));
     }
 
-    fn new_test_table_info(region_numbers: impl Iterator<Item = u32>) -> TableInfo {
-        let column_schemas = vec![
-            ColumnSchema::new("col1", ConcreteDataType::int32_datatype(), true),
-            ColumnSchema::new(
-                "ts",
-                ConcreteDataType::timestamp_millisecond_datatype(),
-                false,
-            )
-            .with_time_index(true),
-            ColumnSchema::new("col2", ConcreteDataType::int32_datatype(), true),
-        ];
-        let schema = SchemaBuilder::try_from(column_schemas)
-            .unwrap()
-            .version(123)
-            .build()
-            .unwrap();
-
-        let meta = TableMetaBuilder::default()
-            .schema(Arc::new(schema))
-            .primary_key_indices(vec![0])
-            .engine("engine")
-            .next_column_id(3)
-            .region_numbers(region_numbers.collect::<Vec<_>>())
-            .build()
-            .unwrap();
-        TableInfoBuilder::default()
-            .table_id(10)
-            .table_version(5)
-            .name("mytable")
-            .meta(meta)
-            .build()
-            .unwrap()
-    }
-
     fn new_test_region_route() -> RegionRoute {
         new_region_route(1, 2)
     }
@@ -783,9 +811,14 @@ mod tests {
             },
             leader_peer: Some(Peer::new(datanode, "a2")),
             follower_peers: vec![],
+            leader_status: None,
         }
     }
 
+    fn new_test_table_info(region_numbers: impl Iterator<Item = u32>) -> TableInfo {
+        test_utils::new_test_table_info(10, region_numbers)
+    }
+
     #[tokio::test]
     async fn test_create_table_metadata() {
         let mem_kv = Arc::new(MemoryKvBackend::default());
@@ -1022,6 +1055,74 @@ mod tests {
             .is_err())
     }
 
+    #[tokio::test]
+    async fn test_update_table_leader_region_status() {
+        let mem_kv = Arc::new(MemoryKvBackend::default());
+        let table_metadata_manager = TableMetadataManager::new(mem_kv);
+        let datanode = 1;
+        let region_routes = vec![
+            RegionRoute {
+                region: Region {
+                    id: 1.into(),
+                    name: "r1".to_string(),
+                    partition: None,
+                    attrs: BTreeMap::new(),
+                },
+                leader_peer: Some(Peer::new(datanode, "a2")),
+                leader_status: Some(RegionStatus::Downgraded),
+                follower_peers: vec![],
+            },
+            RegionRoute {
+                region: Region {
+                    id: 2.into(),
+                    name: "r2".to_string(),
+                    partition: None,
+                    attrs: BTreeMap::new(),
+                },
+                leader_peer: Some(Peer::new(datanode, "a1")),
+                leader_status: None,
+                follower_peers: vec![],
+            },
+        ];
+        let table_info: RawTableInfo =
+            new_test_table_info(region_routes.iter().map(|r| r.region.id.region_number())).into();
+        let table_id = table_info.ident.table_id;
+        let current_table_route_value =
+            DeserializedValueWithBytes::from_inner(TableRouteValue::new(region_routes.clone()));
+        // creates metadata.
+        table_metadata_manager
+            .create_table_metadata(table_info.clone(), region_routes.clone())
+            .await
+            .unwrap();
+
+        table_metadata_manager
+            .update_leader_region_status(table_id, current_table_route_value, |region_route| {
+                if region_route.leader_status.is_some() {
+                    None
+                } else {
+                    Some(Some(RegionStatus::Downgraded))
+                }
+            })
+            .await
+            .unwrap();
+
+        let updated_route_value = table_metadata_manager
+            .table_route_manager()
+            .get(table_id)
+            .await
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(
+            updated_route_value.region_routes[0].leader_status,
+            Some(RegionStatus::Downgraded)
+        );
+        assert_eq!(
+            updated_route_value.region_routes[1].leader_status,
+            Some(RegionStatus::Downgraded)
+        );
+    }
+
     async fn assert_datanode_table(
         table_metadata_manager: &TableMetadataManager,
         table_id: u32,

src/common/meta/src/key/catalog_name.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,
@@ -16,10 +16,8 @@ use std::fmt::Display;
 use std::sync::Arc;
 
 use common_catalog::consts::DEFAULT_CATALOG_NAME;
-use common_telemetry::timer;
 use futures::stream::BoxStream;
 use futures::StreamExt;
-use metrics::increment_counter;
 use serde::{Deserialize, Serialize};
 use snafu::{OptionExt, ResultExt};
 
@@ -104,7 +102,7 @@ impl CatalogManager {
 
     /// Creates `CatalogNameKey`.
     pub async fn create(&self, catalog: CatalogNameKey<'_>, if_not_exists: bool) -> Result<()> {
-        let _timer = timer!(crate::metrics::METRIC_META_CREATE_CATALOG);
+        let _timer = crate::metrics::METRIC_META_CREATE_CATALOG.start_timer();
 
         let raw_key = catalog.as_raw_key();
         let raw_value = CatalogNameValue.try_as_raw_value()?;
@@ -113,7 +111,7 @@ impl CatalogManager {
             .put_conditionally(raw_key, raw_value, if_not_exists)
             .await?
         {
-            increment_counter!(crate::metrics::METRIC_META_CREATE_CATALOG);
+            crate::metrics::METRIC_META_CREATE_CATALOG_COUNTER.inc();
         }
 
         Ok(())

src/common/meta/src/key/datanode_table.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/common/meta/src/key/schema_name.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,
@@ -18,11 +18,9 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
-use common_telemetry::timer;
 use futures::stream::BoxStream;
 use futures::StreamExt;
 use humantime_serde::re::humantime;
-use metrics::increment_counter;
 use serde::{Deserialize, Serialize};
 use snafu::{OptionExt, ResultExt};
 
@@ -146,7 +144,7 @@ impl SchemaManager {
         value: Option<SchemaNameValue>,
         if_not_exists: bool,
     ) -> Result<()> {
-        let _timer = timer!(crate::metrics::METRIC_META_CREATE_SCHEMA);
+        let _timer = crate::metrics::METRIC_META_CREATE_SCHEMA.start_timer();
 
         let raw_key = schema.as_raw_key();
         let raw_value = value.unwrap_or_default().try_as_raw_value()?;
@@ -155,7 +153,7 @@ impl SchemaManager {
             .put_conditionally(raw_key, raw_value, if_not_exists)
             .await?
         {
-            increment_counter!(crate::metrics::METRIC_META_CREATE_SCHEMA);
+            crate::metrics::METRIC_META_CREATE_SCHEMA_COUNTER.inc();
         }
 
         Ok(())

src/common/meta/src/key/table_info.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,
@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::collections::HashMap;
+
 use serde::{Deserialize, Serialize};
 use table::engine::TableReference;
 use table::metadata::{RawTableInfo, TableId};
@@ -21,6 +23,7 @@ use crate::error::Result;
 use crate::key::{to_removed_key, TableMetaKey};
 use crate::kv_backend::txn::{Compare, CompareOp, Txn, TxnOp, TxnOpResponse};
 use crate::kv_backend::KvBackendRef;
+use crate::rpc::store::BatchGetRequest;
 use crate::table_name::TableName;
 
 pub struct TableInfoKey {
@@ -233,6 +236,37 @@ impl TableInfoManager {
             .map(|x| DeserializedValueWithBytes::from_inner_slice(&x.value))
             .transpose()
     }
+
+    pub async fn batch_get(
+        &self,
+        table_ids: &[TableId],
+    ) -> Result<HashMap<TableId, TableInfoValue>> {
+        let lookup_table = table_ids
+            .iter()
+            .map(|id| (TableInfoKey::new(*id).as_raw_key(), id))
+            .collect::<HashMap<_, _>>();
+
+        let resp = self
+            .kv_backend
+            .batch_get(BatchGetRequest {
+                keys: lookup_table.keys().cloned().collect::<Vec<_>>(),
+            })
+            .await?;
+
+        let values = resp
+            .kvs
+            .iter()
+            .map(|kv| {
+                Ok((
+                    // Safety: must exist.
+                    **lookup_table.get(kv.key()).unwrap(),
+                    TableInfoValue::try_from_raw_value(&kv.value)?,
+                ))
+            })
+            .collect::<Result<HashMap<_, _>>>()?;
+
+        Ok(values)
+    }
 }
 
 #[cfg(test)]

src/common/meta/src/key/table_name.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/common/meta/src/key/table_region.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,

src/common/meta/src/key/table_route.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::collections::HashMap;
 use std::fmt::Display;
 
 use serde::{Deserialize, Serialize};
@@ -23,6 +24,7 @@ use crate::key::{to_removed_key, RegionDistribution, TableMetaKey, TABLE_ROUTE_P
 use crate::kv_backend::txn::{Compare, CompareOp, Txn, TxnOp, TxnOpResponse};
 use crate::kv_backend::KvBackendRef;
 use crate::rpc::router::{region_distribution, RegionRoute};
+use crate::rpc::store::BatchGetRequest;
 
 pub struct TableRouteKey {
     pub table_id: TableId,
@@ -197,6 +199,38 @@ impl TableRouteManager {
             .transpose()
     }
 
+    /// It may return a subset of the `table_ids`.
+    pub async fn batch_get(
+        &self,
+        table_ids: &[TableId],
+    ) -> Result<HashMap<TableId, TableRouteValue>> {
+        let lookup_table = table_ids
+            .iter()
+            .map(|id| (TableRouteKey::new(*id).as_raw_key(), id))
+            .collect::<HashMap<_, _>>();
+
+        let resp = self
+            .kv_backend
+            .batch_get(BatchGetRequest {
+                keys: lookup_table.keys().cloned().collect::<Vec<_>>(),
+            })
+            .await?;
+
+        let values = resp
+            .kvs
+            .iter()
+            .map(|kv| {
+                Ok((
+                    // Safety: must exist.
+                    **lookup_table.get(kv.key()).unwrap(),
+                    TableRouteValue::try_from_raw_value(&kv.value)?,
+                ))
+            })
+            .collect::<Result<HashMap<_, _>>>()?;
+
+        Ok(values)
+    }
+
     #[cfg(test)]
     pub async fn get_removed(
         &self,

src/common/meta/src/key/test_utils.rs

@@ -0,0 +1,57 @@
+// 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::sync::Arc;
+
+use datatypes::prelude::ConcreteDataType;
+use datatypes::schema::{ColumnSchema, SchemaBuilder};
+use store_api::storage::TableId;
+use table::metadata::{TableInfo, TableInfoBuilder, TableMetaBuilder};
+
+pub fn new_test_table_info<I: IntoIterator<Item = u32>>(
+    table_id: TableId,
+    region_numbers: I,
+) -> TableInfo {
+    let column_schemas = vec![
+        ColumnSchema::new("col1", ConcreteDataType::int32_datatype(), true),
+        ColumnSchema::new(
+            "ts",
+            ConcreteDataType::timestamp_millisecond_datatype(),
+            false,
+        )
+        .with_time_index(true),
+        ColumnSchema::new("col2", ConcreteDataType::int32_datatype(), true),
+    ];
+    let schema = SchemaBuilder::try_from(column_schemas)
+        .unwrap()
+        .version(123)
+        .build()
+        .unwrap();
+
+    let meta = TableMetaBuilder::default()
+        .schema(Arc::new(schema))
+        .primary_key_indices(vec![0])
+        .engine("engine")
+        .next_column_id(3)
+        .region_numbers(region_numbers.into_iter().collect::<Vec<_>>())
+        .build()
+        .unwrap();
+    TableInfoBuilder::default()
+        .table_id(table_id)
+        .table_version(5)
+        .name("mytable")
+        .meta(meta)
+        .build()
+        .unwrap()
+}

src/common/meta/src/kv_backend.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+pub mod etcd;
 pub mod memory;
 pub mod test;
 pub mod txn;
@@ -27,8 +28,7 @@ use crate::error::Error;
 use crate::rpc::store::{
     BatchDeleteRequest, BatchDeleteResponse, BatchGetRequest, BatchGetResponse, BatchPutRequest,
     BatchPutResponse, CompareAndPutRequest, CompareAndPutResponse, DeleteRangeRequest,
-    DeleteRangeResponse, MoveValueRequest, MoveValueResponse, PutRequest, PutResponse,
-    RangeRequest, RangeResponse,
+    DeleteRangeResponse, PutRequest, PutResponse, RangeRequest, RangeResponse,
 };
 use crate::rpc::KeyValue;
 
@@ -66,9 +66,6 @@ where
         req: BatchDeleteRequest,
     ) -> Result<BatchDeleteResponse, Self::Error>;
 
-    /// MoveValue atomically renames the key to the given updated key.
-    async fn move_value(&self, req: MoveValueRequest) -> Result<MoveValueResponse, Self::Error>;
-
     // The following methods are implemented based on the above methods,
     // and a higher-level interface is provided for to simplify usage.
 
@@ -131,3 +128,12 @@ where
         }
     }
 }
+
+pub trait ResettableKvBackend: KvBackend
+where
+    Self::Error: ErrorExt,
+{
+    fn reset(&self);
+}
+
+pub type ResettableKvBackendRef = Arc<dyn ResettableKvBackend<Error = Error> + Send + Sync>;

src/common/meta/src/kv_backend/etcd.rs

@@ -15,27 +15,47 @@
 use std::any::Any;
 use std::sync::Arc;
 
-use common_meta::kv_backend::txn::{Txn as KvTxn, TxnResponse as KvTxnResponse};
-use common_meta::kv_backend::{KvBackend, TxnService};
-use common_meta::metrics::METRIC_META_TXN_REQUEST;
-use common_meta::rpc::store::{
-    BatchDeleteRequest, BatchDeleteResponse, BatchGetRequest, BatchGetResponse, BatchPutRequest,
-    BatchPutResponse, CompareAndPutRequest, CompareAndPutResponse, DeleteRangeRequest,
-    DeleteRangeResponse, MoveValueRequest, MoveValueResponse, PutRequest, PutResponse,
-    RangeRequest, RangeResponse,
-};
-use common_meta::rpc::KeyValue;
-use common_telemetry::{timer, warn};
 use etcd_client::{
     Client, Compare, CompareOp, DeleteOptions, GetOptions, PutOptions, Txn, TxnOp, TxnOpResponse,
     TxnResponse,
 };
 use snafu::{ensure, OptionExt, ResultExt};
 
-use crate::error;
-use crate::error::{ConvertEtcdTxnObjectSnafu, Error, Result};
-use crate::service::store::etcd_util::KvPair;
-use crate::service::store::kv::KvStoreRef;
+use super::KvBackendRef;
+use crate::error::{self, Error, Result};
+use crate::kv_backend::txn::{Txn as KvTxn, TxnResponse as KvTxnResponse};
+use crate::kv_backend::{KvBackend, TxnService};
+use crate::metrics::METRIC_META_TXN_REQUEST;
+use crate::rpc::store::{
+    BatchDeleteRequest, BatchDeleteResponse, BatchGetRequest, BatchGetResponse, BatchPutRequest,
+    BatchPutResponse, CompareAndPutRequest, CompareAndPutResponse, DeleteRangeRequest,
+    DeleteRangeResponse, PutRequest, PutResponse, RangeRequest, RangeResponse,
+};
+use crate::rpc::KeyValue;
+
+pub struct KvPair<'a>(&'a etcd_client::KeyValue);
+
+impl<'a> KvPair<'a> {
+    /// Creates a `KvPair` from etcd KeyValue
+    #[inline]
+    pub fn new(kv: &'a etcd_client::KeyValue) -> Self {
+        Self(kv)
+    }
+
+    #[inline]
+    pub fn from_etcd_kv(kv: &etcd_client::KeyValue) -> KeyValue {
+        KeyValue::from(KvPair::new(kv))
+    }
+}
+
+impl<'a> From<KvPair<'a>> for KeyValue {
+    fn from(kv: KvPair<'a>) -> Self {
+        Self {
+            key: kv.0.key().to_vec(),
+            value: kv.0.value().to_vec(),
+        }
+    }
+}
 
 // Maximum number of operations permitted in a transaction.
 // The etcd default configuration's `--max-txn-ops` is 128.
@@ -48,7 +68,7 @@ pub struct EtcdStore {
 }
 
 impl EtcdStore {
-    pub async fn with_endpoints<E, S>(endpoints: S) -> Result<KvStoreRef>
+    pub async fn with_endpoints<E, S>(endpoints: S) -> Result<KvBackendRef>
     where
         E: AsRef<str>,
         S: AsRef<[E]>,
@@ -60,7 +80,7 @@ impl EtcdStore {
         Ok(Self::with_etcd_client(client))
     }
 
-    pub fn with_etcd_client(client: Client) -> KvStoreRef {
+    pub fn with_etcd_client(client: Client) -> KvBackendRef {
         Arc::new(Self { client })
     }
 
@@ -289,79 +309,6 @@ impl KvBackend for EtcdStore {
 
         Ok(BatchDeleteResponse { prev_kvs })
     }
-
-    async fn move_value(&self, req: MoveValueRequest) -> Result<MoveValueResponse> {
-        let MoveValue {
-            from_key,
-            to_key,
-            delete_options,
-        } = req.try_into()?;
-
-        let mut client = self.client.kv_client();
-
-        // TODO(jiachun): Maybe it's better to let the users control it in the request
-        const MAX_RETRIES: usize = 8;
-        for _ in 0..MAX_RETRIES {
-            let from_key = from_key.as_slice();
-            let to_key = to_key.as_slice();
-
-            let res = client
-                .get(from_key, None)
-                .await
-                .context(error::EtcdFailedSnafu)?;
-
-            let txn = match res.kvs().first() {
-                None => {
-                    // get `to_key` if `from_key` absent
-                    // revision 0 means key was not exist
-                    let compare = Compare::create_revision(from_key, CompareOp::Equal, 0);
-                    let get = TxnOp::get(to_key, None);
-                    Txn::new().when(vec![compare]).and_then(vec![get])
-                }
-                Some(kv) => {
-                    // compare `from_key` and move to `to_key`
-                    let value = kv.value();
-                    let compare = Compare::value(from_key, CompareOp::Equal, value);
-                    let delete = TxnOp::delete(from_key, delete_options.clone());
-                    let put = TxnOp::put(to_key, value, None);
-                    Txn::new().when(vec![compare]).and_then(vec![delete, put])
-                }
-            };
-
-            let txn_res = client.txn(txn).await.context(error::EtcdFailedSnafu)?;
-
-            if !txn_res.succeeded() {
-                warn!(
-                    "Failed to atomically move {:?} to {:?}, try again...",
-                    String::from_utf8_lossy(from_key),
-                    String::from_utf8_lossy(to_key)
-                );
-                continue;
-            }
-
-            // [`get_res'] or [`delete_res`, `put_res`], `put_res` will be ignored.
-            for op_res in txn_res.op_responses() {
-                match op_res {
-                    TxnOpResponse::Get(res) => {
-                        return Ok(MoveValueResponse(
-                            res.kvs().first().map(KvPair::from_etcd_kv),
-                        ));
-                    }
-                    TxnOpResponse::Delete(res) => {
-                        return Ok(MoveValueResponse(
-                            res.prev_kvs().first().map(KvPair::from_etcd_kv),
-                        ));
-                    }
-                    _ => {}
-                }
-            }
-        }
-
-        error::MoveValueSnafu {
-            key: String::from_utf8_lossy(&from_key),
-        }
-        .fail()
-    }
 }
 
 #[async_trait::async_trait]
@@ -369,10 +316,9 @@ impl TxnService for EtcdStore {
     type Error = Error;
 
     async fn txn(&self, txn: KvTxn) -> Result<KvTxnResponse> {
-        let _timer = timer!(
-            METRIC_META_TXN_REQUEST,
-            &[("target", "etcd".to_string()), ("op", "txn".to_string()),]
-        );
+        let _timer = METRIC_META_TXN_REQUEST
+            .with_label_values(&["etcd", "txn"])
+            .start_timer();
 
         let etcd_txn: Txn = txn.into();
         let txn_res = self
@@ -381,7 +327,7 @@ impl TxnService for EtcdStore {
             .txn(etcd_txn)
             .await
             .context(error::EtcdFailedSnafu)?;
-        txn_res.try_into().context(ConvertEtcdTxnObjectSnafu)
+        txn_res.try_into()
     }
 }
 
@@ -570,26 +516,6 @@ impl TryFrom<DeleteRangeRequest> for Delete {
     }
 }
 
-struct MoveValue {
-    from_key: Vec<u8>,
-    to_key: Vec<u8>,
-    delete_options: Option<DeleteOptions>,
-}
-
-impl TryFrom<MoveValueRequest> for MoveValue {
-    type Error = Error;
-
-    fn try_from(req: MoveValueRequest) -> Result<Self> {
-        let MoveValueRequest { from_key, to_key } = req;
-
-        Ok(MoveValue {
-            from_key,
-            to_key,
-            delete_options: Some(DeleteOptions::default().with_prev_key()),
-        })
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -701,18 +627,4 @@ mod tests {
         assert_eq!(b"test_key".to_vec(), delete.key);
         let _ = delete.options.unwrap();
     }
-
-    #[test]
-    fn test_parse_move_value() {
-        let req = MoveValueRequest {
-            from_key: b"test_from_key".to_vec(),
-            to_key: b"test_to_key".to_vec(),
-        };
-
-        let move_value: MoveValue = req.try_into().unwrap();
-
-        assert_eq!(b"test_from_key".to_vec(), move_value.from_key);
-        assert_eq!(b"test_to_key".to_vec(), move_value.to_key);
-        let _ = move_value.delete_options.unwrap();
-    }
 }

src/common/meta/src/kv_backend/memory.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,
@@ -21,17 +21,16 @@ use std::sync::RwLock;
 
 use async_trait::async_trait;
 use common_error::ext::ErrorExt;
-use common_telemetry::timer;
 use serde::Serializer;
 
+use super::ResettableKvBackend;
 use crate::kv_backend::txn::{Txn, TxnOp, TxnOpResponse, TxnRequest, TxnResponse};
 use crate::kv_backend::{KvBackend, TxnService};
 use crate::metrics::METRIC_META_TXN_REQUEST;
 use crate::rpc::store::{
     BatchDeleteRequest, BatchDeleteResponse, BatchGetRequest, BatchGetResponse, BatchPutRequest,
     BatchPutResponse, CompareAndPutRequest, CompareAndPutResponse, DeleteRangeRequest,
-    DeleteRangeResponse, MoveValueRequest, MoveValueResponse, PutRequest, PutResponse,
-    RangeRequest, RangeResponse,
+    DeleteRangeResponse, PutRequest, PutResponse, RangeRequest, RangeResponse,
 };
 use crate::rpc::KeyValue;
 
@@ -263,27 +262,6 @@ impl<T: ErrorExt + Send + Sync + 'static> KvBackend for MemoryKvBackend<T> {
 
         Ok(BatchDeleteResponse { prev_kvs })
     }
-
-    async fn move_value(&self, req: MoveValueRequest) -> Result<MoveValueResponse, Self::Error> {
-        let MoveValueRequest { from_key, to_key } = req;
-
-        let mut kvs = self.kvs.write().unwrap();
-
-        let kv = if let Some(v) = kvs.remove(&from_key) {
-            kvs.insert(to_key, v.clone());
-            Some(KeyValue {
-                key: from_key,
-                value: v,
-            })
-        } else {
-            kvs.get(&to_key).map(|v| KeyValue {
-                key: to_key,
-                value: v.clone(),
-            })
-        };
-
-        Ok(MoveValueResponse(kv))
-    }
 }
 
 #[async_trait]
@@ -291,10 +269,9 @@ impl<T: ErrorExt + Send + Sync> TxnService for MemoryKvBackend<T> {
     type Error = T;
 
     async fn txn(&self, txn: Txn) -> Result<TxnResponse, Self::Error> {
-        let _timer = timer!(
-            METRIC_META_TXN_REQUEST,
-            &[("target", "memory"), ("op", "txn")]
-        );
+        let _timer = METRIC_META_TXN_REQUEST
+            .with_label_values(&["memory", "txn"])
+            .start_timer();
 
         let TxnRequest {
             compare,
@@ -348,6 +325,12 @@ impl<T: ErrorExt + Send + Sync> TxnService for MemoryKvBackend<T> {
     }
 }
 
+impl<T: ErrorExt + Send + Sync + 'static> ResettableKvBackend for MemoryKvBackend<T> {
+    fn reset(&self) {
+        self.clear();
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
@@ -358,27 +341,26 @@ mod tests {
         prepare_kv, test_kv_batch_delete, test_kv_batch_get, test_kv_compare_and_put,
         test_kv_delete_range, test_kv_put, test_kv_range, test_kv_range_2,
     };
-    use crate::kv_backend::KvBackend;
 
     async fn mock_mem_store_with_data() -> MemoryKvBackend<Error> {
-        let kv_store = MemoryKvBackend::<Error>::new();
-        prepare_kv(&kv_store).await;
+        let kv_backend = MemoryKvBackend::<Error>::new();
+        prepare_kv(&kv_backend).await;
 
-        kv_store
+        kv_backend
     }
 
     #[tokio::test]
     async fn test_put() {
-        let kv_store = mock_mem_store_with_data().await;
+        let kv_backend = mock_mem_store_with_data().await;
 
-        test_kv_put(kv_store).await;
+        test_kv_put(kv_backend).await;
     }
 
     #[tokio::test]
     async fn test_range() {
-        let kv_store = mock_mem_store_with_data().await;
+        let kv_backend = mock_mem_store_with_data().await;
 
-        test_kv_range(kv_store).await;
+        test_kv_range(kv_backend).await;
     }
 
     #[tokio::test]
@@ -390,53 +372,29 @@ mod tests {
 
     #[tokio::test]
     async fn test_batch_get() {
-        let kv_store = mock_mem_store_with_data().await;
+        let kv_backend = mock_mem_store_with_data().await;
 
-        test_kv_batch_get(kv_store).await;
+        test_kv_batch_get(kv_backend).await;
     }
 
     #[tokio::test(flavor = "multi_thread")]
     async fn test_compare_and_put() {
-        let kv_store = Arc::new(MemoryKvBackend::<Error>::new());
+        let kv_backend = Arc::new(MemoryKvBackend::<Error>::new());
 
-        test_kv_compare_and_put(kv_store).await;
+        test_kv_compare_and_put(kv_backend).await;
     }
 
     #[tokio::test]
     async fn test_delete_range() {
-        let kv_store = mock_mem_store_with_data().await;
+        let kv_backend = mock_mem_store_with_data().await;
 
-        test_kv_delete_range(kv_store).await;
-    }
-
-    #[tokio::test]
-    async fn test_move_value() {
-        let kv_store = mock_mem_store_with_data().await;
-
-        let req = MoveValueRequest {
-            from_key: b"key1".to_vec(),
-            to_key: b"key111".to_vec(),
-        };
-
-        let resp = kv_store.move_value(req).await.unwrap();
-        assert_eq!(b"key1", resp.0.as_ref().unwrap().key());
-        assert_eq!(b"val1", resp.0.as_ref().unwrap().value());
-
-        let kv_store = mock_mem_store_with_data().await;
-
-        let req = MoveValueRequest {
-            from_key: b"notexistkey".to_vec(),
-            to_key: b"key222".to_vec(),
-        };
-
-        let resp = kv_store.move_value(req).await.unwrap();
-        assert!(resp.0.is_none());
+        test_kv_delete_range(kv_backend).await;
     }
 
     #[tokio::test]
     async fn test_batch_delete() {
-        let kv_store = mock_mem_store_with_data().await;
+        let kv_backend = mock_mem_store_with_data().await;
 
-        test_kv_batch_delete(kv_store).await;
+        test_kv_batch_delete(kv_backend).await;
     }
 }

src/common/meta/src/kv_backend/test.rs

@@ -38,9 +38,9 @@ pub fn mock_kvs() -> Vec<KeyValue> {
     ]
 }
 
-pub async fn prepare_kv(kv_store: &impl KvBackend) {
+pub async fn prepare_kv(kv_backend: &impl KvBackend) {
     let kvs = mock_kvs();
-    assert!(kv_store
+    assert!(kv_backend
         .batch_put(BatchPutRequest {
             kvs,
             ..Default::default()
@@ -48,7 +48,7 @@ pub async fn prepare_kv(kv_store: &impl KvBackend) {
         .await
         .is_ok());
 
-    assert!(kv_store
+    assert!(kv_backend
         .put(PutRequest {
             key: b"key11".to_vec(),
             value: b"val11".to_vec(),
@@ -58,8 +58,8 @@ pub async fn prepare_kv(kv_store: &impl KvBackend) {
         .is_ok());
 }
 
-pub async fn test_kv_put(kv_store: impl KvBackend) {
-    let resp = kv_store
+pub async fn test_kv_put(kv_backend: impl KvBackend) {
+    let resp = kv_backend
         .put(PutRequest {
             key: b"key11".to_vec(),
             value: b"val12".to_vec(),
@@ -69,7 +69,7 @@ pub async fn test_kv_put(kv_store: impl KvBackend) {
         .unwrap();
     assert!(resp.prev_kv.is_none());
 
-    let resp = kv_store
+    let resp = kv_backend
         .put(PutRequest {
             key: b"key11".to_vec(),
             value: b"val13".to_vec(),
@@ -82,11 +82,11 @@ pub async fn test_kv_put(kv_store: impl KvBackend) {
     assert_eq!(b"val12", prev_kv.value());
 }
 
-pub async fn test_kv_range(kv_store: impl KvBackend) {
+pub async fn test_kv_range(kv_backend: impl KvBackend) {
     let key = b"key1".to_vec();
     let range_end = util::get_prefix_end_key(b"key1");
 
-    let resp = kv_store
+    let resp = kv_backend
         .range(RangeRequest {
             key: key.clone(),
             range_end: range_end.clone(),
@@ -102,7 +102,7 @@ pub async fn test_kv_range(kv_store: impl KvBackend) {
     assert_eq!(b"key11", resp.kvs[1].key());
     assert_eq!(b"val11", resp.kvs[1].value());
 
-    let resp = kv_store
+    let resp = kv_backend
         .range(RangeRequest {
             key: key.clone(),
             range_end: range_end.clone(),
@@ -118,7 +118,7 @@ pub async fn test_kv_range(kv_store: impl KvBackend) {
     assert_eq!(b"key11", resp.kvs[1].key());
     assert_eq!(b"", resp.kvs[1].value());
 
-    let resp = kv_store
+    let resp = kv_backend
         .range(RangeRequest {
             key: key.clone(),
             limit: 0,
@@ -132,7 +132,7 @@ pub async fn test_kv_range(kv_store: impl KvBackend) {
     assert_eq!(b"key1", resp.kvs[0].key());
     assert_eq!(b"val1", resp.kvs[0].value());
 
-    let resp = kv_store
+    let resp = kv_backend
         .range(RangeRequest {
             key,
             range_end,
@@ -147,19 +147,19 @@ pub async fn test_kv_range(kv_store: impl KvBackend) {
     assert_eq!(b"val1", resp.kvs[0].value());
 }
 
-pub async fn test_kv_range_2(kv_store: impl KvBackend) {
-    kv_store
+pub async fn test_kv_range_2(kv_backend: impl KvBackend) {
+    kv_backend
         .put(PutRequest::new().with_key("atest").with_value("value"))
         .await
         .unwrap();
 
-    kv_store
+    kv_backend
         .put(PutRequest::new().with_key("test").with_value("value"))
         .await
         .unwrap();
 
     // If both key and range_end are ‘\0’, then range represents all keys.
-    let result = kv_store
+    let result = kv_backend
         .range(RangeRequest::new().with_range(b"\0".to_vec(), b"\0".to_vec()))
         .await
         .unwrap();
@@ -168,14 +168,14 @@ pub async fn test_kv_range_2(kv_store: impl KvBackend) {
     assert!(!result.more);
 
     // If range_end is ‘\0’, the range is all keys greater than or equal to the key argument.
-    let result = kv_store
+    let result = kv_backend
         .range(RangeRequest::new().with_range(b"a".to_vec(), b"\0".to_vec()))
         .await
         .unwrap();
 
     assert_eq!(result.kvs.len(), 2);
 
-    let result = kv_store
+    let result = kv_backend
         .range(RangeRequest::new().with_range(b"b".to_vec(), b"\0".to_vec()))
         .await
         .unwrap();
@@ -184,7 +184,7 @@ pub async fn test_kv_range_2(kv_store: impl KvBackend) {
     assert_eq!(result.kvs[0].key, b"test");
 
     // Fetches the keys >= "a", set limit to 1, the `more` should be true.
-    let result = kv_store
+    let result = kv_backend
         .range(
             RangeRequest::new()
                 .with_range(b"a".to_vec(), b"\0".to_vec())
@@ -196,7 +196,7 @@ pub async fn test_kv_range_2(kv_store: impl KvBackend) {
     assert!(result.more);
 
     // Fetches the keys >= "a", set limit to 2, the `more` should be false.
-    let result = kv_store
+    let result = kv_backend
         .range(
             RangeRequest::new()
                 .with_range(b"a".to_vec(), b"\0".to_vec())
@@ -208,7 +208,7 @@ pub async fn test_kv_range_2(kv_store: impl KvBackend) {
     assert!(!result.more);
 
     // Fetches the keys >= "a", set limit to 3, the `more` should be false.
-    let result = kv_store
+    let result = kv_backend
         .range(
             RangeRequest::new()
                 .with_range(b"a".to_vec(), b"\0".to_vec())
@@ -220,19 +220,28 @@ pub async fn test_kv_range_2(kv_store: impl KvBackend) {
     assert!(!result.more);
 }
 
-pub async fn test_kv_batch_get(kv_store: impl KvBackend) {
+pub async fn test_kv_batch_get(kv_backend: impl KvBackend) {
     let keys = vec![];
-    let resp = kv_store.batch_get(BatchGetRequest { keys }).await.unwrap();
+    let resp = kv_backend
+        .batch_get(BatchGetRequest { keys })
+        .await
+        .unwrap();
 
     assert!(resp.kvs.is_empty());
 
     let keys = vec![b"key10".to_vec()];
-    let resp = kv_store.batch_get(BatchGetRequest { keys }).await.unwrap();
+    let resp = kv_backend
+        .batch_get(BatchGetRequest { keys })
+        .await
+        .unwrap();
 
     assert!(resp.kvs.is_empty());
 
     let keys = vec![b"key1".to_vec(), b"key3".to_vec(), b"key4".to_vec()];
-    let resp = kv_store.batch_get(BatchGetRequest { keys }).await.unwrap();
+    let resp = kv_backend
+        .batch_get(BatchGetRequest { keys })
+        .await
+        .unwrap();
 
     assert_eq!(2, resp.kvs.len());
     assert_eq!(b"key1", resp.kvs[0].key());
@@ -241,12 +250,12 @@ pub async fn test_kv_batch_get(kv_store: impl KvBackend) {
     assert_eq!(b"val3", resp.kvs[1].value());
 }
 
-pub async fn test_kv_compare_and_put(kv_store: Arc<dyn KvBackend<Error = Error>>) {
+pub async fn test_kv_compare_and_put(kv_backend: Arc<dyn KvBackend<Error = Error>>) {
     let success = Arc::new(AtomicU8::new(0));
 
     let mut joins = vec![];
     for _ in 0..20 {
-        let kv_store_clone = kv_store.clone();
+        let kv_backend_clone = kv_backend.clone();
         let success_clone = success.clone();
         let join = tokio::spawn(async move {
             let req = CompareAndPutRequest {
@@ -254,7 +263,7 @@ pub async fn test_kv_compare_and_put(kv_store: Arc<dyn KvBackend<Error = Error>>
                 expect: vec![],
                 value: b"val_new".to_vec(),
             };
-            let resp = kv_store_clone.compare_and_put(req).await.unwrap();
+            let resp = kv_backend_clone.compare_and_put(req).await.unwrap();
             if resp.success {
                 success_clone.fetch_add(1, Ordering::SeqCst);
             }
@@ -269,20 +278,20 @@ pub async fn test_kv_compare_and_put(kv_store: Arc<dyn KvBackend<Error = Error>>
     assert_eq!(1, success.load(Ordering::SeqCst));
 }
 
-pub async fn test_kv_delete_range(kv_store: impl KvBackend) {
+pub async fn test_kv_delete_range(kv_backend: impl KvBackend) {
     let req = DeleteRangeRequest {
         key: b"key3".to_vec(),
         range_end: vec![],
         prev_kv: true,
     };
 
-    let resp = kv_store.delete_range(req).await.unwrap();
+    let resp = kv_backend.delete_range(req).await.unwrap();
     assert_eq!(1, resp.prev_kvs.len());
     assert_eq!(1, resp.deleted);
     assert_eq!(b"key3", resp.prev_kvs[0].key());
     assert_eq!(b"val3", resp.prev_kvs[0].value());
 
-    let resp = kv_store.get(b"key3").await.unwrap();
+    let resp = kv_backend.get(b"key3").await.unwrap();
     assert!(resp.is_none());
 
     let req = DeleteRangeRequest {
@@ -291,11 +300,11 @@ pub async fn test_kv_delete_range(kv_store: impl KvBackend) {
         prev_kv: false,
     };
 
-    let resp = kv_store.delete_range(req).await.unwrap();
+    let resp = kv_backend.delete_range(req).await.unwrap();
     assert_eq!(1, resp.deleted);
     assert!(resp.prev_kvs.is_empty());
 
-    let resp = kv_store.get(b"key2").await.unwrap();
+    let resp = kv_backend.get(b"key2").await.unwrap();
     assert!(resp.is_none());
 
     let key = b"key1".to_vec();
@@ -306,7 +315,7 @@ pub async fn test_kv_delete_range(kv_store: impl KvBackend) {
         range_end: range_end.clone(),
         prev_kv: true,
     };
-    let resp = kv_store.delete_range(req).await.unwrap();
+    let resp = kv_backend.delete_range(req).await.unwrap();
     assert_eq!(2, resp.prev_kvs.len());
 
     let req = RangeRequest {
@@ -314,19 +323,19 @@ pub async fn test_kv_delete_range(kv_store: impl KvBackend) {
         range_end,
         ..Default::default()
     };
-    let resp = kv_store.range(req).await.unwrap();
+    let resp = kv_backend.range(req).await.unwrap();
     assert!(resp.kvs.is_empty());
 }
 
-pub async fn test_kv_batch_delete(kv_store: impl KvBackend) {
-    assert!(kv_store.get(b"key1").await.unwrap().is_some());
-    assert!(kv_store.get(b"key100").await.unwrap().is_none());
+pub async fn test_kv_batch_delete(kv_backend: impl KvBackend) {
+    assert!(kv_backend.get(b"key1").await.unwrap().is_some());
+    assert!(kv_backend.get(b"key100").await.unwrap().is_none());
 
     let req = BatchDeleteRequest {
         keys: vec![b"key1".to_vec(), b"key100".to_vec()],
         prev_kv: true,
     };
-    let resp = kv_store.batch_delete(req).await.unwrap();
+    let resp = kv_backend.batch_delete(req).await.unwrap();
     assert_eq!(1, resp.prev_kvs.len());
     assert_eq!(
         vec![KeyValue {
@@ -335,18 +344,18 @@ pub async fn test_kv_batch_delete(kv_store: impl KvBackend) {
         }],
         resp.prev_kvs
     );
-    assert!(kv_store.get(b"key1").await.unwrap().is_none());
+    assert!(kv_backend.get(b"key1").await.unwrap().is_none());
 
-    assert!(kv_store.get(b"key2").await.unwrap().is_some());
-    assert!(kv_store.get(b"key3").await.unwrap().is_some());
+    assert!(kv_backend.get(b"key2").await.unwrap().is_some());
+    assert!(kv_backend.get(b"key3").await.unwrap().is_some());
 
     let req = BatchDeleteRequest {
         keys: vec![b"key2".to_vec(), b"key3".to_vec()],
         prev_kv: false,
     };
-    let resp = kv_store.batch_delete(req).await.unwrap();
+    let resp = kv_backend.batch_delete(req).await.unwrap();
     assert!(resp.prev_kvs.is_empty());
 
-    assert!(kv_store.get(b"key2").await.unwrap().is_none());
-    assert!(kv_store.get(b"key3").await.unwrap().is_none());
+    assert!(kv_backend.get(b"key2").await.unwrap().is_none());
+    assert!(kv_backend.get(b"key3").await.unwrap().is_none());
 }

src/common/meta/src/kv_backend/txn.rs

@@ -268,9 +268,9 @@ mod tests {
 
     #[tokio::test]
     async fn test_txn_one_compare_op() {
-        let kv_store = create_kv_store().await;
+        let kv_backend = create_kv_backend().await;
 
-        let _ = kv_store
+        let _ = kv_backend
             .put(PutRequest {
                 key: vec![11],
                 value: vec![3],
@@ -288,7 +288,7 @@ mod tests {
             .and_then(vec![TxnOp::Put(vec![11], vec![1])])
             .or_else(vec![TxnOp::Put(vec![11], vec![2])]);
 
-        let txn_response = kv_store.txn(txn).await.unwrap();
+        let txn_response = kv_backend.txn(txn).await.unwrap();
 
         assert!(txn_response.succeeded);
         assert_eq!(txn_response.responses.len(), 1);
@@ -296,10 +296,10 @@ mod tests {
 
     #[tokio::test]
     async fn test_txn_multi_compare_op() {
-        let kv_store = create_kv_store().await;
+        let kv_backend = create_kv_backend().await;
 
         for i in 1..3 {
-            let _ = kv_store
+            let _ = kv_backend
                 .put(PutRequest {
                     key: vec![i],
                     value: vec![i],
@@ -321,7 +321,7 @@ mod tests {
             ])
             .or_else(vec![TxnOp::Put(vec![1], vec![11])]);
 
-        let txn_response = kv_store.txn(txn).await.unwrap();
+        let txn_response = kv_backend.txn(txn).await.unwrap();
 
         assert!(txn_response.succeeded);
         assert_eq!(txn_response.responses.len(), 2);
@@ -329,9 +329,9 @@ mod tests {
 
     #[tokio::test]
     async fn test_txn_compare_equal() {
-        let kv_store = create_kv_store().await;
+        let kv_backend = create_kv_backend().await;
         let key = vec![101u8];
-        kv_store.delete(&key, false).await.unwrap();
+        kv_backend.delete(&key, false).await.unwrap();
 
         let txn = Txn::new()
             .when(vec![Compare::with_not_exist_value(
@@ -340,10 +340,10 @@ mod tests {
             )])
             .and_then(vec![TxnOp::Put(key.clone(), vec![1])])
             .or_else(vec![TxnOp::Put(key.clone(), vec![2])]);
-        let txn_response = kv_store.txn(txn.clone()).await.unwrap();
+        let txn_response = kv_backend.txn(txn.clone()).await.unwrap();
         assert!(txn_response.succeeded);
 
-        let txn_response = kv_store.txn(txn).await.unwrap();
+        let txn_response = kv_backend.txn(txn).await.unwrap();
         assert!(!txn_response.succeeded);
 
         let txn = Txn::new()
@@ -354,15 +354,15 @@ mod tests {
             )])
             .and_then(vec![TxnOp::Put(key.clone(), vec![3])])
             .or_else(vec![TxnOp::Put(key, vec![4])]);
-        let txn_response = kv_store.txn(txn).await.unwrap();
+        let txn_response = kv_backend.txn(txn).await.unwrap();
         assert!(txn_response.succeeded);
     }
 
     #[tokio::test]
     async fn test_txn_compare_greater() {
-        let kv_store = create_kv_store().await;
+        let kv_backend = create_kv_backend().await;
         let key = vec![102u8];
-        kv_store.delete(&key, false).await.unwrap();
+        kv_backend.delete(&key, false).await.unwrap();
 
         let txn = Txn::new()
             .when(vec![Compare::with_not_exist_value(
@@ -371,10 +371,10 @@ mod tests {
             )])
             .and_then(vec![TxnOp::Put(key.clone(), vec![1])])
             .or_else(vec![TxnOp::Put(key.clone(), vec![2])]);
-        let txn_response = kv_store.txn(txn.clone()).await.unwrap();
+        let txn_response = kv_backend.txn(txn.clone()).await.unwrap();
         assert!(!txn_response.succeeded);
 
-        let txn_response = kv_store.txn(txn).await.unwrap();
+        let txn_response = kv_backend.txn(txn).await.unwrap();
         assert!(txn_response.succeeded);
 
         let txn = Txn::new()
@@ -385,7 +385,7 @@ mod tests {
             )])
             .and_then(vec![TxnOp::Put(key.clone(), vec![3])])
             .or_else(vec![TxnOp::Get(key.clone())]);
-        let mut txn_response = kv_store.txn(txn).await.unwrap();
+        let mut txn_response = kv_backend.txn(txn).await.unwrap();
         assert!(!txn_response.succeeded);
         let res = txn_response.responses.pop().unwrap();
         assert_eq!(
@@ -402,9 +402,9 @@ mod tests {
 
     #[tokio::test]
     async fn test_txn_compare_less() {
-        let kv_store = create_kv_store().await;
+        let kv_backend = create_kv_backend().await;
         let key = vec![103u8];
-        kv_store.delete(&[3], false).await.unwrap();
+        kv_backend.delete(&[3], false).await.unwrap();
 
         let txn = Txn::new()
             .when(vec![Compare::with_not_exist_value(
@@ -413,10 +413,10 @@ mod tests {
             )])
             .and_then(vec![TxnOp::Put(key.clone(), vec![1])])
             .or_else(vec![TxnOp::Put(key.clone(), vec![2])]);
-        let txn_response = kv_store.txn(txn.clone()).await.unwrap();
+        let txn_response = kv_backend.txn(txn.clone()).await.unwrap();
         assert!(!txn_response.succeeded);
 
-        let txn_response = kv_store.txn(txn).await.unwrap();
+        let txn_response = kv_backend.txn(txn).await.unwrap();
         assert!(!txn_response.succeeded);
 
         let txn = Txn::new()
@@ -427,7 +427,7 @@ mod tests {
             )])
             .and_then(vec![TxnOp::Put(key.clone(), vec![3])])
             .or_else(vec![TxnOp::Get(key.clone())]);
-        let mut txn_response = kv_store.txn(txn).await.unwrap();
+        let mut txn_response = kv_backend.txn(txn).await.unwrap();
         assert!(!txn_response.succeeded);
         let res = txn_response.responses.pop().unwrap();
         assert_eq!(
@@ -444,9 +444,9 @@ mod tests {
 
     #[tokio::test]
     async fn test_txn_compare_not_equal() {
-        let kv_store = create_kv_store().await;
+        let kv_backend = create_kv_backend().await;
         let key = vec![104u8];
-        kv_store.delete(&key, false).await.unwrap();
+        kv_backend.delete(&key, false).await.unwrap();
 
         let txn = Txn::new()
             .when(vec![Compare::with_not_exist_value(
@@ -455,10 +455,10 @@ mod tests {
             )])
             .and_then(vec![TxnOp::Put(key.clone(), vec![1])])
             .or_else(vec![TxnOp::Put(key.clone(), vec![2])]);
-        let txn_response = kv_store.txn(txn.clone()).await.unwrap();
+        let txn_response = kv_backend.txn(txn.clone()).await.unwrap();
         assert!(!txn_response.succeeded);
 
-        let txn_response = kv_store.txn(txn).await.unwrap();
+        let txn_response = kv_backend.txn(txn).await.unwrap();
         assert!(txn_response.succeeded);
 
         let txn = Txn::new()
@@ -469,7 +469,7 @@ mod tests {
             )])
             .and_then(vec![TxnOp::Put(key.clone(), vec![3])])
             .or_else(vec![TxnOp::Get(key.clone())]);
-        let mut txn_response = kv_store.txn(txn).await.unwrap();
+        let mut txn_response = kv_backend.txn(txn).await.unwrap();
         assert!(!txn_response.succeeded);
         let res = txn_response.responses.pop().unwrap();
         assert_eq!(
@@ -484,7 +484,7 @@ mod tests {
         );
     }
 
-    async fn create_kv_store() -> KvBackendRef {
+    async fn create_kv_backend() -> KvBackendRef {
         Arc::new(MemoryKvBackend::<Error>::new())
         // TODO(jiachun): Add a feature to test against etcd in github CI
         //

src/common/meta/src/lib.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#![feature(assert_matches)]
 #![feature(btree_extract_if)]
 #![feature(async_closure)]
 

src/common/meta/src/metrics.rs

@@ -12,11 +12,42 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-pub const METRIC_META_TXN_REQUEST: &str = "meta.txn_request";
+use lazy_static::lazy_static;
+use prometheus::*;
 
-pub(crate) const METRIC_META_CREATE_CATALOG: &str = "meta.create_catalog";
-pub(crate) const METRIC_META_CREATE_SCHEMA: &str = "meta.create_schema";
-pub(crate) const METRIC_META_PROCEDURE_CREATE_TABLE: &str = "meta.procedure.create_table";
-pub(crate) const METRIC_META_PROCEDURE_DROP_TABLE: &str = "meta.procedure.drop_table";
-pub(crate) const METRIC_META_PROCEDURE_ALTER_TABLE: &str = "meta.procedure.alter_table";
-pub(crate) const METRIC_META_PROCEDURE_TRUNCATE_TABLE: &str = "meta.procedure.truncate_table";
+lazy_static! {
+    pub static ref METRIC_META_TXN_REQUEST: HistogramVec =
+        register_histogram_vec!("meta_txn_request", "meta txn request", &["target", "op"]).unwrap();
+    pub static ref METRIC_META_CREATE_CATALOG: Histogram =
+        register_histogram!("meta_create_catalog", "meta create catalog").unwrap();
+    pub static ref METRIC_META_CREATE_CATALOG_COUNTER: IntCounter =
+        register_int_counter!("meta_create_catalog_counter", "meta create catalog").unwrap();
+    pub static ref METRIC_META_CREATE_SCHEMA: Histogram =
+        register_histogram!("meta_create_schema", "meta create schema").unwrap();
+    pub static ref METRIC_META_CREATE_SCHEMA_COUNTER: IntCounter =
+        register_int_counter!("meta_create_schema_counter", "meta create schema").unwrap();
+    pub static ref METRIC_META_PROCEDURE_CREATE_TABLE: HistogramVec = register_histogram_vec!(
+        "meta_procedure_create_table",
+        "meta procedure create table",
+        &["step"]
+    )
+    .unwrap();
+    pub static ref METRIC_META_PROCEDURE_DROP_TABLE: HistogramVec = register_histogram_vec!(
+        "meta_procedure_drop_table",
+        "meta procedure drop table",
+        &["step"]
+    )
+    .unwrap();
+    pub static ref METRIC_META_PROCEDURE_ALTER_TABLE: HistogramVec = register_histogram_vec!(
+        "meta_procedure_alter_table",
+        "meta procedure alter table",
+        &["step"]
+    )
+    .unwrap();
+    pub static ref METRIC_META_PROCEDURE_TRUNCATE_TABLE: HistogramVec = register_histogram_vec!(
+        "meta_procedure_truncate_table",
+        "meta procedure truncate table",
+        &["step"]
+    )
+    .unwrap();
+}

src/common/meta/src/peer.rs

@@ -4,7 +4,7 @@
 // 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
+//     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,
@@ -49,6 +49,14 @@ impl Peer {
             addr: addr.into(),
         }
     }
+
+    #[cfg(any(test, feature = "testing"))]
+    pub fn empty(id: u64) -> Self {
+        Self {
+            id,
+            addr: String::new(),
+        }
+    }
 }
 
 impl Display for Peer {