test!:Update config.yml

2026-01-06 05:12:54 +00:00 · 2025-05-21 15:47:40 +08:00
225 changed files with 2245 additions and 7170 deletions
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -2,7 +2,7 @@ blank_issues_enabled: false
 contact_links:
  - name: Greptime Community Slack
    url: https://greptime.com/slack
-    about: Get free help from the Greptime community
+    about: Get free help from the Greptime community.
  - name: Greptime Community Discussion
    url: https://github.com/greptimeTeam/discussions
-    about: Get free help from the Greptime community
+    about: Get free help from the Greptime community.
--- a/.github/actions/build-linux-artifacts/action.yml
+++ b/.github/actions/build-linux-artifacts/action.yml
@@ -52,7 +52,7 @@ runs:
      uses: ./.github/actions/build-greptime-binary
      with:
        base-image: ubuntu
-        features: servers/dashboard
+        features: servers/dashboard,pg_kvbackend,mysql_kvbackend
        cargo-profile: ${{ inputs.cargo-profile }}
        artifacts-dir: greptime-linux-${{ inputs.arch }}-${{ inputs.version }}
        version: ${{ inputs.version }}
@@ -70,7 +70,7 @@ runs:
      if: ${{ inputs.arch == 'amd64' && inputs.dev-mode == 'false' }} # Builds greptime for centos if the host machine is amd64.
      with:
        base-image: centos
-        features: servers/dashboard
+        features: servers/dashboard,pg_kvbackend,mysql_kvbackend
        cargo-profile: ${{ inputs.cargo-profile }}
        artifacts-dir: greptime-linux-${{ inputs.arch }}-centos-${{ inputs.version }}
        version: ${{ inputs.version }}
--- a/.github/scripts/create-version.sh
+++ b/.github/scripts/create-version.sh
@@ -16,8 +16,7 @@ function create_version() {

  if [ -z "$NEXT_RELEASE_VERSION" ]; then
      echo "NEXT_RELEASE_VERSION is empty, use version from Cargo.toml" >&2
-      # NOTE: Need a `v` prefix for the version string.
-      export NEXT_RELEASE_VERSION=v$(grep '^version = ' Cargo.toml | cut -d '"' -f 2 | head -n 1)
+      export NEXT_RELEASE_VERSION=$(grep '^version = ' Cargo.toml | cut -d '"' -f 2 | head -n 1)
  fi

  if [ -z "$NIGHTLY_RELEASE_PREFIX" ]; then
--- a/.github/workflows/develop.yml
+++ b/.github/workflows/develop.yml
@@ -195,7 +195,6 @@ jobs:
    runs-on: ubuntu-latest
    timeout-minutes: 60
    strategy:
-      fail-fast: false
      matrix:
        target: [ "unstable_fuzz_create_table_standalone" ]
    steps:
@@ -300,7 +299,6 @@ jobs:
    needs:  build-greptime-ci
    timeout-minutes: 60
    strategy:
-      fail-fast: false
      matrix:
        target: [ "fuzz_create_table", "fuzz_alter_table", "fuzz_create_database", "fuzz_create_logical_table", "fuzz_alter_logical_table", "fuzz_insert", "fuzz_insert_logical_table" ]
        mode:
@@ -433,7 +431,6 @@ jobs:
    needs:  build-greptime-ci
    timeout-minutes: 60
    strategy:
-      fail-fast: false
      matrix:
        target: ["fuzz_migrate_mito_regions", "fuzz_migrate_metric_regions", "fuzz_failover_mito_regions", "fuzz_failover_metric_regions"]
        mode:
@@ -581,7 +578,6 @@ jobs:
    needs: build
    runs-on: ${{ matrix.os }}
    strategy:
-      fail-fast: false
      matrix:
        os: [ ubuntu-latest ]
        mode:
--- a/.github/workflows/nightly-ci.yml
+++ b/.github/workflows/nightly-ci.yml
@@ -124,7 +124,9 @@ jobs:
          fetch-depth: 0
          persist-credentials: false
      - uses: cachix/install-nix-action@v31
-      - run: nix develop --command cargo check --bin greptime
+        with:
+          nix_path: nixpkgs=channel:nixos-24.11
+      - run: nix develop --command cargo build --bin greptime
        env:
          CARGO_BUILD_RUSTFLAGS: "-C link-arg=-fuse-ld=mold"

--- a/.github/workflows/semantic-pull-request.yml
+++ b/.github/workflows/semantic-pull-request.yml
@@ -16,7 +16,6 @@ jobs:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write  # Add permissions to modify PRs
-      issues: write
    timeout-minutes: 10
    steps:
      - uses: actions/checkout@v4
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -108,7 +108,7 @@ of what you were trying to do and what went wrong. You can also reach for help i
 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)
+- [GreptimeDB Github Discussions](https://github.com/GreptimeTeam/greptimedb/discussions)

 Also, see some extra GreptimeDB content:

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1852,9 +1852,8 @@ dependencies = [
 "futures",
 "humantime",
 "meta-client",
- "meta-srv",
 "nu-ansi-term",
- "object-store",
+ "opendal 0.51.2",
 "query",
 "rand 0.9.0",
 "reqwest",
@@ -1890,7 +1889,6 @@ dependencies = [
 "common-query",
 "common-recordbatch",
 "common-telemetry",
- "datatypes",
 "enum_dispatch",
 "futures",
 "futures-util",
@@ -2225,7 +2223,6 @@ version = "0.15.0"
 dependencies = [
 "api",
 "arrow-flight",
- "bytes",
 "common-base",
 "common-error",
 "common-macro",
@@ -2323,7 +2320,6 @@ dependencies = [
 "common-query",
 "common-recordbatch",
 "common-telemetry",
- "common-test-util",
 "common-time",
 "common-wal",
 "common-workload",
@@ -2334,7 +2330,6 @@ dependencies = [
 "deadpool-postgres",
 "derive_builder 0.20.1",
 "etcd-client",
- "flexbuffers",
 "futures",
 "futures-util",
 "hex",
@@ -2343,7 +2338,6 @@ dependencies = [
 "itertools 0.14.0",
 "lazy_static",
 "moka",
- "object-store",
 "prometheus",
 "prost 0.13.5",
 "rand 0.9.0",
@@ -2542,7 +2536,6 @@ name = "common-test-util"
 version = "0.15.0"
 dependencies = [
 "client",
- "common-grpc",
 "common-query",
 "common-recordbatch",
 "once_cell",
@@ -4265,19 +4258,6 @@ dependencies = [
 "miniz_oxide",
 ]

-[[package]]
-name = "flexbuffers"
-version = "25.2.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "935627e7bc8f083035d9faad09ffaed9128f73fb1f74a8798f115749c43378e8"
-dependencies = [
- "bitflags 1.3.2",
- "byteorder",
- "num_enum 0.5.11",
- "serde",
- "serde_derive",
-]
-
 [[package]]
 name = "float-cmp"
 version = "0.10.0"
@@ -4372,7 +4352,6 @@ dependencies = [
 "session",
 "smallvec",
 "snafu 0.8.5",
- "sql",
 "store-api",
 "strum 0.27.1",
 "substrait 0.15.0",
@@ -4876,7 +4855,7 @@ dependencies = [
 [[package]]
 name = "greptime-proto"
 version = "0.1.0"
-source = "git+https://github.com/GreptimeTeam/greptime-proto.git?rev=442348b2518c0bf187fb1ad011ba370c38b96cc4#442348b2518c0bf187fb1ad011ba370c38b96cc4"
+source = "git+https://github.com/GreptimeTeam/greptime-proto.git?rev=7668a882d57ca6a2333146e0574b8f0c9d5008ae#7668a882d57ca6a2333146e0574b8f0c9d5008ae"
 dependencies = [
 "prost 0.13.5",
 "serde",
@@ -6976,7 +6955,6 @@ dependencies = [
 "common-decimal",
 "common-error",
 "common-function",
- "common-grpc",
 "common-macro",
 "common-meta",
 "common-query",
@@ -7594,34 +7572,13 @@ dependencies = [
 "libc",
 ]

-[[package]]
-name = "num_enum"
-version = "0.5.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f646caf906c20226733ed5b1374287eb97e3c2a5c227ce668c1f2ce20ae57c9"
-dependencies = [
- "num_enum_derive 0.5.11",
-]
-
 [[package]]
 name = "num_enum"
 version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179"
 dependencies = [
- "num_enum_derive 0.7.3",
-]
-
-[[package]]
-name = "num_enum_derive"
-version = "0.5.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcbff9bc912032c62bf65ef1d5aea88983b420f4f839db1e9b0c281a25c9c799"
-dependencies = [
- "proc-macro-crate 1.3.1",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
+ "num_enum_derive",
 ]

 [[package]]
@@ -7675,7 +7632,7 @@ dependencies = [
 "lazy_static",
 "md5",
 "moka",
- "opendal",
+ "opendal 0.52.0",
 "prometheus",
 "tokio",
 "uuid",
@@ -7714,7 +7671,7 @@ dependencies = [
 "futures",
 "futures-util",
 "object_store",
- "opendal",
+ "opendal 0.52.0",
 "pin-project",
 "tokio",
 ]
@@ -7740,6 +7697,35 @@ version = "11.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b410bbe7e14ab526a0e86877eb47c6996a2bd7746f027ba551028c925390e4e9"

+[[package]]
+name = "opendal"
+version = "0.51.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b1063ea459fa9e94584115743b06330f437902dd1d9f692b863ef1875a20548"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "backon",
+ "base64 0.22.1",
+ "bytes",
+ "chrono",
+ "crc32c",
+ "futures",
+ "getrandom 0.2.15",
+ "http 1.1.0",
+ "log",
+ "md-5",
+ "once_cell",
+ "percent-encoding",
+ "quick-xml 0.36.2",
+ "reqsign",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "tokio",
+ "uuid",
+]
+
 [[package]]
 name = "opendal"
 version = "0.52.0"
@@ -8091,7 +8077,7 @@ dependencies = [
 "arrow 53.4.1",
 "arrow-ipc 53.4.1",
 "lazy_static",
- "num_enum 0.7.3",
+ "num_enum",
 "opentelemetry-proto 0.27.0",
 "paste",
 "prost 0.13.5",
@@ -8428,9 +8414,9 @@ dependencies = [

 [[package]]
 name = "pgwire"
-version = "0.30.1"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec79ee18e6cafde8698885646780b967ecc905120798b8359dd0da64f9688e89"
+checksum = "a4e6fcdc2ae2173ef8ee1005b6e46453d45195ac3d97caac0db7ecf64ab4aa85"
 dependencies = [
 "async-trait",
 "bytes",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -132,7 +132,7 @@ etcd-client = "0.14"
 fst = "0.4.7"
 futures = "0.3"
 futures-util = "0.3"
-greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "442348b2518c0bf187fb1ad011ba370c38b96cc4" }
+greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "7668a882d57ca6a2333146e0574b8f0c9d5008ae" }
 hex = "0.4"
 http = "1"
 humantime = "2.1"
--- a/config/config.md
+++ b/config/config.md
@@ -27,7 +27,6 @@
 | `http.body_limit` | String | `64MB` | HTTP request body limit.<br/>The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.<br/>Set to 0 to disable limit. |
 | `http.enable_cors` | Bool | `true` | HTTP CORS support, it's turned on by default<br/>This allows browser to access http APIs without CORS restrictions |
 | `http.cors_allowed_origins` | Array | Unset | Customize allowed origins for HTTP CORS. |
-| `http.prom_validation_mode` | String | `strict` | Whether to enable validation for Prometheus remote write requests.<br/>Available options:<br/>- strict: deny invalid UTF-8 strings (default).<br/>- lossy: allow invalid UTF-8 strings, replace invalid characters with REPLACEMENT_CHARACTER(U+FFFD).<br/>- unchecked: do not valid strings. |
 | `grpc` | -- | -- | The gRPC server options. |
 | `grpc.bind_addr` | String | `127.0.0.1:4001` | The address to bind the gRPC server. |
 | `grpc.runtime_size` | Integer | `8` | The number of server worker threads. |
@@ -227,7 +226,6 @@
 | `http.body_limit` | String | `64MB` | HTTP request body limit.<br/>The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.<br/>Set to 0 to disable limit. |
 | `http.enable_cors` | Bool | `true` | HTTP CORS support, it's turned on by default<br/>This allows browser to access http APIs without CORS restrictions |
 | `http.cors_allowed_origins` | Array | Unset | Customize allowed origins for HTTP CORS. |
-| `http.prom_validation_mode` | String | `strict` | Whether to enable validation for Prometheus remote write requests.<br/>Available options:<br/>- strict: deny invalid UTF-8 strings (default).<br/>- lossy: allow invalid UTF-8 strings, replace invalid characters with REPLACEMENT_CHARACTER(U+FFFD).<br/>- unchecked: do not valid strings. |
 | `grpc` | -- | -- | The gRPC server options. |
 | `grpc.bind_addr` | String | `127.0.0.1:4001` | The address to bind the gRPC server. |
 | `grpc.server_addr` | String | `127.0.0.1:4001` | The address advertised to the metasrv, and used for connections from outside the host.<br/>If left empty or unset, the server will automatically use the IP address of the first network interface<br/>on the host, with the same port number as the one specified in `grpc.bind_addr`. |
@@ -331,10 +329,6 @@
 | `runtime` | -- | -- | The runtime options. |
 | `runtime.global_rt_size` | Integer | `8` | The number of threads to execute the runtime for global read operations. |
 | `runtime.compact_rt_size` | Integer | `4` | The number of threads to execute the runtime for global write operations. |
-| `http` | -- | -- | The HTTP server options. |
-| `http.addr` | String | `127.0.0.1:4000` | The address to bind the HTTP server. |
-| `http.timeout` | String | `0s` | HTTP request timeout. Set to 0 to disable timeout. |
-| `http.body_limit` | String | `64MB` | HTTP request body limit.<br/>The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.<br/>Set to 0 to disable limit. |
 | `procedure` | -- | -- | Procedure storage options. |
 | `procedure.max_retry_times` | Integer | `12` | Procedure max retry time. |
 | `procedure.retry_delay` | String | `500ms` | Initial retry delay of procedures, increases exponentially |
--- a/config/frontend.example.toml
+++ b/config/frontend.example.toml
@@ -37,12 +37,6 @@ enable_cors = true
 ## Customize allowed origins for HTTP CORS.
 ## @toml2docs:none-default
 cors_allowed_origins = ["https://example.com"]
-## Whether to enable validation for Prometheus remote write requests.
-## Available options:
-## - strict: deny invalid UTF-8 strings (default).
-## - lossy: allow invalid UTF-8 strings, replace invalid characters with REPLACEMENT_CHARACTER(U+FFFD).
-## - unchecked: do not valid strings.
-prom_validation_mode = "strict"

 ## The gRPC server options.
 [grpc]
--- a/config/metasrv.example.toml
+++ b/config/metasrv.example.toml
@@ -67,17 +67,6 @@ node_max_idle_time = "24hours"
 ## The number of threads to execute the runtime for global write operations.
 #+ compact_rt_size = 4

-## The HTTP server options.
-[http]
-## The address to bind the HTTP server.
-addr = "127.0.0.1:4000"
-## HTTP request timeout. Set to 0 to disable timeout.
-timeout = "0s"
-## HTTP request body limit.
-## The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.
-## Set to 0 to disable limit.
-body_limit = "64MB"
-
 ## Procedure storage options.
 [procedure]

--- a/config/standalone.example.toml
+++ b/config/standalone.example.toml
@@ -43,13 +43,6 @@ enable_cors = true
 ## @toml2docs:none-default
 cors_allowed_origins = ["https://example.com"]

-## Whether to enable validation for Prometheus remote write requests.
-## Available options:
-## - strict: deny invalid UTF-8 strings (default).
-## - lossy: allow invalid UTF-8 strings, replace invalid characters with REPLACEMENT_CHARACTER(U+FFFD).
-## - unchecked: do not valid strings.
-prom_validation_mode = "strict"
-
 ## The gRPC server options.
 [grpc]
 ## The address to bind the gRPC server.
--- a/flake.lock
+++ b/flake.lock
@@ -41,16 +41,16 @@
    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1748162331,
-        "narHash": "sha256-rqc2RKYTxP3tbjA+PB3VMRQNnjesrT0pEofXQTrMsS8=",
+        "lastModified": 1745487689,
+        "narHash": "sha256-FQoi3R0NjQeBAsEOo49b5tbDPcJSMWc3QhhaIi9eddw=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "7c43f080a7f28b2774f3b3f43234ca11661bf334",
+        "rev": "5630cf13cceac06cefe9fc607e8dfa8fb342dde3",
        "type": "github"
      },
      "original": {
        "owner": "NixOS",
-        "ref": "nixos-25.05",
+        "ref": "nixos-24.11",
        "repo": "nixpkgs",
        "type": "github"
      }
--- a/flake.nix
+++ b/flake.nix
@@ -2,7 +2,7 @@
  description = "Development environment flake";

  inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.11";
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
@@ -51,7 +51,6 @@
          ];

          LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath buildInputs;
-          NIX_HARDENING_ENABLE = "";
        };
      });
 }
--- a/licenserc.toml
+++ b/licenserc.toml
@@ -26,11 +26,6 @@ excludes = [
    "src/common/base/src/secrets.rs",
    "src/servers/src/repeated_field.rs",
    "src/servers/src/http/test_helpers.rs",
-    # enterprise
-    "src/sql/src/statements/create/trigger.rs",
-    "src/sql/src/statements/show/trigger.rs",
-    "src/sql/src/parsers/create_parser/trigger.rs",
-    "src/sql/src/parsers/show_parser/trigger.rs",
 ]

 [properties]
--- a/src/cli/Cargo.toml
+++ b/src/cli/Cargo.toml
@@ -43,9 +43,11 @@ etcd-client.workspace = true
 futures.workspace = true
 humantime.workspace = true
 meta-client.workspace = true
-meta-srv.workspace = true
 nu-ansi-term = "0.46"
-object-store.workspace = true
+opendal = { version = "0.51.1", features = [
+    "services-fs",
+    "services-s3",
+] }
 query.workspace = true
 rand.workspace = true
 reqwest.workspace = true
--- a/src/cli/src/error.rs
+++ b/src/cli/src/error.rs
@@ -17,7 +17,6 @@ use std::any::Any;
 use common_error::ext::{BoxedError, ErrorExt};
 use common_error::status_code::StatusCode;
 use common_macro::stack_trace_debug;
-use object_store::Error as ObjectStoreError;
 use snafu::{Location, Snafu};

 #[derive(Snafu)]
@@ -226,7 +225,7 @@ pub enum Error {
        #[snafu(implicit)]
        location: Location,
        #[snafu(source)]
-        error: ObjectStoreError,
+        error: opendal::Error,
    },
    #[snafu(display("S3 config need be set"))]
    S3ConfigNotSet {
@@ -238,12 +237,6 @@ pub enum Error {
        #[snafu(implicit)]
        location: Location,
    },
-    #[snafu(display("KV backend not set: {}", backend))]
-    KvBackendNotSet {
-        backend: String,
-        #[snafu(implicit)]
-        location: Location,
-    },
 }

 pub type Result<T> = std::result::Result<T, Error>;
@@ -280,9 +273,8 @@ impl ErrorExt for Error {

            Error::Other { source, .. } => source.status_code(),
            Error::OpenDal { .. } => StatusCode::Internal,
-            Error::S3ConfigNotSet { .. }
-            | Error::OutputDirNotSet { .. }
-            | Error::KvBackendNotSet { .. } => StatusCode::InvalidArguments,
+            Error::S3ConfigNotSet { .. } => StatusCode::InvalidArguments,
+            Error::OutputDirNotSet { .. } => StatusCode::InvalidArguments,

            Error::BuildRuntime { source, .. } => source.status_code(),

--- a/src/cli/src/export.rs
+++ b/src/cli/src/export.rs
@@ -21,8 +21,8 @@ use async_trait::async_trait;
 use clap::{Parser, ValueEnum};
 use common_error::ext::BoxedError;
 use common_telemetry::{debug, error, info};
-use object_store::layers::LoggingLayer;
-use object_store::{services, ObjectStore};
+use opendal::layers::LoggingLayer;
+use opendal::{services, Operator};
 use serde_json::Value;
 use snafu::{OptionExt, ResultExt};
 use tokio::sync::Semaphore;
@@ -470,7 +470,7 @@ impl Export {
        Ok(())
    }

-    async fn build_operator(&self) -> Result<ObjectStore> {
+    async fn build_operator(&self) -> Result<Operator> {
        if self.s3 {
            self.build_s3_operator().await
        } else {
@@ -479,11 +479,11 @@ impl Export {
    }

    /// build operator with preference for file system
-    async fn build_prefer_fs_operator(&self) -> Result<ObjectStore> {
+    async fn build_prefer_fs_operator(&self) -> Result<Operator> {
        // is under s3 mode and s3_ddl_dir is set, use it as root
        if self.s3 && self.s3_ddl_local_dir.is_some() {
            let root = self.s3_ddl_local_dir.as_ref().unwrap().clone();
-            let op = ObjectStore::new(services::Fs::default().root(&root))
+            let op = Operator::new(services::Fs::default().root(&root))
                .context(OpenDalSnafu)?
                .layer(LoggingLayer::default())
                .finish();
@@ -495,7 +495,7 @@ impl Export {
        }
    }

-    async fn build_s3_operator(&self) -> Result<ObjectStore> {
+    async fn build_s3_operator(&self) -> Result<Operator> {
        let mut builder = services::S3::default().bucket(
            self.s3_bucket
                .as_ref()
@@ -522,20 +522,20 @@ impl Export {
            builder = builder.secret_access_key(secret_key);
        }

-        let op = ObjectStore::new(builder)
+        let op = Operator::new(builder)
            .context(OpenDalSnafu)?
            .layer(LoggingLayer::default())
            .finish();
        Ok(op)
    }

-    async fn build_fs_operator(&self) -> Result<ObjectStore> {
+    async fn build_fs_operator(&self) -> Result<Operator> {
        let root = self
            .output_dir
            .as_ref()
            .context(OutputDirNotSetSnafu)?
            .clone();
-        let op = ObjectStore::new(services::Fs::default().root(&root))
+        let op = Operator::new(services::Fs::default().root(&root))
            .context(OpenDalSnafu)?
            .layer(LoggingLayer::default())
            .finish();
@@ -642,14 +642,11 @@ impl Export {

    async fn write_to_storage(
        &self,
-        op: &ObjectStore,
+        op: &Operator,
        file_path: &str,
        content: Vec<u8>,
    ) -> Result<()> {
-        op.write(file_path, content)
-            .await
-            .context(OpenDalSnafu)
-            .map(|_| ())
+        op.write(file_path, content).await.context(OpenDalSnafu)
    }

    fn get_storage_params(&self, schema: &str) -> (String, String) {
--- a/src/cli/src/lib.rs
+++ b/src/cli/src/lib.rs
@@ -17,7 +17,6 @@ mod database;
 pub mod error;
 mod export;
 mod import;
-mod meta_snapshot;

 use async_trait::async_trait;
 use clap::Parser;
@@ -28,7 +27,6 @@ use error::Result;
 pub use crate::bench::BenchTableMetadataCommand;
 pub use crate::export::ExportCommand;
 pub use crate::import::ImportCommand;
-pub use crate::meta_snapshot::{MetaRestoreCommand, MetaSnapshotCommand};

 #[async_trait]
 pub trait Tool: Send + Sync {
--- a/src/cli/src/meta_snapshot.rs
+++ b/src/cli/src/meta_snapshot.rs
@@ -1,329 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use clap::Parser;
-use common_base::secrets::{ExposeSecret, SecretString};
-use common_error::ext::BoxedError;
-use common_meta::kv_backend::chroot::ChrootKvBackend;
-use common_meta::kv_backend::etcd::EtcdStore;
-use common_meta::kv_backend::KvBackendRef;
-use common_meta::snapshot::MetadataSnapshotManager;
-use meta_srv::bootstrap::create_etcd_client;
-use meta_srv::metasrv::BackendImpl;
-use object_store::services::{Fs, S3};
-use object_store::ObjectStore;
-use snafu::ResultExt;
-
-use crate::error::{KvBackendNotSetSnafu, OpenDalSnafu, S3ConfigNotSetSnafu};
-use crate::Tool;
-#[derive(Debug, Default, Parser)]
-struct MetaConnection {
-    /// The endpoint of store. one of etcd, pg or mysql.
-    #[clap(long, alias = "store-addr", value_delimiter = ',', num_args = 1..)]
-    store_addrs: Vec<String>,
-    /// The database backend.
-    #[clap(long, value_enum)]
-    backend: Option<BackendImpl>,
-    #[clap(long, default_value = "")]
-    store_key_prefix: String,
-    #[cfg(any(feature = "pg_kvbackend", feature = "mysql_kvbackend"))]
-    #[clap(long,default_value = common_meta::kv_backend::DEFAULT_META_TABLE_NAME)]
-    meta_table_name: String,
-    #[clap(long, default_value = "128")]
-    max_txn_ops: usize,
-}
-
-impl MetaConnection {
-    pub async fn build(&self) -> Result<KvBackendRef, BoxedError> {
-        let max_txn_ops = self.max_txn_ops;
-        let store_addrs = &self.store_addrs;
-        if store_addrs.is_empty() {
-            KvBackendNotSetSnafu { backend: "all" }
-                .fail()
-                .map_err(BoxedError::new)
-        } else {
-            let kvbackend = match self.backend {
-                Some(BackendImpl::EtcdStore) => {
-                    let etcd_client = create_etcd_client(store_addrs)
-                        .await
-                        .map_err(BoxedError::new)?;
-                    Ok(EtcdStore::with_etcd_client(etcd_client, max_txn_ops))
-                }
-                #[cfg(feature = "pg_kvbackend")]
-                Some(BackendImpl::PostgresStore) => {
-                    let table_name = &self.meta_table_name;
-                    let pool = meta_srv::bootstrap::create_postgres_pool(store_addrs)
-                        .await
-                        .map_err(BoxedError::new)?;
-                    Ok(common_meta::kv_backend::rds::PgStore::with_pg_pool(
-                        pool,
-                        table_name,
-                        max_txn_ops,
-                    )
-                    .await
-                    .map_err(BoxedError::new)?)
-                }
-                #[cfg(feature = "mysql_kvbackend")]
-                Some(BackendImpl::MysqlStore) => {
-                    let table_name = &self.meta_table_name;
-                    let pool = meta_srv::bootstrap::create_mysql_pool(store_addrs)
-                        .await
-                        .map_err(BoxedError::new)?;
-                    Ok(common_meta::kv_backend::rds::MySqlStore::with_mysql_pool(
-                        pool,
-                        table_name,
-                        max_txn_ops,
-                    )
-                    .await
-                    .map_err(BoxedError::new)?)
-                }
-                _ => KvBackendNotSetSnafu { backend: "all" }
-                    .fail()
-                    .map_err(BoxedError::new),
-            };
-            if self.store_key_prefix.is_empty() {
-                kvbackend
-            } else {
-                let chroot_kvbackend =
-                    ChrootKvBackend::new(self.store_key_prefix.as_bytes().to_vec(), kvbackend?);
-                Ok(Arc::new(chroot_kvbackend))
-            }
-        }
-    }
-}
-
-// TODO(qtang): Abstract a generic s3 config for export import meta snapshot restore
-#[derive(Debug, Default, Parser)]
-struct S3Config {
-    /// whether to use s3 as the output directory. default is false.
-    #[clap(long, default_value = "false")]
-    s3: bool,
-    /// The s3 bucket name.
-    #[clap(long)]
-    s3_bucket: Option<String>,
-    /// The s3 region.
-    #[clap(long)]
-    s3_region: Option<String>,
-    /// The s3 access key.
-    #[clap(long)]
-    s3_access_key: Option<SecretString>,
-    /// The s3 secret key.
-    #[clap(long)]
-    s3_secret_key: Option<SecretString>,
-    /// The s3 endpoint. we will automatically use the default s3 decided by the region if not set.
-    #[clap(long)]
-    s3_endpoint: Option<String>,
-}
-
-impl S3Config {
-    pub fn build(&self, root: &str) -> Result<Option<ObjectStore>, BoxedError> {
-        if !self.s3 {
-            Ok(None)
-        } else {
-            if self.s3_region.is_none()
-                || self.s3_access_key.is_none()
-                || self.s3_secret_key.is_none()
-                || self.s3_bucket.is_none()
-            {
-                return S3ConfigNotSetSnafu.fail().map_err(BoxedError::new);
-            }
-            // Safety, unwrap is safe because we have checked the options above.
-            let mut config = S3::default()
-                .bucket(self.s3_bucket.as_ref().unwrap())
-                .region(self.s3_region.as_ref().unwrap())
-                .access_key_id(self.s3_access_key.as_ref().unwrap().expose_secret())
-                .secret_access_key(self.s3_secret_key.as_ref().unwrap().expose_secret());
-
-            if !root.is_empty() && root != "." {
-                config = config.root(root);
-            }
-
-            if let Some(endpoint) = &self.s3_endpoint {
-                config = config.endpoint(endpoint);
-            }
-            Ok(Some(
-                ObjectStore::new(config)
-                    .context(OpenDalSnafu)
-                    .map_err(BoxedError::new)?
-                    .finish(),
-            ))
-        }
-    }
-}
-
-/// Export metadata snapshot tool.
-/// This tool is used to export metadata snapshot from etcd, pg or mysql.
-/// It will dump the metadata snapshot to local file or s3 bucket.
-/// The snapshot file will be in binary format.
-#[derive(Debug, Default, Parser)]
-pub struct MetaSnapshotCommand {
-    /// The connection to the metadata store.
-    #[clap(flatten)]
-    connection: MetaConnection,
-    /// The s3 config.
-    #[clap(flatten)]
-    s3_config: S3Config,
-    /// The name of the target snapshot file. we will add the file extension automatically.
-    #[clap(long, default_value = "metadata_snapshot")]
-    file_name: String,
-    /// The directory to store the snapshot file.
-    /// if target output is s3 bucket, this is the root directory in the bucket.
-    /// if target output is local file, this is the local directory.
-    #[clap(long, default_value = "")]
-    output_dir: String,
-}
-
-fn create_local_file_object_store(root: &str) -> Result<ObjectStore, BoxedError> {
-    let root = if root.is_empty() { "." } else { root };
-    let object_store = ObjectStore::new(Fs::default().root(root))
-        .context(OpenDalSnafu)
-        .map_err(BoxedError::new)?
-        .finish();
-    Ok(object_store)
-}
-
-impl MetaSnapshotCommand {
-    pub async fn build(&self) -> Result<Box<dyn Tool>, BoxedError> {
-        let kvbackend = self.connection.build().await?;
-        let output_dir = &self.output_dir;
-        let object_store = self.s3_config.build(output_dir).map_err(BoxedError::new)?;
-        if let Some(store) = object_store {
-            let tool = MetaSnapshotTool {
-                inner: MetadataSnapshotManager::new(kvbackend, store),
-                target_file: self.file_name.clone(),
-            };
-            Ok(Box::new(tool))
-        } else {
-            let object_store = create_local_file_object_store(output_dir)?;
-            let tool = MetaSnapshotTool {
-                inner: MetadataSnapshotManager::new(kvbackend, object_store),
-                target_file: self.file_name.clone(),
-            };
-            Ok(Box::new(tool))
-        }
-    }
-}
-
-pub struct MetaSnapshotTool {
-    inner: MetadataSnapshotManager,
-    target_file: String,
-}
-
-#[async_trait]
-impl Tool for MetaSnapshotTool {
-    async fn do_work(&self) -> std::result::Result<(), BoxedError> {
-        self.inner
-            .dump("", &self.target_file)
-            .await
-            .map_err(BoxedError::new)?;
-        Ok(())
-    }
-}
-
-/// Restore metadata snapshot tool.
-/// This tool is used to restore metadata snapshot from etcd, pg or mysql.
-/// It will restore the metadata snapshot from local file or s3 bucket.
-#[derive(Debug, Default, Parser)]
-pub struct MetaRestoreCommand {
-    /// The connection to the metadata store.
-    #[clap(flatten)]
-    connection: MetaConnection,
-    /// The s3 config.
-    #[clap(flatten)]
-    s3_config: S3Config,
-    /// The name of the target snapshot file.
-    #[clap(long, default_value = "metadata_snapshot.metadata.fb")]
-    file_name: String,
-    /// The directory to store the snapshot file.
-    #[clap(long, default_value = ".")]
-    input_dir: String,
-    #[clap(long, default_value = "false")]
-    force: bool,
-}
-
-impl MetaRestoreCommand {
-    pub async fn build(&self) -> Result<Box<dyn Tool>, BoxedError> {
-        let kvbackend = self.connection.build().await?;
-        let input_dir = &self.input_dir;
-        let object_store = self.s3_config.build(input_dir).map_err(BoxedError::new)?;
-        if let Some(store) = object_store {
-            let tool = MetaRestoreTool::new(
-                MetadataSnapshotManager::new(kvbackend, store),
-                self.file_name.clone(),
-                self.force,
-            );
-            Ok(Box::new(tool))
-        } else {
-            let object_store = create_local_file_object_store(input_dir)?;
-            let tool = MetaRestoreTool::new(
-                MetadataSnapshotManager::new(kvbackend, object_store),
-                self.file_name.clone(),
-                self.force,
-            );
-            Ok(Box::new(tool))
-        }
-    }
-}
-
-pub struct MetaRestoreTool {
-    inner: MetadataSnapshotManager,
-    source_file: String,
-    force: bool,
-}
-
-impl MetaRestoreTool {
-    pub fn new(inner: MetadataSnapshotManager, source_file: String, force: bool) -> Self {
-        Self {
-            inner,
-            source_file,
-            force,
-        }
-    }
-}
-
-#[async_trait]
-impl Tool for MetaRestoreTool {
-    async fn do_work(&self) -> std::result::Result<(), BoxedError> {
-        let clean = self
-            .inner
-            .check_target_source_clean()
-            .await
-            .map_err(BoxedError::new)?;
-        if clean {
-            common_telemetry::info!(
-                "The target source is clean, we will restore the metadata snapshot."
-            );
-            self.inner
-                .restore(&self.source_file)
-                .await
-                .map_err(BoxedError::new)?;
-            Ok(())
-        } else if !self.force {
-            common_telemetry::warn!(
-                 "The target source is not clean, if you want to restore the metadata snapshot forcefully, please use --force option."
-             );
-            Ok(())
-        } else {
-            common_telemetry::info!("The target source is not clean, We will restore the metadata snapshot with --force.");
-            self.inner
-                .restore(&self.source_file)
-                .await
-                .map_err(BoxedError::new)?;
-            Ok(())
-        }
-    }
-}
--- a/src/client/Cargo.toml
+++ b/src/client/Cargo.toml
@@ -25,7 +25,6 @@ common-meta.workspace = true
 common-query.workspace = true
 common-recordbatch.workspace = true
 common-telemetry.workspace = true
-datatypes.workspace = true
 enum_dispatch = "0.3"
 futures.workspace = true
 futures-util.workspace = true
--- a/src/client/src/database.rs
+++ b/src/client/src/database.rs
@@ -14,7 +14,6 @@

 use std::pin::Pin;
 use std::str::FromStr;
-use std::sync::Arc;

 use api::v1::auth_header::AuthScheme;
 use api::v1::ddl_request::Expr as DdlExpr;
@@ -36,7 +35,7 @@ use common_grpc::flight::do_put::DoPutResponse;
 use common_grpc::flight::{FlightDecoder, FlightMessage};
 use common_query::Output;
 use common_recordbatch::error::ExternalSnafu;
-use common_recordbatch::{RecordBatch, RecordBatchStreamWrapper};
+use common_recordbatch::RecordBatchStreamWrapper;
 use common_telemetry::tracing_context::W3cTrace;
 use common_telemetry::{error, warn};
 use futures::future;
@@ -50,7 +49,7 @@ use crate::error::{
    ConvertFlightDataSnafu, Error, FlightGetSnafu, IllegalFlightMessagesSnafu,
    InvalidTonicMetadataValueSnafu, ServerSnafu,
 };
-use crate::{error, from_grpc_response, Client, Result};
+use crate::{from_grpc_response, Client, Result};

 type FlightDataStream = Pin<Box<dyn Stream<Item = FlightData> + Send>>;

@@ -338,30 +337,20 @@ impl Database {
                );
                Ok(Output::new_with_affected_rows(rows))
            }
-            FlightMessage::RecordBatch(_) | FlightMessage::Metrics(_) => {
+            FlightMessage::Recordbatch(_) | FlightMessage::Metrics(_) => {
                IllegalFlightMessagesSnafu {
                    reason: "The first flight message cannot be a RecordBatch or Metrics message",
                }
                .fail()
            }
            FlightMessage::Schema(schema) => {
-                let schema = Arc::new(
-                    datatypes::schema::Schema::try_from(schema)
-                        .context(error::ConvertSchemaSnafu)?,
-                );
-                let schema_cloned = schema.clone();
                let stream = Box::pin(stream!({
                    while let Some(flight_message) = flight_message_stream.next().await {
                        let flight_message = flight_message
                            .map_err(BoxedError::new)
                            .context(ExternalSnafu)?;
                        match flight_message {
-                            FlightMessage::RecordBatch(arrow_batch) => {
-                                yield RecordBatch::try_from_df_record_batch(
-                                    schema_cloned.clone(),
-                                    arrow_batch,
-                                )
-                            }
+                            FlightMessage::Recordbatch(record_batch) => yield Ok(record_batch),
                            FlightMessage::Metrics(_) => {}
                            FlightMessage::AffectedRows(_) | FlightMessage::Schema(_) => {
                                yield IllegalFlightMessagesSnafu {reason: format!("A Schema message must be succeeded exclusively by a set of RecordBatch messages, flight_message: {:?}", flight_message)}
--- a/src/client/src/error.rs
+++ b/src/client/src/error.rs
@@ -117,13 +117,6 @@ pub enum Error {
        #[snafu(implicit)]
        location: Location,
    },
-
-    #[snafu(display("Failed to convert Schema"))]
-    ConvertSchema {
-        #[snafu(implicit)]
-        location: Location,
-        source: datatypes::error::Error,
-    },
 }

 pub type Result<T> = std::result::Result<T, Error>;
@@ -144,7 +137,6 @@ impl ErrorExt for Error {
            | Error::CreateTlsChannel { source, .. } => source.status_code(),
            Error::IllegalGrpcClientState { .. } => StatusCode::Unexpected,
            Error::InvalidTonicMetadataValue { .. } => StatusCode::InvalidArguments,
-            Error::ConvertSchema { source, .. } => source.status_code(),
        }
    }

--- a/src/client/src/region.rs
+++ b/src/client/src/region.rs
@@ -28,7 +28,7 @@ use common_meta::error::{self as meta_error, Result as MetaResult};
 use common_meta::node_manager::Datanode;
 use common_query::request::QueryRequest;
 use common_recordbatch::error::ExternalSnafu;
-use common_recordbatch::{RecordBatch, RecordBatchStreamWrapper, SendableRecordBatchStream};
+use common_recordbatch::{RecordBatchStreamWrapper, SendableRecordBatchStream};
 use common_telemetry::error;
 use common_telemetry::tracing_context::TracingContext;
 use prost::Message;
@@ -55,7 +55,6 @@ impl Datanode for RegionRequester {
            if err.should_retry() {
                meta_error::Error::RetryLater {
                    source: BoxedError::new(err),
-                    clean_poisons: false,
                }
            } else {
                meta_error::Error::External {
@@ -147,10 +146,6 @@ impl RegionRequester {

        let tracing_context = TracingContext::from_current_span();

-        let schema = Arc::new(
-            datatypes::schema::Schema::try_from(schema).context(error::ConvertSchemaSnafu)?,
-        );
-        let schema_cloned = schema.clone();
        let stream = Box::pin(stream!({
            let _span = tracing_context.attach(common_telemetry::tracing::info_span!(
                "poll_flight_data_stream"
@@ -161,12 +156,7 @@ impl RegionRequester {
                    .context(ExternalSnafu)?;

                match flight_message {
-                    FlightMessage::RecordBatch(record_batch) => {
-                        yield RecordBatch::try_from_df_record_batch(
-                            schema_cloned.clone(),
-                            record_batch,
-                        )
-                    }
+                    FlightMessage::Recordbatch(record_batch) => yield Ok(record_batch),
                    FlightMessage::Metrics(s) => {
                        let m = serde_json::from_str(&s).ok().map(Arc::new);
                        metrics_ref.swap(m);
--- a/src/cmd/Cargo.toml
+++ b/src/cmd/Cargo.toml
@@ -10,7 +10,7 @@ name = "greptime"
 path = "src/bin/greptime.rs"

 [features]
-default = ["servers/pprof", "servers/mem-prof", "meta-srv/pg_kvbackend", "meta-srv/mysql_kvbackend"]
+default = ["servers/pprof", "servers/mem-prof"]
 tokio-console = ["common-telemetry/tokio-console"]

 [lints]
--- a/src/common/grpc/Cargo.toml
+++ b/src/common/grpc/Cargo.toml
@@ -10,7 +10,6 @@ workspace = true
 [dependencies]
 api.workspace = true
 arrow-flight.workspace = true
-bytes.workspace = true
 common-base.workspace = true
 common-error.workspace = true
 common-macro.workspace = true
--- a/src/common/grpc/benches/bench_flight_decoder.rs
+++ b/src/common/grpc/benches/bench_flight_decoder.rs
@@ -1,146 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::sync::Arc;
-
-use arrow_flight::FlightData;
-use bytes::Bytes;
-use common_grpc::flight::{FlightDecoder, FlightEncoder, FlightMessage};
-use common_recordbatch::DfRecordBatch;
-use criterion::{criterion_group, criterion_main, Criterion};
-use datatypes::arrow;
-use datatypes::arrow::array::{ArrayRef, Int64Array, StringArray, TimestampMillisecondArray};
-use datatypes::arrow::datatypes::DataType;
-use datatypes::data_type::ConcreteDataType;
-use datatypes::schema::{ColumnSchema, Schema};
-use prost::Message;
-
-fn schema() -> arrow::datatypes::SchemaRef {
-    let schema = Schema::new(vec![
-        ColumnSchema::new("k0", ConcreteDataType::string_datatype(), false),
-        ColumnSchema::new("k1", ConcreteDataType::string_datatype(), false),
-        ColumnSchema::new(
-            "ts",
-            ConcreteDataType::timestamp_millisecond_datatype(),
-            false,
-        ),
-        ColumnSchema::new("v0", ConcreteDataType::int64_datatype(), false),
-        ColumnSchema::new("v1", ConcreteDataType::int64_datatype(), false),
-    ]);
-    schema.arrow_schema().clone()
-}
-
-/// Generate record batch according to provided schema and num rows.
-fn prepare_random_record_batch(
-    schema: arrow::datatypes::SchemaRef,
-    num_rows: usize,
-) -> DfRecordBatch {
-    let tag_candidates = (0..10000).map(|i| i.to_string()).collect::<Vec<_>>();
-
-    let columns: Vec<ArrayRef> = schema
-        .fields
-        .iter()
-        .map(|col| match col.data_type() {
-            DataType::Utf8 => {
-                let array = StringArray::from(
-                    (0..num_rows)
-                        .map(|_| {
-                            let idx: usize = rand::random_range(0..10000);
-                            format!("tag-{}", tag_candidates[idx])
-                        })
-                        .collect::<Vec<_>>(),
-                );
-                Arc::new(array) as ArrayRef
-            }
-            DataType::Timestamp(_, _) => {
-                let now = common_time::util::current_time_millis();
-                let array = TimestampMillisecondArray::from(
-                    (0..num_rows).map(|i| now + i as i64).collect::<Vec<_>>(),
-                );
-                Arc::new(array) as ArrayRef
-            }
-            DataType::Int64 => {
-                let array = Int64Array::from((0..num_rows).map(|i| i as i64).collect::<Vec<_>>());
-                Arc::new(array) as ArrayRef
-            }
-            _ => unreachable!(),
-        })
-        .collect();
-
-    DfRecordBatch::try_new(schema, columns).unwrap()
-}
-
-fn prepare_flight_data(num_rows: usize) -> (FlightData, FlightData) {
-    let schema = schema();
-    let mut encoder = FlightEncoder::default();
-    let schema_data = encoder.encode(FlightMessage::Schema(schema.clone()));
-    let rb = prepare_random_record_batch(schema, num_rows);
-    let rb_data = encoder.encode(FlightMessage::RecordBatch(rb));
-    (schema_data, rb_data)
-}
-
-fn decode_flight_data_from_protobuf(schema: &Bytes, payload: &Bytes) -> DfRecordBatch {
-    let schema = FlightData::decode(&schema[..]).unwrap();
-    let payload = FlightData::decode(&payload[..]).unwrap();
-    let mut decoder = FlightDecoder::default();
-    let _schema = decoder.try_decode(&schema).unwrap();
-    let message = decoder.try_decode(&payload).unwrap();
-    let FlightMessage::RecordBatch(batch) = message else {
-        unreachable!("unexpected message");
-    };
-    batch
-}
-
-fn decode_flight_data_from_header_and_body(
-    schema: &Bytes,
-    data_header: &Bytes,
-    data_body: &Bytes,
-) -> DfRecordBatch {
-    let mut decoder = FlightDecoder::try_from_schema_bytes(schema).unwrap();
-    decoder
-        .try_decode_record_batch(data_header, data_body)
-        .unwrap()
-}
-
-fn bench_decode_flight_data(c: &mut Criterion) {
-    let row_counts = [100000, 200000, 1000000];
-
-    for row_count in row_counts {
-        let (schema, payload) = prepare_flight_data(row_count);
-
-        // arguments for decode_flight_data_from_protobuf
-        let schema_bytes = Bytes::from(schema.encode_to_vec());
-        let payload_bytes = Bytes::from(payload.encode_to_vec());
-
-        let mut group = c.benchmark_group(format!("flight_decoder_{}_rows", row_count));
-        group.bench_function("decode_from_protobuf", |b| {
-            b.iter(|| decode_flight_data_from_protobuf(&schema_bytes, &payload_bytes));
-        });
-
-        group.bench_function("decode_from_header_and_body", |b| {
-            b.iter(|| {
-                decode_flight_data_from_header_and_body(
-                    &schema.data_header,
-                    &payload.data_header,
-                    &payload.data_body,
-                )
-            });
-        });
-
-        group.finish();
-    }
-}
-
-criterion_group!(benches, bench_decode_flight_data);
-criterion_main!(benches);
--- a/src/common/grpc/benches/bench_main.rs
+++ b/src/common/grpc/benches/bench_main.rs
@@ -14,10 +14,8 @@

 use criterion::criterion_main;

-mod bench_flight_decoder;
 mod channel_manager;

 criterion_main! {
-    channel_manager::benches,
-    bench_flight_decoder::benches
+    channel_manager::benches
 }
--- a/src/common/grpc/src/error.rs
+++ b/src/common/grpc/src/error.rs
@@ -18,7 +18,6 @@ use std::io;
 use common_error::ext::ErrorExt;
 use common_error::status_code::StatusCode;
 use common_macro::stack_trace_debug;
-use datatypes::arrow::error::ArrowError;
 use snafu::{Location, Snafu};

 pub type Result<T> = std::result::Result<T, Error>;
@@ -60,6 +59,13 @@ pub enum Error {
        location: Location,
    },

+    #[snafu(display("Failed to create RecordBatch"))]
+    CreateRecordBatch {
+        #[snafu(implicit)]
+        location: Location,
+        source: common_recordbatch::error::Error,
+    },
+
    #[snafu(display("Failed to convert Arrow type: {}", from))]
    Conversion {
        from: String,
@@ -82,6 +88,13 @@ pub enum Error {
        location: Location,
    },

+    #[snafu(display("Failed to convert Arrow Schema"))]
+    ConvertArrowSchema {
+        #[snafu(implicit)]
+        location: Location,
+        source: datatypes::error::Error,
+    },
+
    #[snafu(display("Not supported: {}", feat))]
    NotSupported { feat: String },

@@ -92,14 +105,6 @@ pub enum Error {
        #[snafu(implicit)]
        location: Location,
    },
-
-    #[snafu(display("Failed arrow operation"))]
-    Arrow {
-        #[snafu(implicit)]
-        location: Location,
-        #[snafu(source)]
-        error: ArrowError,
-    },
 }

 impl ErrorExt for Error {
@@ -116,7 +121,8 @@ impl ErrorExt for Error {
            | Error::DecodeFlightData { .. }
            | Error::SerdeJson { .. } => StatusCode::Internal,

-            Error::Arrow { .. } => StatusCode::Internal,
+            Error::CreateRecordBatch { source, .. } => source.status_code(),
+            Error::ConvertArrowSchema { source, .. } => source.status_code(),
        }
    }

--- a/src/common/grpc/src/flight.rs
+++ b/src/common/grpc/src/flight.rs
@@ -21,24 +21,25 @@ use api::v1::{AffectedRows, FlightMetadata, Metrics};
 use arrow_flight::utils::flight_data_to_arrow_batch;
 use arrow_flight::{FlightData, SchemaAsIpc};
 use common_base::bytes::Bytes;
-use common_recordbatch::DfRecordBatch;
+use common_recordbatch::{RecordBatch, RecordBatches};
 use datatypes::arrow;
-use datatypes::arrow::buffer::Buffer;
-use datatypes::arrow::datatypes::{Schema as ArrowSchema, SchemaRef};
-use datatypes::arrow::error::ArrowError;
-use datatypes::arrow::ipc::{convert, reader, root_as_message, writer, MessageHeader};
+use datatypes::arrow::datatypes::Schema as ArrowSchema;
+use datatypes::arrow::ipc::{root_as_message, writer, MessageHeader};
+use datatypes::schema::{Schema, SchemaRef};
 use flatbuffers::FlatBufferBuilder;
 use prost::bytes::Bytes as ProstBytes;
 use prost::Message;
 use snafu::{OptionExt, ResultExt};

-use crate::error;
-use crate::error::{DecodeFlightDataSnafu, InvalidFlightDataSnafu, Result};
+use crate::error::{
+    ConvertArrowSchemaSnafu, CreateRecordBatchSnafu, DecodeFlightDataSnafu, InvalidFlightDataSnafu,
+    Result,
+};

 #[derive(Debug, Clone)]
 pub enum FlightMessage {
    Schema(SchemaRef),
-    RecordBatch(DfRecordBatch),
+    Recordbatch(RecordBatch),
    AffectedRows(usize),
    Metrics(String),
 }
@@ -66,12 +67,14 @@ impl Default for FlightEncoder {
 impl FlightEncoder {
    pub fn encode(&mut self, flight_message: FlightMessage) -> FlightData {
        match flight_message {
-            FlightMessage::Schema(schema) => SchemaAsIpc::new(&schema, &self.write_options).into(),
-            FlightMessage::RecordBatch(record_batch) => {
+            FlightMessage::Schema(schema) => {
+                SchemaAsIpc::new(schema.arrow_schema(), &self.write_options).into()
+            }
+            FlightMessage::Recordbatch(recordbatch) => {
                let (encoded_dictionaries, encoded_batch) = self
                    .data_gen
                    .encoded_batch(
-                        &record_batch,
+                        recordbatch.df_record_batch(),
                        &mut self.dictionary_tracker,
                        &self.write_options,
                    )
@@ -121,58 +124,9 @@ impl FlightEncoder {
 #[derive(Default)]
 pub struct FlightDecoder {
    schema: Option<SchemaRef>,
-    schema_bytes: Option<bytes::Bytes>,
 }

 impl FlightDecoder {
-    /// Build a [FlightDecoder] instance from provided schema bytes.
-    pub fn try_from_schema_bytes(schema_bytes: &bytes::Bytes) -> Result<Self> {
-        let arrow_schema = convert::try_schema_from_flatbuffer_bytes(&schema_bytes[..])
-            .context(error::ArrowSnafu)?;
-        Ok(Self {
-            schema: Some(Arc::new(arrow_schema)),
-            schema_bytes: Some(schema_bytes.clone()),
-        })
-    }
-
-    pub fn try_decode_record_batch(
-        &mut self,
-        data_header: &bytes::Bytes,
-        data_body: &bytes::Bytes,
-    ) -> Result<DfRecordBatch> {
-        let schema = self
-            .schema
-            .as_ref()
-            .context(InvalidFlightDataSnafu {
-                reason: "Should have decoded schema first!",
-            })?
-            .clone();
-        let message = root_as_message(&data_header[..])
-            .map_err(|err| {
-                ArrowError::ParseError(format!("Unable to get root as message: {err:?}"))
-            })
-            .context(error::ArrowSnafu)?;
-        let result = message
-            .header_as_record_batch()
-            .ok_or_else(|| {
-                ArrowError::ParseError(
-                    "Unable to convert flight data header to a record batch".to_string(),
-                )
-            })
-            .and_then(|batch| {
-                reader::read_record_batch(
-                    &Buffer::from(data_body.as_ref()),
-                    batch,
-                    schema,
-                    &HashMap::new(),
-                    None,
-                    &message.version(),
-                )
-            })
-            .context(error::ArrowSnafu)?;
-        Ok(result)
-    }
-
    pub fn try_decode(&mut self, flight_data: &FlightData) -> Result<FlightMessage> {
        let message = root_as_message(&flight_data.data_header).map_err(|e| {
            InvalidFlightDataSnafu {
@@ -198,29 +152,36 @@ impl FlightDecoder {
                .fail()
            }
            MessageHeader::Schema => {
-                let arrow_schema = Arc::new(ArrowSchema::try_from(flight_data).map_err(|e| {
+                let arrow_schema = ArrowSchema::try_from(flight_data).map_err(|e| {
                    InvalidFlightDataSnafu {
                        reason: e.to_string(),
                    }
                    .build()
-                })?);
-                self.schema = Some(arrow_schema.clone());
-                self.schema_bytes = Some(flight_data.data_header.clone());
-                Ok(FlightMessage::Schema(arrow_schema))
+                })?;
+                let schema =
+                    Arc::new(Schema::try_from(arrow_schema).context(ConvertArrowSchemaSnafu)?);
+
+                self.schema = Some(schema.clone());
+
+                Ok(FlightMessage::Schema(schema))
            }
            MessageHeader::RecordBatch => {
                let schema = self.schema.clone().context(InvalidFlightDataSnafu {
                    reason: "Should have decoded schema first!",
                })?;
+                let arrow_schema = schema.arrow_schema().clone();
+
                let arrow_batch =
-                    flight_data_to_arrow_batch(flight_data, schema.clone(), &HashMap::new())
+                    flight_data_to_arrow_batch(flight_data, arrow_schema, &HashMap::new())
                        .map_err(|e| {
                            InvalidFlightDataSnafu {
                                reason: e.to_string(),
                            }
                            .build()
                        })?;
-                Ok(FlightMessage::RecordBatch(arrow_batch))
+                let recordbatch = RecordBatch::try_from_df_record_batch(schema, arrow_batch)
+                    .context(CreateRecordBatchSnafu)?;
+                Ok(FlightMessage::Recordbatch(recordbatch))
            }
            other => {
                let name = other.variant_name().unwrap_or("UNKNOWN");
@@ -235,22 +196,16 @@ impl FlightDecoder {
    pub fn schema(&self) -> Option<&SchemaRef> {
        self.schema.as_ref()
    }
-
-    pub fn schema_bytes(&self) -> Option<bytes::Bytes> {
-        self.schema_bytes.clone()
-    }
 }

-pub fn flight_messages_to_recordbatches(
-    messages: Vec<FlightMessage>,
-) -> Result<Vec<DfRecordBatch>> {
+pub fn flight_messages_to_recordbatches(messages: Vec<FlightMessage>) -> Result<RecordBatches> {
    if messages.is_empty() {
-        Ok(vec![])
+        Ok(RecordBatches::empty())
    } else {
        let mut recordbatches = Vec::with_capacity(messages.len() - 1);

-        match &messages[0] {
-            FlightMessage::Schema(_schema) => {}
+        let schema = match &messages[0] {
+            FlightMessage::Schema(schema) => schema.clone(),
            _ => {
                return InvalidFlightDataSnafu {
                    reason: "First Flight Message must be schema!",
@@ -261,7 +216,7 @@ pub fn flight_messages_to_recordbatches(

        for message in messages.into_iter().skip(1) {
            match message {
-                FlightMessage::RecordBatch(recordbatch) => recordbatches.push(recordbatch),
+                FlightMessage::Recordbatch(recordbatch) => recordbatches.push(recordbatch),
                _ => {
                    return InvalidFlightDataSnafu {
                        reason: "Expect the following Flight Messages are all Recordbatches!",
@@ -271,7 +226,7 @@ pub fn flight_messages_to_recordbatches(
            }
        }

-        Ok(recordbatches)
+        RecordBatches::try_new(schema, recordbatches).context(CreateRecordBatchSnafu)
    }
 }

@@ -292,33 +247,38 @@ fn build_none_flight_msg() -> Bytes {
 #[cfg(test)]
 mod test {
    use arrow_flight::utils::batches_to_flight_data;
-    use datatypes::arrow::array::Int32Array;
-    use datatypes::arrow::datatypes::{DataType, Field, Schema};
+    use datatypes::arrow::datatypes::{DataType, Field};
+    use datatypes::prelude::ConcreteDataType;
+    use datatypes::schema::ColumnSchema;
+    use datatypes::vectors::Int32Vector;

    use super::*;
    use crate::Error;

    #[test]
    fn test_try_decode() {
-        let schema = Arc::new(ArrowSchema::new(vec![Field::new(
-            "n",
-            DataType::Int32,
-            true,
-        )]));
+        let arrow_schema = ArrowSchema::new(vec![Field::new("n", DataType::Int32, true)]);
+        let schema = Arc::new(Schema::try_from(arrow_schema.clone()).unwrap());

-        let batch1 = DfRecordBatch::try_new(
+        let batch1 = RecordBatch::new(
            schema.clone(),
-            vec![Arc::new(Int32Array::from(vec![Some(1), None, Some(3)])) as _],
+            vec![Arc::new(Int32Vector::from(vec![Some(1), None, Some(3)])) as _],
        )
        .unwrap();
-        let batch2 = DfRecordBatch::try_new(
+        let batch2 = RecordBatch::new(
            schema.clone(),
-            vec![Arc::new(Int32Array::from(vec![None, Some(5)])) as _],
+            vec![Arc::new(Int32Vector::from(vec![None, Some(5)])) as _],
        )
        .unwrap();

-        let flight_data =
-            batches_to_flight_data(&schema, vec![batch1.clone(), batch2.clone()]).unwrap();
+        let flight_data = batches_to_flight_data(
+            &arrow_schema,
+            vec![
+                batch1.clone().into_df_record_batch(),
+                batch2.clone().into_df_record_batch(),
+            ],
+        )
+        .unwrap();
        assert_eq!(flight_data.len(), 3);
        let [d1, d2, d3] = flight_data.as_slice() else {
            unreachable!()
@@ -344,15 +304,15 @@ mod test {
        let _ = decoder.schema.as_ref().unwrap();

        let message = decoder.try_decode(d2).unwrap();
-        assert!(matches!(message, FlightMessage::RecordBatch(_)));
-        let FlightMessage::RecordBatch(actual_batch) = message else {
+        assert!(matches!(message, FlightMessage::Recordbatch(_)));
+        let FlightMessage::Recordbatch(actual_batch) = message else {
            unreachable!()
        };
        assert_eq!(actual_batch, batch1);

        let message = decoder.try_decode(d3).unwrap();
-        assert!(matches!(message, FlightMessage::RecordBatch(_)));
-        let FlightMessage::RecordBatch(actual_batch) = message else {
+        assert!(matches!(message, FlightMessage::Recordbatch(_)));
+        let FlightMessage::Recordbatch(actual_batch) = message else {
            unreachable!()
        };
        assert_eq!(actual_batch, batch2);
@@ -360,22 +320,27 @@ mod test {

    #[test]
    fn test_flight_messages_to_recordbatches() {
-        let schema = Arc::new(Schema::new(vec![Field::new("m", DataType::Int32, true)]));
-        let batch1 = DfRecordBatch::try_new(
+        let schema = Arc::new(Schema::new(vec![ColumnSchema::new(
+            "m",
+            ConcreteDataType::int32_datatype(),
+            true,
+        )]));
+        let batch1 = RecordBatch::new(
            schema.clone(),
-            vec![Arc::new(Int32Array::from(vec![Some(2), None, Some(4)])) as _],
+            vec![Arc::new(Int32Vector::from(vec![Some(2), None, Some(4)])) as _],
        )
        .unwrap();
-        let batch2 = DfRecordBatch::try_new(
+        let batch2 = RecordBatch::new(
            schema.clone(),
-            vec![Arc::new(Int32Array::from(vec![None, Some(6)])) as _],
+            vec![Arc::new(Int32Vector::from(vec![None, Some(6)])) as _],
        )
        .unwrap();
-        let recordbatches = vec![batch1.clone(), batch2.clone()];
+        let recordbatches =
+            RecordBatches::try_new(schema.clone(), vec![batch1.clone(), batch2.clone()]).unwrap();

        let m1 = FlightMessage::Schema(schema);
-        let m2 = FlightMessage::RecordBatch(batch1);
-        let m3 = FlightMessage::RecordBatch(batch2);
+        let m2 = FlightMessage::Recordbatch(batch1);
+        let m3 = FlightMessage::Recordbatch(batch2);

        let result = flight_messages_to_recordbatches(vec![m2.clone(), m1.clone(), m3.clone()]);
        assert!(matches!(result, Err(Error::InvalidFlightData { .. })));
--- a/src/common/meta/Cargo.toml
+++ b/src/common/meta/Cargo.toml
@@ -42,7 +42,6 @@ deadpool = { workspace = true, optional = true }
 deadpool-postgres = { workspace = true, optional = true }
 derive_builder.workspace = true
 etcd-client.workspace = true
-flexbuffers = "25.2"
 futures.workspace = true
 futures-util.workspace = true
 hex.workspace = true
@@ -50,7 +49,6 @@ humantime-serde.workspace = true
 itertools.workspace = true
 lazy_static.workspace = true
 moka.workspace = true
-object-store.workspace = true
 prometheus.workspace = true
 prost.workspace = true
 rand.workspace = true
@@ -73,7 +71,6 @@ typetag.workspace = true
 [dev-dependencies]
 chrono.workspace = true
 common-procedure = { workspace = true, features = ["testing"] }
-common-test-util.workspace = true
 common-wal = { workspace = true, features = ["testing"] }
 datatypes.workspace = true
 hyper = { version = "0.14", features = ["full"] }
--- a/src/common/meta/src/cache_invalidator.rs
+++ b/src/common/meta/src/cache_invalidator.rs
@@ -16,12 +16,9 @@ use std::sync::Arc;

 use crate::error::Result;
 use crate::flow_name::FlowName;
-use crate::instruction::{CacheIdent, DropFlow};
+use crate::instruction::CacheIdent;
 use crate::key::flow::flow_info::FlowInfoKey;
 use crate::key::flow::flow_name::FlowNameKey;
-use crate::key::flow::flow_route::FlowRouteKey;
-use crate::key::flow::flownode_flow::FlownodeFlowKey;
-use crate::key::flow::table_flow::TableFlowKey;
 use crate::key::schema_name::SchemaNameKey;
 use crate::key::table_info::TableInfoKey;
 use crate::key::table_name::TableNameKey;
@@ -92,40 +89,9 @@ where
                    let key: SchemaNameKey = schema_name.into();
                    self.invalidate_key(&key.to_bytes()).await;
                }
-                CacheIdent::CreateFlow(_) => {
+                CacheIdent::CreateFlow(_) | CacheIdent::DropFlow(_) => {
                    // Do nothing
                }
-                CacheIdent::DropFlow(DropFlow {
-                    flow_id,
-                    source_table_ids,
-                    flow_part2node_id,
-                }) => {
-                    // invalidate flow route/flownode flow/table flow
-                    let mut keys = Vec::with_capacity(
-                        source_table_ids.len() * flow_part2node_id.len()
-                            + flow_part2node_id.len() * 2,
-                    );
-                    for table_id in source_table_ids {
-                        for (partition_id, node_id) in flow_part2node_id {
-                            let key =
-                                TableFlowKey::new(*table_id, *node_id, *flow_id, *partition_id)
-                                    .to_bytes();
-                            keys.push(key);
-                        }
-                    }
-
-                    for (partition_id, node_id) in flow_part2node_id {
-                        let key =
-                            FlownodeFlowKey::new(*node_id, *flow_id, *partition_id).to_bytes();
-                        keys.push(key);
-                        let key = FlowRouteKey::new(*flow_id, *partition_id).to_bytes();
-                        keys.push(key);
-                    }
-
-                    for key in keys {
-                        self.invalidate_key(&key).await;
-                    }
-                }
                CacheIdent::FlowName(FlowName {
                    catalog_name,
                    flow_name,
--- a/src/common/meta/src/ddl/alter_database.rs
+++ b/src/common/meta/src/ddl/alter_database.rs
@@ -21,7 +21,7 @@ use snafu::{ensure, ResultExt};
 use strum::AsRefStr;

 use crate::cache_invalidator::Context;
-use crate::ddl::utils::map_to_procedure_error;
+use crate::ddl::utils::handle_retry_error;
 use crate::ddl::DdlContext;
 use crate::error::{Result, SchemaNotFoundSnafu};
 use crate::instruction::CacheIdent;
@@ -148,7 +148,7 @@ impl Procedure for AlterDatabaseProcedure {
            AlterDatabaseState::UpdateMetadata => self.on_update_metadata().await,
            AlterDatabaseState::InvalidateSchemaCache => self.on_invalidate_schema_cache().await,
        }
-        .map_err(map_to_procedure_error)
+        .map_err(handle_retry_error)
    }

    fn dump(&self) -> ProcedureResult<String> {
--- a/src/common/meta/src/ddl/alter_logical_tables.rs
+++ b/src/common/meta/src/ddl/alter_logical_tables.rs
@@ -32,12 +32,9 @@ use store_api::metric_engine_consts::ALTER_PHYSICAL_EXTENSION_KEY;
 use strum::AsRefStr;
 use table::metadata::TableId;

-use crate::ddl::utils::{
-    add_peer_context_if_needed, map_to_procedure_error, sync_follower_regions,
-};
+use crate::ddl::utils::{add_peer_context_if_needed, sync_follower_regions};
 use crate::ddl::DdlContext;
-use crate::error::{DecodeJsonSnafu, MetadataCorruptionSnafu, Result};
-use crate::instruction::CacheIdent;
+use crate::error::{DecodeJsonSnafu, Error, MetadataCorruptionSnafu, Result};
 use crate::key::table_info::TableInfoValue;
 use crate::key::table_route::PhysicalTableRouteValue;
 use crate::key::DeserializedValueWithBytes;
@@ -69,7 +66,6 @@ impl AlterLogicalTablesProcedure {
                physical_table_info: None,
                physical_table_route: None,
                physical_columns: vec![],
-                table_cache_keys_to_invalidate: vec![],
            },
        }
    }
@@ -199,19 +195,16 @@ impl AlterLogicalTablesProcedure {
        self.update_physical_table_metadata().await?;
        self.update_logical_tables_metadata().await?;

-        self.data.build_cache_keys_to_invalidate();
-        self.data.clear_metadata_fields();
-
        self.data.state = AlterTablesState::InvalidateTableCache;
        Ok(Status::executing(true))
    }

    pub(crate) async fn on_invalidate_table_cache(&mut self) -> Result<Status> {
-        let to_invalidate = &self.data.table_cache_keys_to_invalidate;
+        let to_invalidate = self.build_table_cache_keys_to_invalidate();

        self.context
            .cache_invalidator
-            .invalidate(&Default::default(), to_invalidate)
+            .invalidate(&Default::default(), &to_invalidate)
            .await?;
        Ok(Status::done())
    }
@@ -224,6 +217,14 @@ impl Procedure for AlterLogicalTablesProcedure {
    }

    async fn execute(&mut self, _ctx: &Context) -> ProcedureResult<Status> {
+        let error_handler = |e: Error| {
+            if e.is_retry_later() {
+                common_procedure::Error::retry_later(e)
+            } else {
+                common_procedure::Error::external(e)
+            }
+        };
+
        let state = &self.data.state;

        let step = state.as_ref();
@@ -240,7 +241,7 @@ impl Procedure for AlterLogicalTablesProcedure {
            AlterTablesState::UpdateMetadata => self.on_update_metadata().await,
            AlterTablesState::InvalidateTableCache => self.on_invalidate_table_cache().await,
        }
-        .map_err(map_to_procedure_error)
+        .map_err(error_handler)
    }

    fn dump(&self) -> ProcedureResult<String> {
@@ -279,20 +280,6 @@ pub struct AlterTablesData {
    physical_table_info: Option<DeserializedValueWithBytes<TableInfoValue>>,
    physical_table_route: Option<PhysicalTableRouteValue>,
    physical_columns: Vec<ColumnMetadata>,
-    table_cache_keys_to_invalidate: Vec<CacheIdent>,
-}
-
-impl AlterTablesData {
-    /// Clears all data fields except `state` and `table_cache_keys_to_invalidate` after metadata update.
-    /// This is done to avoid persisting unnecessary data after the update metadata step.
-    fn clear_metadata_fields(&mut self) {
-        self.tasks.clear();
-        self.table_info_values.clear();
-        self.physical_table_id = 0;
-        self.physical_table_info = None;
-        self.physical_table_route = None;
-        self.physical_columns.clear();
-    }
 }

 #[derive(Debug, Serialize, Deserialize, AsRefStr)]
--- a/src/common/meta/src/ddl/alter_logical_tables/table_cache_keys.rs
+++ b/src/common/meta/src/ddl/alter_logical_tables/table_cache_keys.rs
@@ -15,12 +15,13 @@
 use table::metadata::RawTableInfo;
 use table::table_name::TableName;

-use crate::ddl::alter_logical_tables::AlterTablesData;
+use crate::ddl::alter_logical_tables::AlterLogicalTablesProcedure;
 use crate::instruction::CacheIdent;

-impl AlterTablesData {
-    pub(crate) fn build_cache_keys_to_invalidate(&mut self) {
+impl AlterLogicalTablesProcedure {
+    pub(crate) fn build_table_cache_keys_to_invalidate(&self) -> Vec<CacheIdent> {
        let mut cache_keys = self
+            .data
            .table_info_values
            .iter()
            .flat_map(|table| {
@@ -30,14 +31,14 @@ impl AlterTablesData {
                ]
            })
            .collect::<Vec<_>>();
-        cache_keys.push(CacheIdent::TableId(self.physical_table_id));
+        cache_keys.push(CacheIdent::TableId(self.data.physical_table_id));
        // Safety: physical_table_info already filled in previous steps
-        let physical_table_info = &self.physical_table_info.as_ref().unwrap().table_info;
+        let physical_table_info = &self.data.physical_table_info.as_ref().unwrap().table_info;
        cache_keys.push(CacheIdent::TableName(extract_table_name(
            physical_table_info,
        )));

-        self.table_cache_keys_to_invalidate = cache_keys;
+        cache_keys
    }
 }

--- a/src/common/meta/src/ddl/alter_table.rs
+++ b/src/common/meta/src/ddl/alter_table.rs
@@ -40,11 +40,10 @@ use table::table_reference::TableReference;

 use crate::cache_invalidator::Context;
 use crate::ddl::utils::{
-    add_peer_context_if_needed, handle_multiple_results, map_to_procedure_error,
-    sync_follower_regions, MultipleResults,
+    add_peer_context_if_needed, handle_multiple_results, sync_follower_regions, MultipleResults,
 };
 use crate::ddl::DdlContext;
-use crate::error::{AbortProcedureSnafu, NoLeaderSnafu, PutPoisonSnafu, Result, RetryLaterSnafu};
+use crate::error::{AbortProcedureSnafu, Error, NoLeaderSnafu, PutPoisonSnafu, Result};
 use crate::instruction::CacheIdent;
 use crate::key::table_info::TableInfoValue;
 use crate::key::{DeserializedValueWithBytes, RegionDistribution};
@@ -196,10 +195,7 @@ impl AlterTableProcedure {
            }
            MultipleResults::AllRetryable(error) => {
                // Just returns the error, and wait for the next try.
-                let err = BoxedError::new(error);
-                Err(err).context(RetryLaterSnafu {
-                    clean_poisons: true,
-                })
+                Err(error)
            }
            MultipleResults::Ok(results) => {
                self.submit_sync_region_requests(results, &physical_table_route.region_routes)
@@ -327,6 +323,16 @@ impl Procedure for AlterTableProcedure {
    }

    async fn execute(&mut self, ctx: &ProcedureContext) -> ProcedureResult<Status> {
+        let error_handler = |e: Error| {
+            if e.is_retry_later() {
+                ProcedureError::retry_later(e)
+            } else if e.need_clean_poisons() {
+                ProcedureError::external_and_clean_poisons(e)
+            } else {
+                ProcedureError::external(e)
+            }
+        };
+
        let state = &self.data.state;

        let step = state.as_ref();
@@ -344,7 +350,7 @@ impl Procedure for AlterTableProcedure {
            AlterTableState::UpdateMetadata => self.on_update_metadata().await,
            AlterTableState::InvalidateTableCache => self.on_broadcast().await,
        }
-        .map_err(map_to_procedure_error)
+        .map_err(error_handler)
    }

    fn dump(&self) -> ProcedureResult<String> {
--- a/src/common/meta/src/ddl/create_database.rs
+++ b/src/common/meta/src/ddl/create_database.rs
@@ -22,7 +22,7 @@ use serde_with::{serde_as, DefaultOnNull};
 use snafu::{ensure, ResultExt};
 use strum::AsRefStr;

-use crate::ddl::utils::map_to_procedure_error;
+use crate::ddl::utils::handle_retry_error;
 use crate::ddl::DdlContext;
 use crate::error::{self, Result};
 use crate::key::schema_name::{SchemaNameKey, SchemaNameValue};
@@ -115,7 +115,7 @@ impl Procedure for CreateDatabaseProcedure {
            CreateDatabaseState::Prepare => self.on_prepare().await,
            CreateDatabaseState::CreateMetadata => self.on_create_metadata().await,
        }
-        .map_err(map_to_procedure_error)
+        .map_err(handle_retry_error)
    }

    fn dump(&self) -> ProcedureResult<String> {
--- a/src/common/meta/src/ddl/create_flow.rs
+++ b/src/common/meta/src/ddl/create_flow.rs
@@ -36,7 +36,7 @@ use strum::AsRefStr;
 use table::metadata::TableId;

 use crate::cache_invalidator::Context;
-use crate::ddl::utils::{add_peer_context_if_needed, map_to_procedure_error};
+use crate::ddl::utils::{add_peer_context_if_needed, handle_retry_error};
 use crate::ddl::DdlContext;
 use crate::error::{self, Result, UnexpectedSnafu};
 use crate::instruction::{CacheIdent, CreateFlow, DropFlow};
@@ -304,7 +304,7 @@ impl Procedure for CreateFlowProcedure {
            CreateFlowState::CreateMetadata => self.on_create_metadata().await,
            CreateFlowState::InvalidateFlowCache => self.on_broadcast().await,
        }
-        .map_err(map_to_procedure_error)
+        .map_err(handle_retry_error)
    }

    fn dump(&self) -> ProcedureResult<String> {
--- a/src/common/meta/src/ddl/create_logical_tables.rs
+++ b/src/common/meta/src/ddl/create_logical_tables.rs
@@ -33,9 +33,7 @@ use store_api::storage::{RegionId, RegionNumber};
 use strum::AsRefStr;
 use table::metadata::{RawTableInfo, TableId};

-use crate::ddl::utils::{
-    add_peer_context_if_needed, map_to_procedure_error, sync_follower_regions,
-};
+use crate::ddl::utils::{add_peer_context_if_needed, handle_retry_error, sync_follower_regions};
 use crate::ddl::DdlContext;
 use crate::error::{DecodeJsonSnafu, MetadataCorruptionSnafu, Result};
 use crate::key::table_route::TableRouteValue;
@@ -240,7 +238,7 @@ impl Procedure for CreateLogicalTablesProcedure {
            CreateTablesState::DatanodeCreateRegions => self.on_datanode_create_regions().await,
            CreateTablesState::CreateMetadata => self.on_create_metadata().await,
        }
-        .map_err(map_to_procedure_error)
+        .map_err(handle_retry_error)
    }

    fn dump(&self) -> ProcedureResult<String> {
--- a/src/common/meta/src/ddl/create_table.rs
+++ b/src/common/meta/src/ddl/create_table.rs
@@ -34,7 +34,7 @@ use table::table_reference::TableReference;

 use crate::ddl::create_table_template::{build_template, CreateRequestBuilder};
 use crate::ddl::utils::{
-    add_peer_context_if_needed, convert_region_routes_to_detecting_regions, map_to_procedure_error,
+    add_peer_context_if_needed, convert_region_routes_to_detecting_regions, handle_retry_error,
    region_storage_path,
 };
 use crate::ddl::{DdlContext, TableMetadata};
@@ -319,7 +319,7 @@ impl Procedure for CreateTableProcedure {
            CreateTableState::DatanodeCreateRegions => self.on_datanode_create_regions().await,
            CreateTableState::CreateMetadata => self.on_create_metadata().await,
        }
-        .map_err(map_to_procedure_error)
+        .map_err(handle_retry_error)
    }

    fn dump(&self) -> ProcedureResult<String> {
--- a/src/common/meta/src/ddl/create_view.rs
+++ b/src/common/meta/src/ddl/create_view.rs
@@ -23,7 +23,7 @@ use table::metadata::{RawTableInfo, TableId, TableType};
 use table::table_reference::TableReference;

 use crate::cache_invalidator::Context;
-use crate::ddl::utils::map_to_procedure_error;
+use crate::ddl::utils::handle_retry_error;
 use crate::ddl::{DdlContext, TableMetadata};
 use crate::error::{self, Result};
 use crate::instruction::CacheIdent;
@@ -249,7 +249,7 @@ impl Procedure for CreateViewProcedure {
            CreateViewState::Prepare => self.on_prepare().await,
            CreateViewState::CreateMetadata => self.on_create_metadata(ctx).await,
        }
-        .map_err(map_to_procedure_error)
+        .map_err(handle_retry_error)
    }

    fn dump(&self) -> ProcedureResult<String> {
--- a/src/common/meta/src/ddl/drop_database.rs
+++ b/src/common/meta/src/ddl/drop_database.rs
@@ -21,7 +21,7 @@ use std::any::Any;
 use std::fmt::Debug;

 use common_error::ext::BoxedError;
-use common_procedure::error::{ExternalSnafu, FromJsonSnafu, ToJsonSnafu};
+use common_procedure::error::{Error as ProcedureError, ExternalSnafu, FromJsonSnafu, ToJsonSnafu};
 use common_procedure::{
    Context as ProcedureContext, LockKey, Procedure, Result as ProcedureResult, Status,
 };
@@ -31,7 +31,6 @@ use snafu::ResultExt;
 use tonic::async_trait;

 use self::start::DropDatabaseStart;
-use crate::ddl::utils::map_to_procedure_error;
 use crate::ddl::DdlContext;
 use crate::error::Result;
 use crate::key::table_name::TableNameValue;
@@ -142,7 +141,13 @@ impl Procedure for DropDatabaseProcedure {
        let (next, status) = state
            .next(&self.runtime_context, &mut self.context)
            .await
-            .map_err(map_to_procedure_error)?;
+            .map_err(|e| {
+                if e.is_retry_later() {
+                    ProcedureError::retry_later(e)
+                } else {
+                    ProcedureError::external(e)
+                }
+            })?;

        *state = next;
        Ok(status)
--- a/src/common/meta/src/ddl/drop_database/executor.rs
+++ b/src/common/meta/src/ddl/drop_database/executor.rs
@@ -323,7 +323,6 @@ mod tests {
                    }
                    .build(),
                ),
-                clean_poisons: false,
            })
        }

--- a/src/common/meta/src/ddl/drop_flow.rs
+++ b/src/common/meta/src/ddl/drop_flow.rs
@@ -30,7 +30,7 @@ use snafu::{ensure, ResultExt};
 use strum::AsRefStr;

 use crate::cache_invalidator::Context;
-use crate::ddl::utils::{add_peer_context_if_needed, map_to_procedure_error};
+use crate::ddl::utils::{add_peer_context_if_needed, handle_retry_error};
 use crate::ddl::DdlContext;
 use crate::error::{self, Result};
 use crate::flow_name::FlowName;
@@ -201,7 +201,7 @@ impl Procedure for DropFlowProcedure {
            DropFlowState::InvalidateFlowCache => self.on_broadcast().await,
            DropFlowState::DropFlows => self.on_flownode_drop_flows().await,
        }
-        .map_err(map_to_procedure_error)
+        .map_err(handle_retry_error)
    }

    fn dump(&self) -> ProcedureResult<String> {
--- a/src/common/meta/src/ddl/drop_table.rs
+++ b/src/common/meta/src/ddl/drop_table.rs
@@ -35,7 +35,7 @@ use table::metadata::TableId;
 use table::table_reference::TableReference;

 use self::executor::DropTableExecutor;
-use crate::ddl::utils::map_to_procedure_error;
+use crate::ddl::utils::handle_retry_error;
 use crate::ddl::DdlContext;
 use crate::error::{self, Result};
 use crate::key::table_route::TableRouteValue;
@@ -221,7 +221,7 @@ impl Procedure for DropTableProcedure {
            DropTableState::DatanodeDropRegions => self.on_datanode_drop_regions().await,
            DropTableState::DeleteTombstone => self.on_delete_metadata_tombstone().await,
        }
-        .map_err(map_to_procedure_error)
+        .map_err(handle_retry_error)
    }

    fn dump(&self) -> ProcedureResult<String> {
--- a/src/common/meta/src/ddl/drop_view.rs
+++ b/src/common/meta/src/ddl/drop_view.rs
@@ -25,7 +25,7 @@ use table::metadata::{RawTableInfo, TableId, TableType};
 use table::table_reference::TableReference;

 use crate::cache_invalidator::Context;
-use crate::ddl::utils::map_to_procedure_error;
+use crate::ddl::utils::handle_retry_error;
 use crate::ddl::DdlContext;
 use crate::error::{self, Result};
 use crate::instruction::CacheIdent;
@@ -191,7 +191,7 @@ impl Procedure for DropViewProcedure {
            DropViewState::DeleteMetadata => self.on_delete_metadata().await,
            DropViewState::InvalidateViewCache => self.on_broadcast().await,
        }
-        .map_err(map_to_procedure_error)
+        .map_err(handle_retry_error)
    }

    fn dump(&self) -> ProcedureResult<String> {
--- a/src/common/meta/src/ddl/test_util/datanode_handler.rs
+++ b/src/common/meta/src/ddl/test_util/datanode_handler.rs
@@ -105,7 +105,6 @@ impl MockDatanodeHandler for RetryErrorDatanodeHandler {
                }
                .build(),
            ),
-            clean_poisons: false,
        })
    }

@@ -219,7 +218,6 @@ impl MockDatanodeHandler for PartialSuccessDatanodeHandler {
                    }
                    .build(),
                ),
-                clean_poisons: false,
            })
        } else {
            error::UnexpectedSnafu {
@@ -254,7 +252,6 @@ impl MockDatanodeHandler for AllFailureDatanodeHandler {
                    }
                    .build(),
                ),
-                clean_poisons: false,
            })
        } else {
            error::UnexpectedSnafu {
--- a/src/common/meta/src/ddl/tests/alter_table.rs
+++ b/src/common/meta/src/ddl/tests/alter_table.rs
@@ -575,7 +575,6 @@ async fn test_on_submit_alter_request_with_partial_success_retryable() {
        .await
        .unwrap_err();
    assert!(result.is_retry_later());
-    assert!(!result.need_clean_poisons());

    // Submits again
    let result = procedure
@@ -583,7 +582,6 @@ async fn test_on_submit_alter_request_with_partial_success_retryable() {
        .await
        .unwrap_err();
    assert!(result.is_retry_later());
-    assert!(!result.need_clean_poisons());
 }

 #[tokio::test]
@@ -620,14 +618,12 @@ async fn test_on_submit_alter_request_with_all_failure_retrybale() {
        .await
        .unwrap_err();
    assert!(err.is_retry_later());
-    assert!(err.need_clean_poisons());
    // submits again
    let err = procedure
        .submit_alter_region_requests(procedure_id, provider.as_ref())
        .await
        .unwrap_err();
    assert!(err.is_retry_later());
-    assert!(err.need_clean_poisons());
 }

 #[tokio::test]
--- a/src/common/meta/src/ddl/truncate_table.rs
+++ b/src/common/meta/src/ddl/truncate_table.rs
@@ -31,7 +31,7 @@ use table::metadata::{RawTableInfo, TableId};
 use table::table_name::TableName;
 use table::table_reference::TableReference;

-use crate::ddl::utils::{add_peer_context_if_needed, map_to_procedure_error};
+use crate::ddl::utils::{add_peer_context_if_needed, handle_retry_error};
 use crate::ddl::DdlContext;
 use crate::error::{Result, TableNotFoundSnafu};
 use crate::key::table_info::TableInfoValue;
@@ -66,7 +66,7 @@ impl Procedure for TruncateTableProcedure {
                self.on_datanode_truncate_regions().await
            }
        }
-        .map_err(map_to_procedure_error)
+        .map_err(handle_retry_error)
    }

    fn dump(&self) -> ProcedureResult<String> {
--- a/src/common/meta/src/ddl/utils.rs
+++ b/src/common/meta/src/ddl/utils.rs
@@ -60,16 +60,11 @@ pub fn add_peer_context_if_needed(datanode: Peer) -> impl FnOnce(Error) -> Error
    }
 }

-/// Maps the error to the corresponding procedure error.
-///
-/// This function determines whether the error should be retried and if poison cleanup is needed,
-/// then maps it to the appropriate procedure error variant.
-pub fn map_to_procedure_error(e: Error) -> ProcedureError {
-    match (e.is_retry_later(), e.need_clean_poisons()) {
-        (true, true) => ProcedureError::retry_later_and_clean_poisons(e),
-        (true, false) => ProcedureError::retry_later(e),
-        (false, true) => ProcedureError::external_and_clean_poisons(e),
-        (false, false) => ProcedureError::external(e),
+pub fn handle_retry_error(e: Error) -> ProcedureError {
+    if e.is_retry_later() {
+        ProcedureError::retry_later(e)
+    } else {
+        ProcedureError::external(e)
    }
 }

--- a/src/common/meta/src/error.rs
+++ b/src/common/meta/src/error.rs
@@ -454,10 +454,7 @@ pub enum Error {
    },

    #[snafu(display("Retry later"))]
-    RetryLater {
-        source: BoxedError,
-        clean_poisons: bool,
-    },
+    RetryLater { source: BoxedError },

    #[snafu(display("Abort procedure"))]
    AbortProcedure {
@@ -815,68 +812,6 @@ pub enum Error {
        #[snafu(source)]
        error: common_time::error::Error,
    },
-    #[snafu(display("Invalid file path: {}", file_path))]
-    InvalidFilePath {
-        #[snafu(implicit)]
-        location: Location,
-        file_path: String,
-    },
-
-    #[snafu(display("Failed to serialize flexbuffers"))]
-    SerializeFlexbuffers {
-        #[snafu(implicit)]
-        location: Location,
-        #[snafu(source)]
-        error: flexbuffers::SerializationError,
-    },
-
-    #[snafu(display("Failed to deserialize flexbuffers"))]
-    DeserializeFlexbuffers {
-        #[snafu(implicit)]
-        location: Location,
-        #[snafu(source)]
-        error: flexbuffers::DeserializationError,
-    },
-
-    #[snafu(display("Failed to read flexbuffers"))]
-    ReadFlexbuffers {
-        #[snafu(implicit)]
-        location: Location,
-        #[snafu(source)]
-        error: flexbuffers::ReaderError,
-    },
-
-    #[snafu(display("Invalid file name: {}", reason))]
-    InvalidFileName {
-        #[snafu(implicit)]
-        location: Location,
-        reason: String,
-    },
-
-    #[snafu(display("Invalid file extension: {}", reason))]
-    InvalidFileExtension {
-        #[snafu(implicit)]
-        location: Location,
-        reason: String,
-    },
-
-    #[snafu(display("Failed to write object, file path: {}", file_path))]
-    WriteObject {
-        #[snafu(implicit)]
-        location: Location,
-        file_path: String,
-        #[snafu(source)]
-        error: object_store::Error,
-    },
-
-    #[snafu(display("Failed to read object, file path: {}", file_path))]
-    ReadObject {
-        #[snafu(implicit)]
-        location: Location,
-        file_path: String,
-        #[snafu(source)]
-        error: object_store::Error,
-    },
 }

 pub type Result<T> = std::result::Result<T, Error>;
@@ -899,7 +834,6 @@ impl ErrorExt for Error {
            ValueNotExist { .. } | ProcedurePoisonConflict { .. } => StatusCode::Unexpected,

            Unsupported { .. } => StatusCode::Unsupported,
-            WriteObject { .. } | ReadObject { .. } => StatusCode::StorageUnavailable,

            SerdeJson { .. }
            | ParseOption { .. }
@@ -933,10 +867,7 @@ impl ErrorExt for Error {
            | FromUtf8 { .. }
            | MetadataCorruption { .. }
            | ParseWalOptions { .. }
-            | KafkaGetOffset { .. }
-            | ReadFlexbuffers { .. }
-            | SerializeFlexbuffers { .. }
-            | DeserializeFlexbuffers { .. } => StatusCode::Unexpected,
+            | KafkaGetOffset { .. } => StatusCode::Unexpected,

            SendMessage { .. } | GetKvCache { .. } | CacheNotGet { .. } => StatusCode::Internal,

@@ -953,10 +884,7 @@ impl ErrorExt for Error {
            | InvalidSetDatabaseOption { .. }
            | InvalidUnsetDatabaseOption { .. }
            | InvalidTopicNamePrefix { .. }
-            | InvalidTimeZone { .. }
-            | InvalidFileExtension { .. }
-            | InvalidFileName { .. }
-            | InvalidFilePath { .. } => StatusCode::InvalidArguments,
+            | InvalidTimeZone { .. } => StatusCode::InvalidArguments,
            InvalidFlowRequestBody { .. } => StatusCode::InvalidArguments,

            FlowNotFound { .. } => StatusCode::FlowNotFound,
@@ -1042,7 +970,6 @@ impl Error {
    pub fn retry_later<E: ErrorExt + Send + Sync + 'static>(err: E) -> Error {
        Error::RetryLater {
            source: BoxedError::new(err),
-            clean_poisons: false,
        }
    }

@@ -1053,13 +980,7 @@ impl Error {

    /// Determine whether it needs to clean poisons.
    pub fn need_clean_poisons(&self) -> bool {
-        matches!(
-            self,
-            Error::AbortProcedure { clean_poisons, .. } if *clean_poisons
-        ) || matches!(
-            self,
-            Error::RetryLater { clean_poisons, .. } if *clean_poisons
-        )
+        matches!(self, Error::AbortProcedure { clean_poisons, .. } if *clean_poisons)
    }

    /// Returns true if the response exceeds the size limit.
--- a/src/common/meta/src/key/flow.rs
+++ b/src/common/meta/src/key/flow.rs
@@ -45,7 +45,7 @@ use crate::kv_backend::KvBackendRef;
 use crate::rpc::store::BatchDeleteRequest;

 /// The key of `__flow/` scope.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, PartialEq)]
 pub struct FlowScoped<T> {
    inner: T,
 }
--- a/src/common/meta/src/key/flow/flow_info.rs
+++ b/src/common/meta/src/key/flow/flow_info.rs
@@ -153,15 +153,6 @@ impl FlowInfoValue {
        &self.flownode_ids
    }

-    /// Insert a new flownode id for a partition.
-    pub fn insert_flownode_id(
-        &mut self,
-        partition: FlowPartitionId,
-        node: FlownodeId,
-    ) -> Option<FlownodeId> {
-        self.flownode_ids.insert(partition, node)
-    }
-
    /// Returns the `source_table`.
    pub fn source_table_ids(&self) -> &[TableId] {
        &self.source_table_ids
--- a/src/common/meta/src/key/flow/flow_name.rs
+++ b/src/common/meta/src/key/flow/flow_name.rs
@@ -205,7 +205,7 @@ impl FlowNameManager {
        catalog: &str,
    ) -> BoxStream<'static, Result<(String, FlowNameValue)>> {
        let start_key = FlowNameKey::range_start_key(catalog);
-        common_telemetry::trace!("flow_names: start_key: {:?}", start_key);
+        common_telemetry::debug!("flow_names: start_key: {:?}", start_key);
        let req = RangeRequest::new().with_prefix(start_key);

        let stream = PaginationStream::new(
--- a/src/common/meta/src/key/flow/flow_route.rs
+++ b/src/common/meta/src/key/flow/flow_route.rs
@@ -42,7 +42,7 @@ lazy_static! {
 /// The key stores the route info of the flow.
 ///
 /// The layout: `__flow/route/{flow_id}/{partition_id}`.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, PartialEq)]
 pub struct FlowRouteKey(FlowScoped<FlowRouteKeyInner>);

 impl FlowRouteKey {
@@ -145,12 +145,6 @@ pub struct FlowRouteValue {
    pub(crate) peer: Peer,
 }

-impl From<Peer> for FlowRouteValue {
-    fn from(peer: Peer) -> Self {
-        Self { peer }
-    }
-}
-
 impl FlowRouteValue {
    /// Returns the `peer`.
    pub fn peer(&self) -> &Peer {
--- a/src/common/meta/src/key/flow/flownode_flow.rs
+++ b/src/common/meta/src/key/flow/flownode_flow.rs
@@ -166,17 +166,6 @@ impl FlownodeFlowManager {
        Self { kv_backend }
    }

-    /// Whether given flow exist on this flownode.
-    pub async fn exists(
-        &self,
-        flownode_id: FlownodeId,
-        flow_id: FlowId,
-        partition_id: FlowPartitionId,
-    ) -> Result<bool> {
-        let key = FlownodeFlowKey::new(flownode_id, flow_id, partition_id).to_bytes();
-        Ok(self.kv_backend.get(&key).await?.is_some())
-    }
-
    /// Retrieves all [FlowId] and [FlowPartitionId]s of the specified `flownode_id`.
    pub fn flows(
        &self,
--- a/src/common/meta/src/kv_backend.rs
+++ b/src/common/meta/src/kv_backend.rs
@@ -38,14 +38,6 @@ pub mod txn;
 pub mod util;
 pub type KvBackendRef<E = Error> = Arc<dyn KvBackend<Error = E> + Send + Sync>;

-#[cfg(any(feature = "pg_kvbackend", feature = "mysql_kvbackend"))]
-// The default meta table name, default is "greptime_metakv".
-pub const DEFAULT_META_TABLE_NAME: &str = "greptime_metakv";
-
-#[cfg(any(feature = "pg_kvbackend", feature = "mysql_kvbackend"))]
-// The default lock id for election, default is 1.
-pub const DEFAULT_META_ELECTION_LOCK_ID: u64 = 1;
-
 #[async_trait]
 pub trait KvBackend: TxnService
 where
--- a/src/common/meta/src/kv_backend/memory.rs
+++ b/src/common/meta/src/kv_backend/memory.rs
@@ -308,11 +308,10 @@ mod tests {
    use super::*;
    use crate::error::Error;
    use crate::kv_backend::test::{
-        prepare_kv, prepare_kv_with_prefix, 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,
-        test_simple_kv_range, test_txn_compare_equal, test_txn_compare_greater,
-        test_txn_compare_less, test_txn_compare_not_equal, test_txn_one_compare_op,
-        text_txn_multi_compare_op, unprepare_kv,
+        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, test_txn_compare_equal,
+        test_txn_compare_greater, test_txn_compare_less, test_txn_compare_not_equal,
+        test_txn_one_compare_op, text_txn_multi_compare_op,
    };

    async fn mock_mem_store_with_data() -> MemoryKvBackend<Error> {
@@ -381,12 +380,4 @@ mod tests {
        test_txn_compare_less(&kv_backend).await;
        test_txn_compare_not_equal(&kv_backend).await;
    }
-    #[tokio::test]
-    async fn test_mem_all_range() {
-        let kv_backend = MemoryKvBackend::<Error>::new();
-        let prefix = b"";
-        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
-        test_simple_kv_range(&kv_backend).await;
-        unprepare_kv(&kv_backend, prefix).await;
-    }
 }
--- a/src/common/meta/src/kv_backend/rds.rs
+++ b/src/common/meta/src/kv_backend/rds.rs
@@ -33,12 +33,6 @@ use crate::rpc::store::{
 };
 use crate::rpc::KeyValue;

-const RDS_STORE_OP_BATCH_GET: &str = "batch_get";
-const RDS_STORE_OP_BATCH_PUT: &str = "batch_put";
-const RDS_STORE_OP_RANGE_QUERY: &str = "range_query";
-const RDS_STORE_OP_RANGE_DELETE: &str = "range_delete";
-const RDS_STORE_OP_BATCH_DELETE: &str = "batch_delete";
-
 #[cfg(feature = "pg_kvbackend")]
 mod postgres;
 #[cfg(feature = "pg_kvbackend")]
@@ -566,21 +560,3 @@ fn check_txn_ops(txn_ops: &[TxnOp]) -> Result<bool> {
    });
    Ok(same)
 }
-
-#[macro_export]
-macro_rules! record_rds_sql_execute_elapsed {
-    ($result:expr, $label_store:expr,$label_op:expr,$label_type:expr) => {{
-        let timer = std::time::Instant::now();
-        $result
-            .inspect(|_| {
-                $crate::metrics::RDS_SQL_EXECUTE_ELAPSED
-                    .with_label_values(&[$label_store, "success", $label_op, $label_type])
-                    .observe(timer.elapsed().as_millis_f64())
-            })
-            .inspect_err(|_| {
-                $crate::metrics::RDS_SQL_EXECUTE_ELAPSED
-                    .with_label_values(&[$label_store, "error", $label_op, $label_type])
-                    .observe(timer.elapsed().as_millis_f64());
-            })
-    }};
-}
--- a/src/common/meta/src/kv_backend/rds/mysql.rs
+++ b/src/common/meta/src/kv_backend/rds/mysql.rs
@@ -20,13 +20,11 @@ use snafu::ResultExt;
 use sqlx::mysql::MySqlRow;
 use sqlx::pool::Pool;
 use sqlx::{MySql, MySqlPool, Row, Transaction as MySqlTransaction};
-use strum::AsRefStr;

 use crate::error::{CreateMySqlPoolSnafu, MySqlExecutionSnafu, MySqlTransactionSnafu, Result};
 use crate::kv_backend::rds::{
    Executor, ExecutorFactory, ExecutorImpl, KvQueryExecutor, RdsStore, Transaction,
-    RDS_STORE_OP_BATCH_DELETE, RDS_STORE_OP_BATCH_GET, RDS_STORE_OP_BATCH_PUT,
-    RDS_STORE_OP_RANGE_DELETE, RDS_STORE_OP_RANGE_QUERY, RDS_STORE_TXN_RETRY_COUNT,
+    RDS_STORE_TXN_RETRY_COUNT,
 };
 use crate::kv_backend::KvBackendRef;
 use crate::rpc::store::{
@@ -35,8 +33,6 @@ use crate::rpc::store::{
 };
 use crate::rpc::KeyValue;

-const MYSQL_STORE_NAME: &str = "mysql_store";
-
 type MySqlClient = Arc<Pool<MySql>>;
 pub struct MySqlTxnClient(MySqlTransaction<'static, MySql>);

@@ -51,7 +47,7 @@ fn key_value_from_row(row: MySqlRow) -> KeyValue {
 const EMPTY: &[u8] = &[0];

 /// Type of range template.
-#[derive(Debug, Clone, Copy, AsRefStr)]
+#[derive(Debug, Clone, Copy)]
 enum RangeTemplateType {
    Point,
    Range,
@@ -62,8 +58,6 @@ enum RangeTemplateType {

 /// Builds params for the given range template type.
 impl RangeTemplateType {
-    /// Builds the parameters for the given range template type.
-    /// You can check out the conventions at [RangeRequest]
    fn build_params(&self, mut key: Vec<u8>, range_end: Vec<u8>) -> Vec<Vec<u8>> {
        match self {
            RangeTemplateType::Point => vec![key],
@@ -166,7 +160,7 @@ impl<'a> MySqlTemplateFactory<'a> {
            range_template: RangeTemplate {
                point: format!("SELECT k, v FROM `{table_name}` WHERE k = ?"),
                range: format!("SELECT k, v FROM `{table_name}` WHERE k >= ? AND k < ? ORDER BY k"),
-                full: format!("SELECT k, v FROM `{table_name}` ORDER BY k"),
+                full: format!("SELECT k, v FROM `{table_name}` ? ORDER BY k"),
                left_bounded: format!("SELECT k, v FROM `{table_name}` WHERE k >= ? ORDER BY k"),
                prefix: format!("SELECT k, v FROM `{table_name}` WHERE k LIKE ? ORDER BY k"),
            },
@@ -349,12 +343,7 @@ impl KvQueryExecutor<MySqlClient> for MySqlStore {
            RangeTemplate::with_limit(template, if req.limit == 0 { 0 } else { req.limit + 1 });
        let limit = req.limit as usize;
        debug!("query: {:?}, params: {:?}", query, params);
-        let mut kvs = crate::record_rds_sql_execute_elapsed!(
-            query_executor.query(&query, &params_ref).await,
-            MYSQL_STORE_NAME,
-            RDS_STORE_OP_RANGE_QUERY,
-            template_type.as_ref()
-        )?;
+        let mut kvs = query_executor.query(&query, &params_ref).await?;
        if req.keys_only {
            kvs.iter_mut().for_each(|kv| kv.value = vec![]);
        }
@@ -392,12 +381,7 @@ impl KvQueryExecutor<MySqlClient> for MySqlStore {

        // Fast path: if we don't need previous kvs, we can just upsert the keys.
        if !req.prev_kv {
-            crate::record_rds_sql_execute_elapsed!(
-                query_executor.execute(&update, &values_params).await,
-                MYSQL_STORE_NAME,
-                RDS_STORE_OP_BATCH_PUT,
-                ""
-            )?;
+            query_executor.execute(&update, &values_params).await?;
            return Ok(BatchPutResponse::default());
        }
        // Should use transaction to ensure atomicity.
@@ -408,12 +392,7 @@ impl KvQueryExecutor<MySqlClient> for MySqlStore {
            txn.commit().await?;
            return res;
        }
-        let prev_kvs = crate::record_rds_sql_execute_elapsed!(
-            query_executor.query(&select, &in_params).await,
-            MYSQL_STORE_NAME,
-            RDS_STORE_OP_BATCH_PUT,
-            ""
-        )?;
+        let prev_kvs = query_executor.query(&select, &in_params).await?;
        query_executor.execute(&update, &values_params).await?;
        Ok(BatchPutResponse { prev_kvs })
    }
@@ -430,12 +409,7 @@ impl KvQueryExecutor<MySqlClient> for MySqlStore {
            .sql_template_set
            .generate_batch_get_query(req.keys.len());
        let params = req.keys.iter().map(|x| x as _).collect::<Vec<_>>();
-        let kvs = crate::record_rds_sql_execute_elapsed!(
-            query_executor.query(&query, &params).await,
-            MYSQL_STORE_NAME,
-            RDS_STORE_OP_BATCH_GET,
-            ""
-        )?;
+        let kvs = query_executor.query(&query, &params).await?;
        Ok(BatchGetResponse { kvs })
    }

@@ -467,12 +441,7 @@ impl KvQueryExecutor<MySqlClient> for MySqlStore {
        let template = self.sql_template_set.delete_template.get(template_type);
        let params = template_type.build_params(req.key, req.range_end);
        let params_ref = params.iter().map(|x| x as _).collect::<Vec<_>>();
-        crate::record_rds_sql_execute_elapsed!(
-            query_executor.execute(template, &params_ref).await,
-            MYSQL_STORE_NAME,
-            RDS_STORE_OP_RANGE_DELETE,
-            template_type.as_ref()
-        )?;
+        query_executor.execute(template, &params_ref).await?;
        let mut resp = DeleteRangeResponse::new(prev_kvs.len() as i64);
        if req.prev_kv {
            resp.with_prev_kvs(prev_kvs);
@@ -494,12 +463,7 @@ impl KvQueryExecutor<MySqlClient> for MySqlStore {
        let params = req.keys.iter().map(|x| x as _).collect::<Vec<_>>();
        // Fast path: if we don't need previous kvs, we can just delete the keys.
        if !req.prev_kv {
-            crate::record_rds_sql_execute_elapsed!(
-                query_executor.execute(&query, &params).await,
-                MYSQL_STORE_NAME,
-                RDS_STORE_OP_BATCH_DELETE,
-                ""
-            )?;
+            query_executor.execute(&query, &params).await?;
            return Ok(BatchDeleteResponse::default());
        }
        // Should use transaction to ensure atomicity.
@@ -519,12 +483,7 @@ impl KvQueryExecutor<MySqlClient> for MySqlStore {
            .await?
            .kvs;
        // Pure `DELETE` has no return value, so we need to use `execute` instead of `query`.
-        crate::record_rds_sql_execute_elapsed!(
-            query_executor.execute(&query, &params).await,
-            MYSQL_STORE_NAME,
-            RDS_STORE_OP_BATCH_DELETE,
-            ""
-        )?;
+        query_executor.execute(&query, &params).await?;
        if req.prev_kv {
            Ok(BatchDeleteResponse { prev_kvs })
        } else {
@@ -579,11 +538,10 @@ mod tests {
        prepare_kv_with_prefix, test_kv_batch_delete_with_prefix, test_kv_batch_get_with_prefix,
        test_kv_compare_and_put_with_prefix, test_kv_delete_range_with_prefix,
        test_kv_put_with_prefix, test_kv_range_2_with_prefix, test_kv_range_with_prefix,
-        test_simple_kv_range, test_txn_compare_equal, test_txn_compare_greater,
-        test_txn_compare_less, test_txn_compare_not_equal, test_txn_one_compare_op,
-        text_txn_multi_compare_op, unprepare_kv,
+        test_txn_compare_equal, test_txn_compare_greater, test_txn_compare_less,
+        test_txn_compare_not_equal, test_txn_one_compare_op, text_txn_multi_compare_op,
+        unprepare_kv,
    };
-    use crate::maybe_skip_mysql_integration_test;

    async fn build_mysql_kv_backend(table_name: &str) -> Option<MySqlStore> {
        init_default_ut_logging();
@@ -610,7 +568,6 @@ mod tests {

    #[tokio::test]
    async fn test_mysql_put() {
-        maybe_skip_mysql_integration_test!();
        let kv_backend = build_mysql_kv_backend("put_test").await.unwrap();
        let prefix = b"put/";
        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
@@ -620,7 +577,6 @@ mod tests {

    #[tokio::test]
    async fn test_mysql_range() {
-        maybe_skip_mysql_integration_test!();
        let kv_backend = build_mysql_kv_backend("range_test").await.unwrap();
        let prefix = b"range/";
        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
@@ -630,26 +586,14 @@ mod tests {

    #[tokio::test]
    async fn test_mysql_range_2() {
-        maybe_skip_mysql_integration_test!();
        let kv_backend = build_mysql_kv_backend("range2_test").await.unwrap();
        let prefix = b"range2/";
        test_kv_range_2_with_prefix(&kv_backend, prefix.to_vec()).await;
        unprepare_kv(&kv_backend, prefix).await;
    }

-    #[tokio::test]
-    async fn test_mysql_all_range() {
-        maybe_skip_mysql_integration_test!();
-        let kv_backend = build_mysql_kv_backend("simple_range_test").await.unwrap();
-        let prefix = b"";
-        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
-        test_simple_kv_range(&kv_backend).await;
-        unprepare_kv(&kv_backend, prefix).await;
-    }
-
    #[tokio::test]
    async fn test_mysql_batch_get() {
-        maybe_skip_mysql_integration_test!();
        let kv_backend = build_mysql_kv_backend("batch_get_test").await.unwrap();
        let prefix = b"batch_get/";
        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
@@ -659,7 +603,6 @@ mod tests {

    #[tokio::test]
    async fn test_mysql_batch_delete() {
-        maybe_skip_mysql_integration_test!();
        let kv_backend = build_mysql_kv_backend("batch_delete_test").await.unwrap();
        let prefix = b"batch_delete/";
        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
@@ -669,7 +612,6 @@ mod tests {

    #[tokio::test]
    async fn test_mysql_batch_delete_with_prefix() {
-        maybe_skip_mysql_integration_test!();
        let kv_backend = build_mysql_kv_backend("batch_delete_with_prefix_test")
            .await
            .unwrap();
@@ -681,7 +623,6 @@ mod tests {

    #[tokio::test]
    async fn test_mysql_delete_range() {
-        maybe_skip_mysql_integration_test!();
        let kv_backend = build_mysql_kv_backend("delete_range_test").await.unwrap();
        let prefix = b"delete_range/";
        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
@@ -691,7 +632,6 @@ mod tests {

    #[tokio::test]
    async fn test_mysql_compare_and_put() {
-        maybe_skip_mysql_integration_test!();
        let kv_backend = build_mysql_kv_backend("compare_and_put_test")
            .await
            .unwrap();
@@ -702,7 +642,6 @@ mod tests {

    #[tokio::test]
    async fn test_mysql_txn() {
-        maybe_skip_mysql_integration_test!();
        let kv_backend = build_mysql_kv_backend("txn_test").await.unwrap();
        test_txn_one_compare_op(&kv_backend).await;
        text_txn_multi_compare_op(&kv_backend).await;
--- a/src/common/meta/src/kv_backend/rds/postgres.rs
+++ b/src/common/meta/src/kv_backend/rds/postgres.rs
@@ -18,7 +18,6 @@ use std::sync::Arc;
 use common_telemetry::debug;
 use deadpool_postgres::{Config, Pool, Runtime};
 use snafu::ResultExt;
-use strum::AsRefStr;
 use tokio_postgres::types::ToSql;
 use tokio_postgres::{IsolationLevel, NoTls, Row};

@@ -28,8 +27,7 @@ use crate::error::{
 };
 use crate::kv_backend::rds::{
    Executor, ExecutorFactory, ExecutorImpl, KvQueryExecutor, RdsStore, Transaction,
-    RDS_STORE_OP_BATCH_DELETE, RDS_STORE_OP_BATCH_GET, RDS_STORE_OP_BATCH_PUT,
-    RDS_STORE_OP_RANGE_DELETE, RDS_STORE_OP_RANGE_QUERY, RDS_STORE_TXN_RETRY_COUNT,
+    RDS_STORE_TXN_RETRY_COUNT,
 };
 use crate::kv_backend::KvBackendRef;
 use crate::rpc::store::{
@@ -38,8 +36,6 @@ use crate::rpc::store::{
 };
 use crate::rpc::KeyValue;

-const PG_STORE_NAME: &str = "pg_store";
-
 pub struct PgClient(deadpool::managed::Object<deadpool_postgres::Manager>);
 pub struct PgTxnClient<'a>(deadpool_postgres::Transaction<'a>);

@@ -54,7 +50,7 @@ fn key_value_from_row(r: Row) -> KeyValue {
 const EMPTY: &[u8] = &[0];

 /// Type of range template.
-#[derive(Debug, Clone, Copy, AsRefStr)]
+#[derive(Debug, Clone, Copy)]
 enum RangeTemplateType {
    Point,
    Range,
@@ -65,8 +61,6 @@ enum RangeTemplateType {

 /// Builds params for the given range template type.
 impl RangeTemplateType {
-    /// Builds the parameters for the given range template type.
-    /// You can check out the conventions at [RangeRequest]
    fn build_params(&self, mut key: Vec<u8>, range_end: Vec<u8>) -> Vec<Vec<u8>> {
        match self {
            RangeTemplateType::Point => vec![key],
@@ -170,7 +164,7 @@ impl<'a> PgSqlTemplateFactory<'a> {
                range: format!(
                    "SELECT k, v FROM \"{table_name}\" WHERE k >= $1 AND k < $2 ORDER BY k"
                ),
-                full: format!("SELECT k, v FROM \"{table_name}\" ORDER BY k"),
+                full: format!("SELECT k, v FROM \"{table_name}\" $1 ORDER BY k"),
                left_bounded: format!("SELECT k, v FROM \"{table_name}\" WHERE k >= $1 ORDER BY k"),
                prefix: format!("SELECT k, v FROM \"{table_name}\" WHERE k LIKE $1 ORDER BY k"),
            },
@@ -364,13 +358,7 @@ impl KvQueryExecutor<PgClient> for PgStore {
            RangeTemplate::with_limit(template, if req.limit == 0 { 0 } else { req.limit + 1 });
        let limit = req.limit as usize;
        debug!("query: {:?}, params: {:?}", query, params);
-        let mut kvs = crate::record_rds_sql_execute_elapsed!(
-            query_executor.query(&query, &params_ref).await,
-            PG_STORE_NAME,
-            RDS_STORE_OP_RANGE_QUERY,
-            template_type.as_ref()
-        )?;
-
+        let mut kvs = query_executor.query(&query, &params_ref).await?;
        if req.keys_only {
            kvs.iter_mut().for_each(|kv| kv.value = vec![]);
        }
@@ -405,13 +393,7 @@ impl KvQueryExecutor<PgClient> for PgStore {
        let query = self
            .sql_template_set
            .generate_batch_upsert_query(req.kvs.len());
-
-        let kvs = crate::record_rds_sql_execute_elapsed!(
-            query_executor.query(&query, &params).await,
-            PG_STORE_NAME,
-            RDS_STORE_OP_BATCH_PUT,
-            ""
-        )?;
+        let kvs = query_executor.query(&query, &params).await?;
        if req.prev_kv {
            Ok(BatchPutResponse { prev_kvs: kvs })
        } else {
@@ -432,12 +414,7 @@ impl KvQueryExecutor<PgClient> for PgStore {
            .sql_template_set
            .generate_batch_get_query(req.keys.len());
        let params = req.keys.iter().map(|x| x as _).collect::<Vec<_>>();
-        let kvs = crate::record_rds_sql_execute_elapsed!(
-            query_executor.query(&query, &params).await,
-            PG_STORE_NAME,
-            RDS_STORE_OP_BATCH_GET,
-            ""
-        )?;
+        let kvs = query_executor.query(&query, &params).await?;
        Ok(BatchGetResponse { kvs })
    }

@@ -450,12 +427,7 @@ impl KvQueryExecutor<PgClient> for PgStore {
        let template = self.sql_template_set.delete_template.get(template_type);
        let params = template_type.build_params(req.key, req.range_end);
        let params_ref = params.iter().map(|x| x as _).collect::<Vec<_>>();
-        let kvs = crate::record_rds_sql_execute_elapsed!(
-            query_executor.query(template, &params_ref).await,
-            PG_STORE_NAME,
-            RDS_STORE_OP_RANGE_DELETE,
-            template_type.as_ref()
-        )?;
+        let kvs = query_executor.query(template, &params_ref).await?;
        let mut resp = DeleteRangeResponse::new(kvs.len() as i64);
        if req.prev_kv {
            resp.with_prev_kvs(kvs);
@@ -475,13 +447,7 @@ impl KvQueryExecutor<PgClient> for PgStore {
            .sql_template_set
            .generate_batch_delete_query(req.keys.len());
        let params = req.keys.iter().map(|x| x as _).collect::<Vec<_>>();
-
-        let kvs = crate::record_rds_sql_execute_elapsed!(
-            query_executor.query(&query, &params).await,
-            PG_STORE_NAME,
-            RDS_STORE_OP_BATCH_DELETE,
-            ""
-        )?;
+        let kvs = query_executor.query(&query, &params).await?;
        if req.prev_kv {
            Ok(BatchDeleteResponse { prev_kvs: kvs })
        } else {
@@ -545,11 +511,10 @@ mod tests {
        prepare_kv_with_prefix, test_kv_batch_delete_with_prefix, test_kv_batch_get_with_prefix,
        test_kv_compare_and_put_with_prefix, test_kv_delete_range_with_prefix,
        test_kv_put_with_prefix, test_kv_range_2_with_prefix, test_kv_range_with_prefix,
-        test_simple_kv_range, test_txn_compare_equal, test_txn_compare_greater,
-        test_txn_compare_less, test_txn_compare_not_equal, test_txn_one_compare_op,
-        text_txn_multi_compare_op, unprepare_kv,
+        test_txn_compare_equal, test_txn_compare_greater, test_txn_compare_less,
+        test_txn_compare_not_equal, test_txn_one_compare_op, text_txn_multi_compare_op,
+        unprepare_kv,
    };
-    use crate::maybe_skip_postgres_integration_test;

    async fn build_pg_kv_backend(table_name: &str) -> Option<PgStore> {
        let endpoints = std::env::var("GT_POSTGRES_ENDPOINTS").unwrap_or_default();
@@ -584,7 +549,6 @@ mod tests {

    #[tokio::test]
    async fn test_pg_put() {
-        maybe_skip_postgres_integration_test!();
        let kv_backend = build_pg_kv_backend("put_test").await.unwrap();
        let prefix = b"put/";
        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
@@ -594,7 +558,6 @@ mod tests {

    #[tokio::test]
    async fn test_pg_range() {
-        maybe_skip_postgres_integration_test!();
        let kv_backend = build_pg_kv_backend("range_test").await.unwrap();
        let prefix = b"range/";
        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
@@ -604,26 +567,14 @@ mod tests {

    #[tokio::test]
    async fn test_pg_range_2() {
-        maybe_skip_postgres_integration_test!();
        let kv_backend = build_pg_kv_backend("range2_test").await.unwrap();
        let prefix = b"range2/";
        test_kv_range_2_with_prefix(&kv_backend, prefix.to_vec()).await;
        unprepare_kv(&kv_backend, prefix).await;
    }

-    #[tokio::test]
-    async fn test_pg_all_range() {
-        maybe_skip_postgres_integration_test!();
-        let kv_backend = build_pg_kv_backend("simple_range_test").await.unwrap();
-        let prefix = b"";
-        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
-        test_simple_kv_range(&kv_backend).await;
-        unprepare_kv(&kv_backend, prefix).await;
-    }
-
    #[tokio::test]
    async fn test_pg_batch_get() {
-        maybe_skip_postgres_integration_test!();
        let kv_backend = build_pg_kv_backend("batch_get_test").await.unwrap();
        let prefix = b"batch_get/";
        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
@@ -633,7 +584,6 @@ mod tests {

    #[tokio::test]
    async fn test_pg_batch_delete() {
-        maybe_skip_postgres_integration_test!();
        let kv_backend = build_pg_kv_backend("batch_delete_test").await.unwrap();
        let prefix = b"batch_delete/";
        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
@@ -643,7 +593,6 @@ mod tests {

    #[tokio::test]
    async fn test_pg_batch_delete_with_prefix() {
-        maybe_skip_postgres_integration_test!();
        let kv_backend = build_pg_kv_backend("batch_delete_with_prefix_test")
            .await
            .unwrap();
@@ -655,7 +604,6 @@ mod tests {

    #[tokio::test]
    async fn test_pg_delete_range() {
-        maybe_skip_postgres_integration_test!();
        let kv_backend = build_pg_kv_backend("delete_range_test").await.unwrap();
        let prefix = b"delete_range/";
        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
@@ -665,7 +613,6 @@ mod tests {

    #[tokio::test]
    async fn test_pg_compare_and_put() {
-        maybe_skip_postgres_integration_test!();
        let kv_backend = build_pg_kv_backend("compare_and_put_test").await.unwrap();
        let prefix = b"compare_and_put/";
        let kv_backend = Arc::new(kv_backend);
@@ -674,7 +621,6 @@ mod tests {

    #[tokio::test]
    async fn test_pg_txn() {
-        maybe_skip_postgres_integration_test!();
        let kv_backend = build_pg_kv_backend("txn_test").await.unwrap();
        test_txn_one_compare_op(&kv_backend).await;
        text_txn_multi_compare_op(&kv_backend).await;
--- a/src/common/meta/src/kv_backend/test.rs
+++ b/src/common/meta/src/kv_backend/test.rs
@@ -108,44 +108,6 @@ pub async fn test_kv_range(kv_backend: &impl KvBackend) {
    test_kv_range_with_prefix(kv_backend, vec![]).await;
 }

-pub async fn test_simple_kv_range(kvbackend: &impl KvBackend) {
-    {
-        let full_query = RangeRequest::new().with_range(vec![0], vec![0]);
-        let response = kvbackend.range(full_query).await.unwrap();
-        assert_eq!(response.kvs.len(), 4);
-    }
-    {
-        let point_query = RangeRequest::new().with_range(b"key11".to_vec(), vec![]);
-        let response = kvbackend.range(point_query).await.unwrap();
-        assert_eq!(response.kvs.len(), 1);
-    }
-    {
-        let left_bounded_query = RangeRequest::new().with_range(b"key1".to_vec(), vec![0]);
-        let response = kvbackend.range(left_bounded_query).await.unwrap();
-        assert_eq!(response.kvs.len(), 4);
-    }
-    {
-        let range_query = RangeRequest::new().with_range(b"key1".to_vec(), b"key11".to_vec());
-        let response = kvbackend.range(range_query).await.unwrap();
-        assert_eq!(response.kvs.len(), 1);
-    }
-    {
-        let prefix_query = RangeRequest::new().with_range(b"key1".to_vec(), b"key2".to_vec());
-        let response = kvbackend.range(prefix_query).await.unwrap();
-        assert_eq!(response.kvs.len(), 2);
-    }
-    {
-        let range_query = RangeRequest::new().with_range(b"key10".to_vec(), b"key100".to_vec());
-        let response = kvbackend.range(range_query).await.unwrap();
-        assert_eq!(response.kvs.len(), 0);
-    }
-    {
-        let prefix_query = RangeRequest::new().with_range(b"key10".to_vec(), b"key11".to_vec());
-        let response = kvbackend.range(prefix_query).await.unwrap();
-        assert_eq!(response.kvs.len(), 0);
-    }
-}
-
 pub async fn test_kv_range_with_prefix(kv_backend: &impl KvBackend, prefix: Vec<u8>) {
    let key = [prefix.clone(), b"key1".to_vec()].concat();
    let key11 = [prefix.clone(), b"key11".to_vec()].concat();
--- a/src/common/meta/src/lib.rs
+++ b/src/common/meta/src/lib.rs
@@ -15,7 +15,6 @@
 #![feature(assert_matches)]
 #![feature(btree_extract_if)]
 #![feature(let_chains)]
-#![feature(duration_millis_float)]

 pub mod cache;
 pub mod cache_invalidator;
@@ -42,7 +41,6 @@ pub mod region_keeper;
 pub mod region_registry;
 pub mod rpc;
 pub mod sequence;
-pub mod snapshot;
 pub mod state_store;
 #[cfg(any(test, feature = "testing"))]
 pub mod test_util;
--- a/src/common/meta/src/metrics.rs
+++ b/src/common/meta/src/metrics.rs
@@ -108,10 +108,4 @@ lazy_static! {
        &["name"]
    )
    .unwrap();
-    pub static ref RDS_SQL_EXECUTE_ELAPSED: HistogramVec = register_histogram_vec!(
-        "greptime_meta_rds_pg_sql_execute_elapsed_ms",
-        "rds pg sql execute elapsed",
-        &["backend", "result", "op", "type"]
-    )
-    .unwrap();
 }
--- a/src/common/meta/src/snapshot.rs
+++ b/src/common/meta/src/snapshot.rs
@@ -1,380 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-pub mod file;
-
-use std::fmt::{Display, Formatter};
-use std::path::{Path, PathBuf};
-use std::time::Instant;
-
-use common_telemetry::info;
-use file::{Metadata, MetadataContent};
-use futures::TryStreamExt;
-use object_store::ObjectStore;
-use snafu::{OptionExt, ResultExt};
-use strum::Display;
-
-use crate::error::{
-    Error, InvalidFileExtensionSnafu, InvalidFileNameSnafu, InvalidFilePathSnafu, ReadObjectSnafu,
-    Result, WriteObjectSnafu,
-};
-use crate::kv_backend::KvBackendRef;
-use crate::range_stream::{PaginationStream, DEFAULT_PAGE_SIZE};
-use crate::rpc::store::{BatchPutRequest, RangeRequest};
-use crate::rpc::KeyValue;
-use crate::snapshot::file::{Document, KeyValue as FileKeyValue};
-
-/// The format of the backup file.
-#[derive(Debug, PartialEq, Eq, Display, Clone, Copy)]
-pub enum FileFormat {
-    #[strum(serialize = "fb")]
-    FlexBuffers,
-}
-
-impl TryFrom<&str> for FileFormat {
-    type Error = String;
-
-    fn try_from(value: &str) -> std::result::Result<Self, Self::Error> {
-        match value.to_lowercase().as_str() {
-            "fb" => Ok(FileFormat::FlexBuffers),
-            _ => Err(format!("Invalid file format: {}", value)),
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, Display)]
-#[strum(serialize_all = "lowercase")]
-pub enum DataType {
-    Metadata,
-}
-
-impl TryFrom<&str> for DataType {
-    type Error = String;
-
-    fn try_from(value: &str) -> std::result::Result<Self, Self::Error> {
-        match value.to_lowercase().as_str() {
-            "metadata" => Ok(DataType::Metadata),
-            _ => Err(format!("Invalid data type: {}", value)),
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct FileExtension {
-    format: FileFormat,
-    data_type: DataType,
-}
-
-impl FileExtension {
-    pub fn new(format: FileFormat, data_type: DataType) -> Self {
-        Self { format, data_type }
-    }
-}
-
-impl Display for FileExtension {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}.{}", self.data_type, self.format)
-    }
-}
-
-impl TryFrom<&str> for FileExtension {
-    type Error = Error;
-
-    fn try_from(value: &str) -> Result<Self> {
-        let parts = value.split(".").collect::<Vec<&str>>();
-        if parts.len() != 2 {
-            return InvalidFileExtensionSnafu {
-                reason: format!(
-                    "Extension should be in the format of <datatype>.<format>, got: {}",
-                    value
-                ),
-            }
-            .fail();
-        }
-
-        let data_type = DataType::try_from(parts[0])
-            .map_err(|e| InvalidFileExtensionSnafu { reason: e }.build())?;
-        let format = FileFormat::try_from(parts[1])
-            .map_err(|e| InvalidFileExtensionSnafu { reason: e }.build())?;
-        Ok(FileExtension { format, data_type })
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct FileName {
-    name: String,
-    extension: FileExtension,
-}
-
-impl Display for FileName {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}.{}", self.name, self.extension)
-    }
-}
-
-impl TryFrom<&str> for FileName {
-    type Error = Error;
-
-    fn try_from(value: &str) -> Result<Self> {
-        let Some((name, extension)) = value.split_once(".") else {
-            return InvalidFileNameSnafu {
-                reason: format!(
-                    "The file name should be in the format of <name>.<extension>, got: {}",
-                    value
-                ),
-            }
-            .fail();
-        };
-        let extension = FileExtension::try_from(extension)?;
-        Ok(Self {
-            name: name.to_string(),
-            extension,
-        })
-    }
-}
-
-impl FileName {
-    fn new(name: String, extension: FileExtension) -> Self {
-        Self { name, extension }
-    }
-}
-
-/// The manager of the metadata snapshot.
-///
-/// It manages the metadata snapshot, including dumping and restoring.
-pub struct MetadataSnapshotManager {
-    kv_backend: KvBackendRef,
-    object_store: ObjectStore,
-}
-
-/// The maximum size of the request to put metadata, use 1MiB by default.
-const MAX_REQUEST_SIZE: usize = 1024 * 1024;
-
-impl MetadataSnapshotManager {
-    pub fn new(kv_backend: KvBackendRef, object_store: ObjectStore) -> Self {
-        Self {
-            kv_backend,
-            object_store,
-        }
-    }
-
-    /// Restores the metadata from the backup file to the metadata store.
-    pub async fn restore(&self, file_path: &str) -> Result<u64> {
-        let path = Path::new(file_path);
-
-        let file_name = path
-            .file_name()
-            .and_then(|s| s.to_str())
-            .context(InvalidFilePathSnafu { file_path })?;
-
-        let filename = FileName::try_from(file_name)?;
-        let data = self
-            .object_store
-            .read(file_path)
-            .await
-            .context(ReadObjectSnafu { file_path })?;
-        let document = Document::from_slice(&filename.extension.format, &data.to_bytes())?;
-        let metadata_content = document.into_metadata_content()?;
-        let mut req = BatchPutRequest::default();
-        let mut total_request_size = 0;
-        let mut count = 0;
-        let now = Instant::now();
-        for FileKeyValue { key, value } in metadata_content.into_iter() {
-            count += 1;
-            let key_size = key.len();
-            let value_size = value.len();
-            if total_request_size + key_size + value_size > MAX_REQUEST_SIZE {
-                self.kv_backend.batch_put(req).await?;
-                req = BatchPutRequest::default();
-                total_request_size = 0;
-            }
-            req.kvs.push(KeyValue { key, value });
-            total_request_size += key_size + value_size;
-        }
-        if !req.kvs.is_empty() {
-            self.kv_backend.batch_put(req).await?;
-        }
-
-        info!(
-            "Restored metadata from {} successfully, total {} key-value pairs, elapsed {:?}",
-            file_path,
-            count,
-            now.elapsed()
-        );
-        Ok(count)
-    }
-
-    pub async fn check_target_source_clean(&self) -> Result<bool> {
-        let req = RangeRequest::new().with_range(vec![0], vec![0]);
-        let mut stream = Box::pin(
-            PaginationStream::new(self.kv_backend.clone(), req, 1, Result::Ok).into_stream(),
-        );
-        let v = stream.as_mut().try_next().await?;
-        Ok(v.is_none())
-    }
-
-    /// Dumps the metadata to the backup file.
-    pub async fn dump(&self, path: &str, filename_str: &str) -> Result<(String, u64)> {
-        let format = FileFormat::FlexBuffers;
-        let filename = FileName::new(
-            filename_str.to_string(),
-            FileExtension {
-                format,
-                data_type: DataType::Metadata,
-            },
-        );
-        let file_path_buf = [path, filename.to_string().as_str()]
-            .iter()
-            .collect::<PathBuf>();
-        let file_path = file_path_buf.to_str().context(InvalidFileNameSnafu {
-            reason: format!("Invalid file path: {}, filename: {}", path, filename_str),
-        })?;
-        let now = Instant::now();
-        let req = RangeRequest::new().with_range(vec![0], vec![0]);
-        let stream = PaginationStream::new(self.kv_backend.clone(), req, DEFAULT_PAGE_SIZE, |kv| {
-            Ok(FileKeyValue {
-                key: kv.key,
-                value: kv.value,
-            })
-        })
-        .into_stream();
-        let keyvalues = stream.try_collect::<Vec<_>>().await?;
-        let num_keyvalues = keyvalues.len();
-        let document = Document::new(
-            Metadata::new(),
-            file::Content::Metadata(MetadataContent::new(keyvalues)),
-        );
-        let bytes = document.to_bytes(&format)?;
-        let r = self
-            .object_store
-            .write(file_path, bytes)
-            .await
-            .context(WriteObjectSnafu { file_path })?;
-        info!(
-            "Dumped metadata to {} successfully, total {} key-value pairs, file size {} bytes, elapsed {:?}",
-            file_path,
-            num_keyvalues,
-            r.content_length(),
-            now.elapsed()
-        );
-
-        Ok((filename.to_string(), num_keyvalues as u64))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::assert_matches::assert_matches;
-    use std::sync::Arc;
-
-    use common_test_util::temp_dir::{create_temp_dir, TempDir};
-    use object_store::services::Fs;
-
-    use super::*;
-    use crate::kv_backend::memory::MemoryKvBackend;
-    use crate::kv_backend::KvBackend;
-    use crate::rpc::store::PutRequest;
-
-    #[test]
-    fn test_file_name() {
-        let file_name = FileName::try_from("test.metadata.fb").unwrap();
-        assert_eq!(file_name.name, "test");
-        assert_eq!(file_name.extension.format, FileFormat::FlexBuffers);
-        assert_eq!(file_name.extension.data_type, DataType::Metadata);
-        assert_eq!(file_name.to_string(), "test.metadata.fb");
-
-        let invalid_file_name = FileName::try_from("test.metadata").unwrap_err();
-        assert_eq!(
-            invalid_file_name.to_string(),
-            "Invalid file extension: Extension should be in the format of <datatype>.<format>, got: metadata"
-        );
-
-        let invalid_file_extension = FileName::try_from("test.metadata.hello").unwrap_err();
-        assert_eq!(
-            invalid_file_extension.to_string(),
-            "Invalid file extension: Invalid file format: hello"
-        );
-    }
-
-    fn test_env(
-        prefix: &str,
-    ) -> (
-        TempDir,
-        Arc<MemoryKvBackend<Error>>,
-        MetadataSnapshotManager,
-    ) {
-        let temp_dir = create_temp_dir(prefix);
-        let kv_backend = Arc::new(MemoryKvBackend::default());
-        let temp_path = temp_dir.path();
-        let data_path = temp_path.join("data").as_path().display().to_string();
-        let builder = Fs::default().root(&data_path);
-        let object_store = ObjectStore::new(builder).unwrap().finish();
-        let manager = MetadataSnapshotManager::new(kv_backend.clone(), object_store);
-        (temp_dir, kv_backend, manager)
-    }
-
-    #[tokio::test]
-    async fn test_dump_and_restore() {
-        common_telemetry::init_default_ut_logging();
-        let (temp_dir, kv_backend, manager) = test_env("test_dump_and_restore");
-        let temp_path = temp_dir.path();
-
-        for i in 0..10 {
-            kv_backend
-                .put(
-                    PutRequest::new()
-                        .with_key(format!("test_{}", i).as_bytes().to_vec())
-                        .with_value(format!("value_{}", i).as_bytes().to_vec()),
-                )
-                .await
-                .unwrap();
-        }
-        let dump_path = temp_path.join("snapshot");
-        manager
-            .dump(
-                &dump_path.as_path().display().to_string(),
-                "metadata_snapshot",
-            )
-            .await
-            .unwrap();
-        // Clean up the kv backend
-        kv_backend.clear();
-
-        let restore_path = dump_path
-            .join("metadata_snapshot.metadata.fb")
-            .as_path()
-            .display()
-            .to_string();
-        manager.restore(&restore_path).await.unwrap();
-
-        for i in 0..10 {
-            let key = format!("test_{}", i);
-            let value = kv_backend.get(key.as_bytes()).await.unwrap().unwrap();
-            assert_eq!(value.value, format!("value_{}", i).as_bytes());
-        }
-    }
-
-    #[tokio::test]
-    async fn test_restore_from_nonexistent_file() {
-        let (temp_dir, _kv_backend, manager) = test_env("test_restore_from_nonexistent_file");
-        let restore_path = temp_dir
-            .path()
-            .join("nonexistent.metadata.fb")
-            .as_path()
-            .display()
-            .to_string();
-        let err = manager.restore(&restore_path).await.unwrap_err();
-        assert_matches!(err, Error::ReadObject { .. })
-    }
-}
--- a/src/common/meta/src/snapshot/file.rs
+++ b/src/common/meta/src/snapshot/file.rs
@@ -1,145 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use common_time::util::current_time_millis;
-use flexbuffers::{FlexbufferSerializer, Reader};
-use serde::{Deserialize, Serialize};
-use snafu::ResultExt;
-
-use crate::error::{
-    DeserializeFlexbuffersSnafu, ReadFlexbuffersSnafu, Result, SerializeFlexbuffersSnafu,
-};
-use crate::snapshot::FileFormat;
-
-/// The layout of the backup file.
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-pub(crate) struct Document {
-    metadata: Metadata,
-    content: Content,
-}
-
-impl Document {
-    /// Creates a new document.
-    pub fn new(metadata: Metadata, content: Content) -> Self {
-        Self { metadata, content }
-    }
-
-    fn serialize_to_flexbuffer(&self) -> Result<Vec<u8>> {
-        let mut builder = FlexbufferSerializer::new();
-        self.serialize(&mut builder)
-            .context(SerializeFlexbuffersSnafu)?;
-        Ok(builder.take_buffer())
-    }
-
-    /// Converts the [`Document`] to a bytes.
-    pub(crate) fn to_bytes(&self, format: &FileFormat) -> Result<Vec<u8>> {
-        match format {
-            FileFormat::FlexBuffers => self.serialize_to_flexbuffer(),
-        }
-    }
-
-    fn deserialize_from_flexbuffer(data: &[u8]) -> Result<Self> {
-        let reader = Reader::get_root(data).context(ReadFlexbuffersSnafu)?;
-        Document::deserialize(reader).context(DeserializeFlexbuffersSnafu)
-    }
-
-    /// Deserializes the [`Document`] from a bytes.
-    pub(crate) fn from_slice(format: &FileFormat, data: &[u8]) -> Result<Self> {
-        match format {
-            FileFormat::FlexBuffers => Self::deserialize_from_flexbuffer(data),
-        }
-    }
-
-    /// Converts the [`Document`] to a [`MetadataContent`].
-    pub(crate) fn into_metadata_content(self) -> Result<MetadataContent> {
-        match self.content {
-            Content::Metadata(metadata) => Ok(metadata),
-        }
-    }
-}
-
-/// The metadata of the backup file.
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-pub(crate) struct Metadata {
-    // UNIX_EPOCH in milliseconds.
-    created_timestamp_mills: i64,
-}
-
-impl Metadata {
-    /// Create a new metadata.
-    ///
-    /// The `created_timestamp_mills` will be the current time in milliseconds.
-    pub fn new() -> Self {
-        Self {
-            created_timestamp_mills: current_time_millis(),
-        }
-    }
-}
-
-/// The content of the backup file.
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-pub(crate) enum Content {
-    Metadata(MetadataContent),
-}
-
-/// The content of the backup file.
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-pub(crate) struct MetadataContent {
-    values: Vec<KeyValue>,
-}
-
-impl MetadataContent {
-    /// Create a new metadata content.
-    pub fn new(values: impl IntoIterator<Item = KeyValue>) -> Self {
-        Self {
-            values: values.into_iter().collect(),
-        }
-    }
-
-    /// Returns an iterator over the key-value pairs.
-    pub fn into_iter(self) -> impl Iterator<Item = KeyValue> {
-        self.values.into_iter()
-    }
-}
-
-/// The key-value pair of the backup file.
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-pub(crate) struct KeyValue {
-    pub key: Vec<u8>,
-    pub value: Vec<u8>,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_document() {
-        let document = Document::new(
-            Metadata::new(),
-            Content::Metadata(MetadataContent::new(vec![KeyValue {
-                key: b"key".to_vec(),
-                value: b"value".to_vec(),
-            }])),
-        );
-
-        let bytes = document.to_bytes(&FileFormat::FlexBuffers).unwrap();
-        let document_deserialized = Document::from_slice(&FileFormat::FlexBuffers, &bytes).unwrap();
-        assert_eq!(
-            document.metadata.created_timestamp_mills,
-            document_deserialized.metadata.created_timestamp_mills
-        );
-        assert_eq!(document.content, document_deserialized.content);
-    }
-}
--- a/src/common/meta/src/test_util.rs
+++ b/src/common/meta/src/test_util.rs
@@ -233,35 +233,3 @@ pub async fn test_kafka_topic_pool(

    KafkaTopicPool::new(&config, kv_backend, topic_creator)
 }
-
-#[macro_export]
-/// Skip the test if the environment variable `GT_KAFKA_ENDPOINTS` is not set.
-///
-/// The format of the environment variable is:
-/// ```
-/// GT_KAFKA_ENDPOINTS=localhost:9092,localhost:9093
-/// ```
-macro_rules! maybe_skip_postgres_integration_test {
-    () => {
-        if std::env::var("GT_POSTGRES_ENDPOINTS").is_err() {
-            common_telemetry::warn!("The endpoints is empty, skipping the test");
-            return;
-        }
-    };
-}
-
-#[macro_export]
-/// Skip the test if the environment variable `GT_KAFKA_ENDPOINTS` is not set.
-///
-/// The format of the environment variable is:
-/// ```
-/// GT_KAFKA_ENDPOINTS=localhost:9092,localhost:9093
-/// ```
-macro_rules! maybe_skip_mysql_integration_test {
-    () => {
-        if std::env::var("GT_MYSQL_ENDPOINTS").is_err() {
-            common_telemetry::warn!("The endpoints is empty, skipping the test");
-            return;
-        }
-    };
-}
--- a/src/common/procedure/src/error.rs
+++ b/src/common/procedure/src/error.rs
@@ -138,10 +138,7 @@ pub enum Error {
    },

    #[snafu(display("Procedure exec failed"))]
-    RetryLater {
-        source: BoxedError,
-        clean_poisons: bool,
-    },
+    RetryLater { source: BoxedError },

    #[snafu(display("Procedure panics, procedure_id: {}", procedure_id))]
    ProcedurePanic { procedure_id: ProcedureId },
@@ -301,15 +298,6 @@ impl Error {
    pub fn retry_later<E: ErrorExt + Send + Sync + 'static>(err: E) -> Error {
        Error::RetryLater {
            source: BoxedError::new(err),
-            clean_poisons: false,
-        }
-    }
-
-    /// Creates a new [Error::RetryLater] error from source `err` and clean poisons.
-    pub fn retry_later_and_clean_poisons<E: ErrorExt + Send + Sync + 'static>(err: E) -> Error {
-        Error::RetryLater {
-            source: BoxedError::new(err),
-            clean_poisons: true,
        }
    }

@@ -321,7 +309,6 @@ impl Error {
    /// Determine whether it needs to clean poisons.
    pub fn need_clean_poisons(&self) -> bool {
        matches!(self, Error::External { clean_poisons, .. } if *clean_poisons)
-            || matches!(self, Error::RetryLater { clean_poisons, .. } if *clean_poisons)
    }

    /// Creates a new [Error::RetryLater] or [Error::External] error from source `err` according
--- a/src/common/procedure/src/local/runner.rs
+++ b/src/common/procedure/src/local/runner.rs
@@ -358,11 +358,10 @@ impl Runner {
                    Err(e) => {
                        error!(
                            e;
-                            "Failed to execute procedure {}-{}, retry: {}, clean_poisons: {}",
+                            "Failed to execute procedure {}-{}, retry: {}",
                            self.procedure.type_name(),
                            self.meta.id,
                            e.is_retry_later(),
-                            e.need_clean_poisons(),
                        );

                        // Don't store state if `ProcedureManager` is stopped.
@@ -379,11 +378,6 @@ impl Runner {
                                self.meta.set_state(ProcedureState::retrying(Arc::new(e)));
                                return;
                            }
-                            debug!(
-                                "Procedure {}-{} cleaned poisons",
-                                self.procedure.type_name(),
-                                self.meta.id,
-                            );
                        }

                        if e.is_retry_later() {
@@ -587,7 +581,6 @@ impl Runner {

 #[cfg(test)]
 mod tests {
-    use std::assert_matches::assert_matches;
    use std::sync::atomic::{AtomicU64, Ordering};
    use std::sync::Arc;

@@ -1605,75 +1598,6 @@ mod tests {
        assert_eq!(&procedure_id.to_string(), ROOT_ID);
    }

-    #[tokio::test]
-    async fn test_execute_exceed_max_retry_after_set_poison() {
-        common_telemetry::init_default_ut_logging();
-        let mut times = 0;
-        let poison_key = PoisonKey::new("table/1024");
-        let moved_poison_key = poison_key.clone();
-        let exec_fn = move |ctx: Context| {
-            times += 1;
-            let poison_key = moved_poison_key.clone();
-            async move {
-                if times == 1 {
-                    Ok(Status::executing(true))
-                } else {
-                    // Put the poison to the context.
-                    ctx.provider
-                        .try_put_poison(&poison_key, ctx.procedure_id)
-                        .await
-                        .unwrap();
-                    Err(Error::retry_later_and_clean_poisons(MockError::new(
-                        StatusCode::Unexpected,
-                    )))
-                }
-            }
-            .boxed()
-        };
-        let poison = ProcedureAdapter {
-            data: "poison".to_string(),
-            lock_key: LockKey::single_exclusive("catalog.schema.table"),
-            poison_keys: PoisonKeys::new(vec![poison_key.clone()]),
-            exec_fn,
-            rollback_fn: None,
-        };
-
-        let dir = create_temp_dir("exceed_max_after_set_poison");
-        let meta = poison.new_meta(ROOT_ID);
-        let object_store = test_util::new_object_store(&dir);
-        let procedure_store = Arc::new(ProcedureStore::from_object_store(object_store.clone()));
-        let mut runner = new_runner(meta.clone(), Box::new(poison), procedure_store);
-        runner.manager_ctx.start();
-        runner.exponential_builder = ExponentialBuilder::default()
-            .with_min_delay(Duration::from_millis(1))
-            .with_max_times(3);
-        // Use the manager ctx as the context provider.
-        let ctx = context_with_provider(
-            meta.id,
-            runner.manager_ctx.clone() as Arc<dyn ContextProvider>,
-        );
-        // Manually add this procedure to the manager ctx.
-        runner
-            .manager_ctx
-            .procedures
-            .write()
-            .unwrap()
-            .insert(meta.id, runner.meta.clone());
-        // Run the runner and execute the procedure.
-        runner.execute_once_with_retry(&ctx).await;
-        let err = meta.state().error().unwrap().clone();
-        assert_matches!(&*err, Error::RetryTimesExceeded { .. });
-
-        // Check the poison is deleted.
-        let procedure_id = runner
-            .manager_ctx
-            .poison_manager
-            .get_poison(&poison_key.to_string())
-            .await
-            .unwrap();
-        assert_eq!(procedure_id, None);
-    }
-
    #[tokio::test]
    async fn test_execute_poisoned() {
        let mut times = 0;
--- a/src/common/query/src/error.rs
+++ b/src/common/query/src/error.rs
@@ -103,6 +103,13 @@ pub enum Error {
        source: common_recordbatch::error::Error,
    },

+    #[snafu(display("Failed to convert arrow schema"))]
+    ConvertArrowSchema {
+        #[snafu(implicit)]
+        location: Location,
+        source: DataTypeError,
+    },
+
    #[snafu(display("Failed to cast array to {:?}", typ))]
    TypeCast {
        #[snafu(source)]
@@ -237,6 +244,7 @@ impl ErrorExt for Error {
            Error::InvalidInputType { source, .. }
            | Error::IntoVector { source, .. }
            | Error::FromScalarValue { source, .. }
+            | Error::ConvertArrowSchema { source, .. }
            | Error::FromArrowArray { source, .. }
            | Error::InvalidVectorString { source, .. } => source.status_code(),

--- a/src/common/test-util/Cargo.toml
+++ b/src/common/test-util/Cargo.toml
@@ -9,7 +9,6 @@ workspace = true

 [dependencies]
 client = { workspace = true, features = ["testing"] }
-common-grpc.workspace = true
 common-query.workspace = true
 common-recordbatch.workspace = true
 once_cell.workspace = true
--- a/src/common/test-util/src/flight.rs
+++ b/src/common/test-util/src/flight.rs
@@ -1,26 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use common_grpc::flight::{FlightEncoder, FlightMessage};
-use common_grpc::FlightData;
-use common_recordbatch::DfRecordBatch;
-
-/// Encodes record batch to a Schema message and a RecordBatch message.
-pub fn encode_to_flight_data(rb: DfRecordBatch) -> (FlightData, FlightData) {
-    let mut encoder = FlightEncoder::default();
-    (
-        encoder.encode(FlightMessage::Schema(rb.schema())),
-        encoder.encode(FlightMessage::RecordBatch(rb)),
-    )
-}
--- a/src/common/test-util/src/lib.rs
+++ b/src/common/test-util/src/lib.rs
@@ -16,7 +16,6 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::sync::LazyLock;

-pub mod flight;
 pub mod ports;
 pub mod recordbatch;
 pub mod temp_dir;
--- a/src/flow/Cargo.toml
+++ b/src/flow/Cargo.toml
@@ -65,7 +65,6 @@ servers.workspace = true
 session.workspace = true
 smallvec.workspace = true
 snafu.workspace = true
-sql.workspace = true
 store-api.workspace = true
 strum.workspace = true
 substrait.workspace = true
--- a/src/flow/src/adapter/flownode_impl.rs
+++ b/src/flow/src/adapter/flownode_impl.rs
@@ -359,7 +359,7 @@ impl FlowDualEngine {
                }
            } else {
                warn!(
-                    "Flows do not exist in flownode for node {:?}, flow_ids={:?}",
+                    "Flownode {:?} found flows not exist in flownode, flow_ids={:?}",
                    nodeid, to_be_created
                );
            }
@@ -379,7 +379,7 @@ impl FlowDualEngine {
                }
            } else {
                warn!(
-                    "Flows do not exist in metadata for node {:?}, flow_ids={:?}",
+                    "Flownode {:?} found flows not exist in flownode, flow_ids={:?}",
                    nodeid, to_be_dropped
                );
            }
@@ -826,17 +826,9 @@ fn to_meta_err(
    location: snafu::Location,
 ) -> impl FnOnce(crate::error::Error) -> common_meta::error::Error {
    move |err: crate::error::Error| -> common_meta::error::Error {
-        match err {
-            crate::error::Error::FlowNotFound { id, .. } => {
-                common_meta::error::Error::FlowNotFound {
-                    flow_name: format!("flow_id={id}"),
-                    location,
-                }
-            }
-            _ => common_meta::error::Error::External {
-                location,
-                source: BoxedError::new(err),
-            },
+        common_meta::error::Error::External {
+            location,
+            source: BoxedError::new(err),
        }
    }
 }
--- a/src/flow/src/batching_mode/engine.rs
+++ b/src/flow/src/batching_mode/engine.rs
@@ -39,8 +39,7 @@ use crate::batching_mode::time_window::{find_time_window_expr, TimeWindowExpr};
 use crate::batching_mode::utils::sql_to_df_plan;
 use crate::engine::FlowEngine;
 use crate::error::{
-    ExternalSnafu, FlowAlreadyExistSnafu, FlowNotFoundSnafu, TableNotFoundMetaSnafu,
-    UnexpectedSnafu, UnsupportedSnafu,
+    ExternalSnafu, FlowAlreadyExistSnafu, TableNotFoundMetaSnafu, UnexpectedSnafu, UnsupportedSnafu,
 };
 use crate::{CreateFlowArgs, Error, FlowId, TableName};

@@ -313,7 +312,7 @@ impl BatchingEngine {
                .unwrap_or("None".to_string())
        );

-        let task = BatchingTask::try_new(
+        let task = BatchingTask::new(
            flow_id,
            &sql,
            plan,
@@ -324,7 +323,7 @@ impl BatchingEngine {
            query_ctx,
            self.catalog_manager.clone(),
            rx,
-        )?;
+        );

        let task_inner = task.clone();
        let engine = self.query_engine.clone();
@@ -350,8 +349,7 @@ impl BatchingEngine {

    pub async fn remove_flow_inner(&self, flow_id: FlowId) -> Result<(), Error> {
        if self.tasks.write().await.remove(&flow_id).is_none() {
-            warn!("Flow {flow_id} not found in tasks");
-            FlowNotFoundSnafu { id: flow_id }.fail()?;
+            warn!("Flow {flow_id} not found in tasks")
        }
        let Some(tx) = self.shutdown_txs.write().await.remove(&flow_id) else {
            UnexpectedSnafu {
@@ -368,7 +366,9 @@ impl BatchingEngine {
    pub async fn flush_flow_inner(&self, flow_id: FlowId) -> Result<usize, Error> {
        debug!("Try flush flow {flow_id}");
        let task = self.tasks.read().await.get(&flow_id).cloned();
-        let task = task.with_context(|| FlowNotFoundSnafu { id: flow_id })?;
+        let task = task.with_context(|| UnexpectedSnafu {
+            reason: format!("Can't found task for flow {flow_id}"),
+        })?;

        task.mark_all_windows_as_dirty()?;

--- a/src/flow/src/batching_mode/state.rs
+++ b/src/flow/src/batching_mode/state.rs
@@ -71,33 +71,18 @@ impl TaskState {
        self.last_update_time = Instant::now();
    }

-    /// Compute the next query delay based on the time window size or the last query duration.
-    /// Aiming to avoid too frequent queries. But also not too long delay.
-    /// The delay is computed as follows:
-    /// - If `time_window_size` is set, the delay is half the time window size, constrained to be
-    ///   at least `last_query_duration` and at most `max_timeout`.
-    /// - If `time_window_size` is not set, the delay defaults to `last_query_duration`, constrained
-    ///   to be at least `MIN_REFRESH_DURATION` and at most `max_timeout`.
+    /// wait for at least `last_query_duration`, at most `max_timeout` to start next query
    ///
-    /// If there are dirty time windows, the function returns an immediate execution time to clean them.
-    /// TODO: Make this behavior configurable.
+    /// if have more dirty time window, exec next query immediately
    pub fn get_next_start_query_time(
        &self,
        flow_id: FlowId,
-        time_window_size: &Option<Duration>,
        max_timeout: Option<Duration>,
    ) -> Instant {
-        let last_duration = max_timeout
+        let next_duration = max_timeout
            .unwrap_or(self.last_query_duration)
-            .min(self.last_query_duration)
-            .max(MIN_REFRESH_DURATION);
-
-        let next_duration = time_window_size
-            .map(|t| {
-                let half = t / 2;
-                half.max(last_duration)
-            })
-            .unwrap_or(last_duration);
+            .min(self.last_query_duration);
+        let next_duration = next_duration.max(MIN_REFRESH_DURATION);

        // if have dirty time window, execute immediately to clean dirty time window
        if self.dirty_time_windows.windows.is_empty() {
--- a/src/flow/src/batching_mode/task.rs
+++ b/src/flow/src/batching_mode/task.rs
@@ -13,6 +13,7 @@
 // limitations under the License.

 use std::collections::{BTreeSet, HashSet};
+use std::ops::Deref;
 use std::sync::{Arc, RwLock};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};

@@ -28,7 +29,6 @@ use datafusion::optimizer::analyzer::count_wildcard_rule::CountWildcardRule;
 use datafusion::optimizer::AnalyzerRule;
 use datafusion::sql::unparser::expr_to_sql;
 use datafusion_common::tree_node::{Transformed, TreeNode};
-use datafusion_common::DFSchemaRef;
 use datafusion_expr::{DmlStatement, LogicalPlan, WriteOp};
 use datatypes::prelude::ConcreteDataType;
 use datatypes::schema::{ColumnSchema, Schema};
@@ -37,8 +37,6 @@ use query::query_engine::DefaultSerializer;
 use query::QueryEngineRef;
 use session::context::QueryContextRef;
 use snafu::{ensure, OptionExt, ResultExt};
-use sql::parser::{ParseOptions, ParserContext};
-use sql::statements::statement::Statement;
 use substrait::{DFLogicalSubstraitConvertor, SubstraitPlan};
 use tokio::sync::oneshot;
 use tokio::sync::oneshot::error::TryRecvError;
@@ -70,42 +68,13 @@ use crate::{Error, FlowId};
 pub struct TaskConfig {
    pub flow_id: FlowId,
    pub query: String,
-    /// output schema of the query
-    pub output_schema: DFSchemaRef,
+    plan: Arc<LogicalPlan>,
    pub time_window_expr: Option<TimeWindowExpr>,
    /// in seconds
    pub expire_after: Option<i64>,
    sink_table_name: [String; 3],
    pub source_table_names: HashSet<[String; 3]>,
    catalog_manager: CatalogManagerRef,
-    query_type: QueryType,
-}
-
-fn determine_query_type(query: &str, query_ctx: &QueryContextRef) -> Result<QueryType, Error> {
-    let stmts =
-        ParserContext::create_with_dialect(query, query_ctx.sql_dialect(), ParseOptions::default())
-            .map_err(BoxedError::new)
-            .context(ExternalSnafu)?;
-
-    ensure!(
-        stmts.len() == 1,
-        InvalidQuerySnafu {
-            reason: format!("Expect only one statement, found {}", stmts.len())
-        }
-    );
-    let stmt = &stmts[0];
-    match stmt {
-        Statement::Tql(_) => Ok(QueryType::Tql),
-        _ => Ok(QueryType::Sql),
-    }
-}
-
-#[derive(Debug, Clone)]
-enum QueryType {
-    /// query is a tql query
-    Tql,
-    /// query is a sql query
-    Sql,
 }

 #[derive(Clone)]
@@ -116,7 +85,7 @@ pub struct BatchingTask {

 impl BatchingTask {
    #[allow(clippy::too_many_arguments)]
-    pub fn try_new(
+    pub fn new(
        flow_id: FlowId,
        query: &str,
        plan: LogicalPlan,
@@ -127,21 +96,20 @@ impl BatchingTask {
        query_ctx: QueryContextRef,
        catalog_manager: CatalogManagerRef,
        shutdown_rx: oneshot::Receiver<()>,
-    ) -> Result<Self, Error> {
-        Ok(Self {
+    ) -> Self {
+        Self {
            config: Arc::new(TaskConfig {
                flow_id,
                query: query.to_string(),
+                plan: Arc::new(plan),
                time_window_expr,
                expire_after,
                sink_table_name,
                source_table_names: source_table_names.into_iter().collect(),
                catalog_manager,
-                output_schema: plan.schema().clone(),
-                query_type: determine_query_type(query, &query_ctx)?,
            }),
            state: Arc::new(RwLock::new(TaskState::new(query_ctx, shutdown_rx))),
-        })
+        }
    }

    /// mark time window range (now - expire_after, now) as dirty (or (0, now) if expire_after not set)
@@ -412,23 +380,6 @@ impl BatchingTask {
        frontend_client: Arc<FrontendClient>,
    ) {
        loop {
-            // first check if shutdown signal is received
-            // if so, break the loop
-            {
-                let mut state = self.state.write().unwrap();
-                match state.shutdown_rx.try_recv() {
-                    Ok(()) => break,
-                    Err(TryRecvError::Closed) => {
-                        warn!(
-                            "Unexpected shutdown flow {}, shutdown anyway",
-                            self.config.flow_id
-                        );
-                        break;
-                    }
-                    Err(TryRecvError::Empty) => (),
-                }
-            }
-
            let mut new_query = None;
            let mut gen_and_exec = async || {
                new_query = self.gen_insert_plan(&engine).await?;
@@ -442,15 +393,20 @@ impl BatchingTask {
                // normal execute, sleep for some time before doing next query
                Ok(Some(_)) => {
                    let sleep_until = {
-                        let state = self.state.write().unwrap();
-
+                        let mut state = self.state.write().unwrap();
+                        match state.shutdown_rx.try_recv() {
+                            Ok(()) => break,
+                            Err(TryRecvError::Closed) => {
+                                warn!(
+                                    "Unexpected shutdown flow {}, shutdown anyway",
+                                    self.config.flow_id
+                                );
+                                break;
+                            }
+                            Err(TryRecvError::Empty) => (),
+                        }
                        state.get_next_start_query_time(
                            self.config.flow_id,
-                            &self
-                                .config
-                                .time_window_expr
-                                .as_ref()
-                                .and_then(|t| *t.time_window_size()),
                            Some(DEFAULT_BATCHING_ENGINE_QUERY_TIMEOUT),
                        )
                    };
@@ -516,7 +472,7 @@ impl BatchingTask {
            .unwrap_or(u64::MIN);

        let low_bound = Timestamp::new_second(low_bound as i64);
-        let schema_len = self.config.output_schema.fields().len();
+        let schema_len = self.config.plan.schema().fields().len();

        let expire_time_window_bound = self
            .config
@@ -525,101 +481,104 @@ impl BatchingTask {
            .map(|expr| expr.eval(low_bound))
            .transpose()?;

-        let (Some((Some(l), Some(u))), QueryType::Sql) =
-            (expire_time_window_bound, &self.config.query_type)
-        else {
-            // either no time window or not a sql query, then just use the original query
-            // use sink_table_meta to add to query the `update_at` and `__ts_placeholder` column's value too for compatibility reason
-            debug!(
-                "Flow id = {:?}, can't get window size: precise_lower_bound={expire_time_window_bound:?}, using the same query", self.config.flow_id
-            );
-            // clean dirty time window too, this could be from create flow's check_execute
-            self.state.write().unwrap().dirty_time_windows.clean();
+        let new_plan = {
+            let expr = {
+                match expire_time_window_bound {
+                    Some((Some(l), Some(u))) => {
+                        let window_size = u.sub(&l).with_context(|| UnexpectedSnafu {
+                            reason: format!("Can't get window size from {u:?} - {l:?}"),
+                        })?;
+                        let col_name = self
+                            .config
+                            .time_window_expr
+                            .as_ref()
+                            .map(|expr| expr.column_name.clone())
+                            .with_context(|| UnexpectedSnafu {
+                                reason: format!(
+                                    "Flow id={:?}, Failed to get column name from time window expr",
+                                    self.config.flow_id
+                                ),
+                            })?;

-            // TODO(discord9): not add auto column for tql query?
+                        self.state
+                            .write()
+                            .unwrap()
+                            .dirty_time_windows
+                            .gen_filter_exprs(
+                                &col_name,
+                                Some(l),
+                                window_size,
+                                self.config.flow_id,
+                                Some(self),
+                            )?
+                    }
+                    _ => {
+                        // use sink_table_meta to add to query the `update_at` and `__ts_placeholder` column's value too for compatibility reason
+                        debug!(
+                            "Flow id = {:?}, can't get window size: precise_lower_bound={expire_time_window_bound:?}, using the same query", self.config.flow_id
+                        );
+                        // clean dirty time window too, this could be from create flow's check_execute
+                        self.state.write().unwrap().dirty_time_windows.clean();
+
+                        let mut add_auto_column =
+                            AddAutoColumnRewriter::new(sink_table_schema.clone());
+                        let plan = self
+                            .config
+                            .plan
+                            .deref()
+                            .clone()
+                            .rewrite(&mut add_auto_column)
+                            .with_context(|_| DatafusionSnafu {
+                                context: format!(
+                                    "Failed to rewrite plan:\n {}\n",
+                                    self.config.plan
+                                ),
+                            })?
+                            .data;
+                        let schema_len = plan.schema().fields().len();
+
+                        // since no time window lower/upper bound is found, just return the original query(with auto columns)
+                        return Ok(Some((plan, schema_len)));
+                    }
+                }
+            };
+
+            debug!(
+                "Flow id={:?}, Generated filter expr: {:?}",
+                self.config.flow_id,
+                expr.as_ref()
+                    .map(|expr| expr_to_sql(expr).with_context(|_| DatafusionSnafu {
+                        context: format!("Failed to generate filter expr from {expr:?}"),
+                    }))
+                    .transpose()?
+                    .map(|s| s.to_string())
+            );
+
+            let Some(expr) = expr else {
+                // no new data, hence no need to update
+                debug!("Flow id={:?}, no new data, not update", self.config.flow_id);
+                return Ok(None);
+            };
+
+            // TODO(discord9): add auto column or not? This might break compatibility for auto created sink table before this, but that's ok right?
+
+            let mut add_filter = AddFilterRewriter::new(expr);
            let mut add_auto_column = AddAutoColumnRewriter::new(sink_table_schema.clone());

            let plan = sql_to_df_plan(query_ctx.clone(), engine.clone(), &self.config.query, false)
                .await?;
-
-            let plan = plan
+            let rewrite = plan
                .clone()
-                .rewrite(&mut add_auto_column)
+                .rewrite(&mut add_filter)
+                .and_then(|p| p.data.rewrite(&mut add_auto_column))
                .with_context(|_| DatafusionSnafu {
                    context: format!("Failed to rewrite plan:\n {}\n", plan),
                })?
                .data;
-            let schema_len = plan.schema().fields().len();
-
-            // since no time window lower/upper bound is found, just return the original query(with auto columns)
-            return Ok(Some((plan, schema_len)));
+            // only apply optimize after complex rewrite is done
+            apply_df_optimizer(rewrite).await?
        };

-        debug!(
-            "Flow id = {:?}, found time window: precise_lower_bound={:?}, precise_upper_bound={:?}",
-            self.config.flow_id, l, u
-        );
-        let window_size = u.sub(&l).with_context(|| UnexpectedSnafu {
-            reason: format!("Can't get window size from {u:?} - {l:?}"),
-        })?;
-        let col_name = self
-            .config
-            .time_window_expr
-            .as_ref()
-            .map(|expr| expr.column_name.clone())
-            .with_context(|| UnexpectedSnafu {
-                reason: format!(
-                    "Flow id={:?}, Failed to get column name from time window expr",
-                    self.config.flow_id
-                ),
-            })?;
-
-        let expr = self
-            .state
-            .write()
-            .unwrap()
-            .dirty_time_windows
-            .gen_filter_exprs(
-                &col_name,
-                Some(l),
-                window_size,
-                self.config.flow_id,
-                Some(self),
-            )?;
-
-        debug!(
-            "Flow id={:?}, Generated filter expr: {:?}",
-            self.config.flow_id,
-            expr.as_ref()
-                .map(|expr| expr_to_sql(expr).with_context(|_| DatafusionSnafu {
-                    context: format!("Failed to generate filter expr from {expr:?}"),
-                }))
-                .transpose()?
-                .map(|s| s.to_string())
-        );
-
-        let Some(expr) = expr else {
-            // no new data, hence no need to update
-            debug!("Flow id={:?}, no new data, not update", self.config.flow_id);
-            return Ok(None);
-        };
-
-        let mut add_filter = AddFilterRewriter::new(expr);
-        let mut add_auto_column = AddAutoColumnRewriter::new(sink_table_schema.clone());
-
-        let plan =
-            sql_to_df_plan(query_ctx.clone(), engine.clone(), &self.config.query, false).await?;
-        let rewrite = plan
-            .clone()
-            .rewrite(&mut add_filter)
-            .and_then(|p| p.data.rewrite(&mut add_auto_column))
-            .with_context(|_| DatafusionSnafu {
-                context: format!("Failed to rewrite plan:\n {}\n", plan),
-            })?
-            .data;
-        // only apply optimize after complex rewrite is done
-        let new_plan = apply_df_optimizer(rewrite).await?;
-
        Ok(Some((new_plan, schema_len)))
    }
 }
--- a/src/flow/src/batching_mode/time_window.rs
+++ b/src/flow/src/batching_mode/time_window.rs
@@ -55,9 +55,6 @@ use crate::error::{
 use crate::expr::error::DataTypeSnafu;
 use crate::Error;

-/// Represents a test timestamp in seconds since the Unix epoch.
-const DEFAULT_TEST_TIMESTAMP: Timestamp = Timestamp::new_second(17_0000_0000);
-
 /// Time window expr like `date_bin(INTERVAL '1' MINUTE, ts)`, this type help with
 /// evaluating the expr using given timestamp
 ///
@@ -73,7 +70,6 @@ pub struct TimeWindowExpr {
    pub column_name: String,
    logical_expr: Expr,
    df_schema: DFSchema,
-    eval_time_window_size: Option<std::time::Duration>,
 }

 impl std::fmt::Display for TimeWindowExpr {
@@ -88,11 +84,6 @@ impl std::fmt::Display for TimeWindowExpr {
 }

 impl TimeWindowExpr {
-    /// The time window size of the expr, get from calling `eval` with a test timestamp
-    pub fn time_window_size(&self) -> &Option<std::time::Duration> {
-        &self.eval_time_window_size
-    }
-
    pub fn from_expr(
        expr: &Expr,
        column_name: &str,
@@ -100,28 +91,12 @@ impl TimeWindowExpr {
        session: &SessionState,
    ) -> Result<Self, Error> {
        let phy_expr: PhysicalExprRef = to_phy_expr(expr, df_schema, session)?;
-        let mut zelf = Self {
+        Ok(Self {
            phy_expr,
            column_name: column_name.to_string(),
            logical_expr: expr.clone(),
            df_schema: df_schema.clone(),
-            eval_time_window_size: None,
-        };
-        let test_ts = DEFAULT_TEST_TIMESTAMP;
-        let (l, u) = zelf.eval(test_ts)?;
-        let time_window_size = match (l, u) {
-            (Some(l), Some(u)) => u.sub(&l).map(|r| r.to_std()).transpose().map_err(|_| {
-                UnexpectedSnafu {
-                    reason: format!(
-                        "Expect upper bound older than lower bound, found upper={u:?} and lower={l:?}"
-                    ),
-                }
-                .build()
-            })?,
-            _ => None,
-        };
-        zelf.eval_time_window_size = time_window_size;
-        Ok(zelf)
+        })
    }

    pub fn eval(
--- a/src/flow/src/batching_mode/utils.rs
+++ b/src/flow/src/batching_mode/utils.rs
@@ -29,18 +29,15 @@ use datafusion_common::tree_node::{
 use datafusion_common::{DFSchema, DataFusionError, ScalarValue};
 use datafusion_expr::{Distinct, LogicalPlan, Projection};
 use datatypes::schema::SchemaRef;
-use query::parser::{PromQuery, QueryLanguageParser, QueryStatement, DEFAULT_LOOKBACK_STRING};
+use query::parser::QueryLanguageParser;
 use query::QueryEngineRef;
 use session::context::QueryContextRef;
-use snafu::{ensure, OptionExt, ResultExt};
-use sql::parser::{ParseOptions, ParserContext};
-use sql::statements::statement::Statement;
-use sql::statements::tql::Tql;
+use snafu::{OptionExt, ResultExt};
 use table::metadata::TableInfo;

 use crate::adapter::AUTO_CREATED_PLACEHOLDER_TS_COL;
 use crate::df_optimizer::apply_df_optimizer;
-use crate::error::{DatafusionSnafu, ExternalSnafu, InvalidQuerySnafu, TableNotFoundSnafu};
+use crate::error::{DatafusionSnafu, ExternalSnafu, TableNotFoundSnafu};
 use crate::{Error, TableName};

 pub async fn get_table_info_df_schema(
@@ -76,57 +73,21 @@ pub async fn get_table_info_df_schema(
 }

 /// Convert sql to datafusion logical plan
-/// Also support TQL (but only Eval not Explain or Analyze)
 pub async fn sql_to_df_plan(
    query_ctx: QueryContextRef,
    engine: QueryEngineRef,
    sql: &str,
    optimize: bool,
 ) -> Result<LogicalPlan, Error> {
-    let stmts =
-        ParserContext::create_with_dialect(sql, query_ctx.sql_dialect(), ParseOptions::default())
-            .map_err(BoxedError::new)
-            .context(ExternalSnafu)?;
-
-    ensure!(
-        stmts.len() == 1,
-        InvalidQuerySnafu {
-            reason: format!("Expect only one statement, found {}", stmts.len())
-        }
-    );
-    let stmt = &stmts[0];
-    let query_stmt = match stmt {
-        Statement::Tql(tql) => match tql {
-            Tql::Eval(eval) => {
-                let eval = eval.clone();
-                let promql = PromQuery {
-                    start: eval.start,
-                    end: eval.end,
-                    step: eval.step,
-                    query: eval.query,
-                    lookback: eval
-                        .lookback
-                        .unwrap_or_else(|| DEFAULT_LOOKBACK_STRING.to_string()),
-                };
-
-                QueryLanguageParser::parse_promql(&promql, &query_ctx)
-                    .map_err(BoxedError::new)
-                    .context(ExternalSnafu)?
-            }
-            _ => InvalidQuerySnafu {
-                reason: format!("TQL statement {tql:?} is not supported, expect only TQL EVAL"),
-            }
-            .fail()?,
-        },
-        _ => QueryStatement::Sql(stmt.clone()),
-    };
+    let stmt = QueryLanguageParser::parse_sql(sql, &query_ctx)
+        .map_err(BoxedError::new)
+        .context(ExternalSnafu)?;
    let plan = engine
        .planner()
-        .plan(&query_stmt, query_ctx)
+        .plan(&stmt, query_ctx)
        .await
        .map_err(BoxedError::new)
        .context(ExternalSnafu)?;
-
    let plan = if optimize {
        apply_df_optimizer(plan).await?
    } else {
--- a/src/flow/src/error.rs
+++ b/src/flow/src/error.rs
@@ -321,8 +321,8 @@ impl ErrorExt for Error {
            Self::FlowAlreadyExist { .. } => StatusCode::TableAlreadyExists,
            Self::TableNotFound { .. }
            | Self::TableNotFoundMeta { .. }
+            | Self::FlowNotFound { .. }
            | Self::ListFlows { .. } => StatusCode::TableNotFound,
-            Self::FlowNotFound { .. } => StatusCode::FlowNotFound,
            Self::Plan { .. } | Self::Datatypes { .. } => StatusCode::PlanQuery,
            Self::CreateFlow { .. } | Self::Arrow { .. } | Self::Time { .. } => {
                StatusCode::EngineExecuteQuery
--- a/src/frontend/Cargo.toml
+++ b/src/frontend/Cargo.toml
@@ -6,7 +6,6 @@ license.workspace = true

 [features]
 testing = []
-enterprise = ["operator/enterprise", "sql/enterprise"]

 [lints]
 workspace = true
--- a/src/frontend/src/instance.rs
+++ b/src/frontend/src/instance.rs
@@ -495,10 +495,6 @@ pub fn check_permission(
            // TODO: should also validate source table name here?
            validate_param(&stmt.sink_table_name, query_ctx)?;
        }
-        #[cfg(feature = "enterprise")]
-        Statement::CreateTrigger(stmt) => {
-            validate_param(&stmt.trigger_name, query_ctx)?;
-        }
        Statement::CreateView(stmt) => {
            validate_param(&stmt.name, query_ctx)?;
        }
@@ -550,11 +546,6 @@ pub fn check_permission(
        Statement::ShowFlows(stmt) => {
            validate_db_permission!(stmt, query_ctx);
        }
-        #[cfg(feature = "enterprise")]
-        Statement::ShowTriggers(_stmt) => {
-            // The trigger is organized based on the catalog dimension, so there
-            // is no need to check the permission of the database(schema).
-        }
        Statement::ShowStatus(_stmt) => {}
        Statement::ShowSearchPath(_stmt) => {}
        Statement::DescribeTable(stmt) => {
--- a/src/frontend/src/server.rs
+++ b/src/frontend/src/server.rs
@@ -104,7 +104,7 @@ where
                    self.instance.clone(),
                    Some(self.instance.clone()),
                    opts.prom_store.with_metric_engine,
-                    opts.http.prom_validation_mode,
+                    opts.http.is_strict_mode,
                )
                .with_prometheus_handler(self.instance.clone());
        }
--- a/src/log-store/src/kafka/log_store.rs
+++ b/src/log-store/src/kafka/log_store.rs
@@ -98,7 +98,7 @@ impl KafkaLogStore {
 }

 fn build_entry(
-    data: Vec<u8>,
+    data: &mut Vec<u8>,
    entry_id: EntryId,
    region_id: RegionId,
    provider: &Provider,
@@ -109,10 +109,10 @@ fn build_entry(
            provider: provider.clone(),
            region_id,
            entry_id,
-            data,
+            data: std::mem::take(data),
        })
    } else {
-        let parts = data
+        let parts = std::mem::take(data)
            .chunks(max_data_size)
            .map(|s| s.into())
            .collect::<Vec<_>>();
@@ -140,7 +140,7 @@ impl LogStore for KafkaLogStore {
    /// Creates an [Entry].
    fn entry(
        &self,
-        data: Vec<u8>,
+        data: &mut Vec<u8>,
        entry_id: EntryId,
        region_id: RegionId,
        provider: &Provider,
@@ -479,7 +479,7 @@ mod tests {
    fn test_build_naive_entry() {
        let provider = Provider::kafka_provider("my_topic".to_string());
        let region_id = RegionId::new(1, 1);
-        let entry = build_entry(vec![1; 100], 1, region_id, &provider, 120);
+        let entry = build_entry(&mut vec![1; 100], 1, region_id, &provider, 120);

        assert_eq!(
            entry.into_naive_entry().unwrap(),
@@ -496,7 +496,7 @@ mod tests {
    fn test_build_into_multiple_part_entry() {
        let provider = Provider::kafka_provider("my_topic".to_string());
        let region_id = RegionId::new(1, 1);
-        let entry = build_entry(vec![1; 100], 1, region_id, &provider, 50);
+        let entry = build_entry(&mut vec![1; 100], 1, region_id, &provider, 50);

        assert_eq!(
            entry.into_multiple_part_entry().unwrap(),
@@ -510,7 +510,7 @@ mod tests {
        );

        let region_id = RegionId::new(1, 1);
-        let entry = build_entry(vec![1; 100], 1, region_id, &provider, 21);
+        let entry = build_entry(&mut vec![1; 100], 1, region_id, &provider, 21);

        assert_eq!(
            entry.into_multiple_part_entry().unwrap(),
@@ -545,9 +545,9 @@ mod tests {
    ) -> Vec<Entry> {
        (0..num_entries)
            .map(|_| {
-                let data: Vec<u8> = (0..data_len).map(|_| rand::random::<u8>()).collect();
+                let mut data: Vec<u8> = (0..data_len).map(|_| rand::random::<u8>()).collect();
                // Always set `entry_id` to 0, the real entry_id will be set during the read.
-                logstore.entry(data, 0, region_id, provider).unwrap()
+                logstore.entry(&mut data, 0, region_id, provider).unwrap()
            })
            .collect()
    }
--- a/src/log-store/src/raft_engine/log_store.rs
+++ b/src/log-store/src/raft_engine/log_store.rs
@@ -442,7 +442,7 @@ impl LogStore for RaftEngineLogStore {

    fn entry(
        &self,
-        data: Vec<u8>,
+        data: &mut Vec<u8>,
        entry_id: EntryId,
        region_id: RegionId,
        provider: &Provider,
@@ -455,7 +455,7 @@ impl LogStore for RaftEngineLogStore {
            provider: provider.clone(),
            region_id,
            entry_id,
-            data,
+            data: std::mem::take(data),
        }))
    }

--- a/src/meta-srv/src/bootstrap.rs
+++ b/src/meta-srv/src/bootstrap.rs
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-use std::net::SocketAddr;
 use std::sync::Arc;

 use api::v1::meta::cluster_server::ClusterServer;
@@ -37,6 +36,7 @@ use common_telemetry::info;
 #[cfg(feature = "pg_kvbackend")]
 use deadpool_postgres::{Config, Runtime};
 use etcd_client::Client;
+use futures::future;
 use servers::configurator::ConfiguratorRef;
 use servers::export_metrics::ExportMetricsTask;
 use servers::http::{HttpServer, HttpServerBuilder};
@@ -53,7 +53,6 @@ use sqlx::mysql::{MySqlConnection, MySqlPool};
 use sqlx::Connection;
 use tokio::net::TcpListener;
 use tokio::sync::mpsc::{self, Receiver, Sender};
-use tokio::sync::{oneshot, Mutex};
 #[cfg(feature = "pg_kvbackend")]
 use tokio_postgres::NoTls;
 use tonic::codec::CompressionEncoding;
@@ -89,12 +88,6 @@ pub struct MetasrvInstance {
    plugins: Plugins,

    export_metrics_task: Option<ExportMetricsTask>,
-
-    /// gRPC serving state receiver. Only present if the gRPC server is started.
-    serve_state: Arc<Mutex<Option<oneshot::Receiver<Result<()>>>>>,
-
-    /// gRPC bind addr
-    bind_addr: Option<SocketAddr>,
 }

 impl MetasrvInstance {
@@ -120,8 +113,6 @@ impl MetasrvInstance {
            signal_sender: None,
            plugins,
            export_metrics_task,
-            serve_state: Default::default(),
-            bind_addr: None,
        })
    }

@@ -141,30 +132,21 @@ impl MetasrvInstance {
            router = configurator.config_grpc(router);
        }

-        let (serve_state_tx, serve_state_rx) = oneshot::channel();
-
-        let socket_addr =
-            bootstrap_metasrv_with_router(&self.opts.bind_addr, router, serve_state_tx, rx).await?;
-        self.bind_addr = Some(socket_addr);
-
+        let metasrv = bootstrap_metasrv_with_router(&self.opts.bind_addr, router, rx);
        let addr = self.opts.http.addr.parse().context(error::ParseAddrSnafu {
            addr: &self.opts.http.addr,
        })?;
-        self.http_server
-            .start(addr)
-            .await
-            .context(error::StartHttpSnafu)?;
-
-        *self.serve_state.lock().await = Some(serve_state_rx);
+        let http_srv = async {
+            self.http_server
+                .start(addr)
+                .await
+                .context(error::StartHttpSnafu)
+        };
+        future::try_join(metasrv, http_srv).await?;
        Ok(())
    }

    pub async fn shutdown(&self) -> Result<()> {
-        if let Some(mut rx) = self.serve_state.lock().await.take() {
-            if let Ok(Err(err)) = rx.try_recv() {
-                common_telemetry::error!(err; "Metasrv start failed")
-            }
-        }
        if let Some(signal) = &self.signal_sender {
            signal
                .send(())
@@ -188,42 +170,30 @@ impl MetasrvInstance {
    pub fn get_inner(&self) -> &Metasrv {
        &self.metasrv
    }
-    pub fn bind_addr(&self) -> &Option<SocketAddr> {
-        &self.bind_addr
-    }
 }

 pub async fn bootstrap_metasrv_with_router(
    bind_addr: &str,
    router: Router,
-    serve_state_tx: oneshot::Sender<Result<()>>,
-    mut shutdown_rx: Receiver<()>,
-) -> Result<SocketAddr> {
+    mut signal: Receiver<()>,
+) -> Result<()> {
    let listener = TcpListener::bind(bind_addr)
        .await
        .context(error::TcpBindSnafu { addr: bind_addr })?;

-    let real_bind_addr = listener
-        .local_addr()
-        .context(error::TcpBindSnafu { addr: bind_addr })?;
-
-    info!("gRPC server is bound to: {}", real_bind_addr);
+    info!("gRPC server is bound to: {bind_addr}");

    let incoming =
        TcpIncoming::from_listener(listener, true, None).context(error::TcpIncomingSnafu)?;

-    let _handle = common_runtime::spawn_global(async move {
-        let result = router
-            .serve_with_incoming_shutdown(incoming, async {
-                let _ = shutdown_rx.recv().await;
-            })
-            .await
-            .inspect_err(|err| common_telemetry::error!(err;"Failed to start metasrv"))
-            .context(error::StartGrpcSnafu);
-        let _ = serve_state_tx.send(result);
-    });
+    router
+        .serve_with_incoming_shutdown(incoming, async {
+            let _ = signal.recv().await;
+        })
+        .await
+        .context(error::StartGrpcSnafu)?;

-    Ok(real_bind_addr)
+    Ok(())
 }

 #[macro_export]
@@ -257,7 +227,7 @@ pub async fn metasrv_builder(
        (Some(kv_backend), _) => (kv_backend, None),
        (None, BackendImpl::MemoryStore) => (Arc::new(MemoryKvBackend::new()) as _, None),
        (None, BackendImpl::EtcdStore) => {
-            let etcd_client = create_etcd_client(&opts.store_addrs).await?;
+            let etcd_client = create_etcd_client(opts).await?;
            let kv_backend = EtcdStore::with_etcd_client(etcd_client.clone(), opts.max_txn_ops);
            let election = EtcdElection::with_etcd_client(
                &opts.server_addr,
@@ -270,7 +240,7 @@ pub async fn metasrv_builder(
        }
        #[cfg(feature = "pg_kvbackend")]
        (None, BackendImpl::PostgresStore) => {
-            let pool = create_postgres_pool(&opts.store_addrs).await?;
+            let pool = create_postgres_pool(opts).await?;
            let kv_backend = PgStore::with_pg_pool(pool, &opts.meta_table_name, opts.max_txn_ops)
                .await
                .context(error::KvBackendSnafu)?;
@@ -290,7 +260,7 @@ pub async fn metasrv_builder(
        }
        #[cfg(feature = "mysql_kvbackend")]
        (None, BackendImpl::MysqlStore) => {
-            let pool = create_mysql_pool(&opts.store_addrs).await?;
+            let pool = create_mysql_pool(opts).await?;
            let kv_backend =
                MySqlStore::with_mysql_pool(pool, &opts.meta_table_name, opts.max_txn_ops)
                    .await
@@ -360,8 +330,9 @@ pub async fn metasrv_builder(
        .plugins(plugins))
 }

-pub async fn create_etcd_client(store_addrs: &[String]) -> Result<Client> {
-    let etcd_endpoints = store_addrs
+async fn create_etcd_client(opts: &MetasrvOptions) -> Result<Client> {
+    let etcd_endpoints = opts
+        .store_addrs
        .iter()
        .map(|x| x.trim())
        .filter(|x| !x.is_empty())
@@ -392,10 +363,13 @@ async fn create_postgres_client(opts: &MetasrvOptions) -> Result<tokio_postgres:
 }

 #[cfg(feature = "pg_kvbackend")]
-pub async fn create_postgres_pool(store_addrs: &[String]) -> Result<deadpool_postgres::Pool> {
-    let postgres_url = store_addrs.first().context(error::InvalidArgumentsSnafu {
-        err_msg: "empty store addrs",
-    })?;
+async fn create_postgres_pool(opts: &MetasrvOptions) -> Result<deadpool_postgres::Pool> {
+    let postgres_url = opts
+        .store_addrs
+        .first()
+        .context(error::InvalidArgumentsSnafu {
+            err_msg: "empty store addrs",
+        })?;
    let mut cfg = Config::new();
    cfg.url = Some(postgres_url.to_string());
    let pool = cfg
@@ -405,10 +379,13 @@ pub async fn create_postgres_pool(store_addrs: &[String]) -> Result<deadpool_pos
 }

 #[cfg(feature = "mysql_kvbackend")]
-async fn setup_mysql_options(store_addrs: &[String]) -> Result<MySqlConnectOptions> {
-    let mysql_url = store_addrs.first().context(error::InvalidArgumentsSnafu {
-        err_msg: "empty store addrs",
-    })?;
+async fn setup_mysql_options(opts: &MetasrvOptions) -> Result<MySqlConnectOptions> {
+    let mysql_url = opts
+        .store_addrs
+        .first()
+        .context(error::InvalidArgumentsSnafu {
+            err_msg: "empty store addrs",
+        })?;
    // Avoid `SET` commands in sqlx
    let opts: MySqlConnectOptions = mysql_url
        .parse()
@@ -422,8 +399,8 @@ async fn setup_mysql_options(store_addrs: &[String]) -> Result<MySqlConnectOptio
 }

 #[cfg(feature = "mysql_kvbackend")]
-pub async fn create_mysql_pool(store_addrs: &[String]) -> Result<MySqlPool> {
-    let opts = setup_mysql_options(store_addrs).await?;
+async fn create_mysql_pool(opts: &MetasrvOptions) -> Result<MySqlPool> {
+    let opts = setup_mysql_options(opts).await?;
    let pool = MySqlPool::connect_with(opts)
        .await
        .context(error::CreateMySqlPoolSnafu)?;
@@ -432,7 +409,7 @@ pub async fn create_mysql_pool(store_addrs: &[String]) -> Result<MySqlPool> {

 #[cfg(feature = "mysql_kvbackend")]
 async fn create_mysql_client(opts: &MetasrvOptions) -> Result<MySqlConnection> {
-    let opts = setup_mysql_options(&opts.store_addrs).await?;
+    let opts = setup_mysql_options(opts).await?;
    let client = MySqlConnection::connect_with(&opts)
        .await
        .context(error::ConnectMySqlSnafu)?;
--- a/src/meta-srv/src/election/etcd.rs
+++ b/src/meta-srv/src/election/etcd.rs
@@ -121,7 +121,7 @@ impl Election for EtcdElection {

    fn in_leader_infancy(&self) -> bool {
        self.infancy
-            .compare_exchange(true, false, Ordering::AcqRel, Ordering::Acquire)
+            .compare_exchange(true, false, Ordering::Relaxed, Ordering::Relaxed)
            .is_ok()
    }

@@ -249,7 +249,7 @@ impl Election for EtcdElection {

            if self
                .is_leader
-                .compare_exchange(true, false, Ordering::AcqRel, Ordering::Acquire)
+                .compare_exchange(true, false, Ordering::Relaxed, Ordering::Relaxed)
                .is_ok()
            {
                if let Err(e) = self
@@ -307,10 +307,10 @@ impl EtcdElection {
            // Only after a successful `keep_alive` is the leader considered official.
            if self
                .is_leader
-                .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+                .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
                .is_ok()
            {
-                self.infancy.store(true, Ordering::Release);
+                self.infancy.store(true, Ordering::Relaxed);

                if let Err(e) = self
                    .leader_watcher
--- a/src/meta-srv/src/election/mysql.rs
+++ b/src/meta-srv/src/election/mysql.rs
@@ -403,7 +403,7 @@ impl Election for MySqlElection {

    fn in_leader_infancy(&self) -> bool {
        self.leader_infancy
-            .compare_exchange(true, false, Ordering::AcqRel, Ordering::Acquire)
+            .compare_exchange(true, false, Ordering::Relaxed, Ordering::Relaxed)
            .is_ok()
    }

@@ -774,7 +774,7 @@ impl MySqlElection {
        };
        if self
            .is_leader
-            .compare_exchange(true, false, Ordering::AcqRel, Ordering::Acquire)
+            .compare_exchange(true, false, Ordering::Relaxed, Ordering::Relaxed)
            .is_ok()
        {
            if let Err(e) = self
@@ -802,10 +802,10 @@ impl MySqlElection {

        if self
            .is_leader
-            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+            .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
            .is_ok()
        {
-            self.leader_infancy.store(true, Ordering::Release);
+            self.leader_infancy.store(true, Ordering::Relaxed);

            if let Err(e) = self
                .leader_watcher
@@ -842,7 +842,6 @@ impl MySqlElection {
 mod tests {
    use std::env;

-    use common_meta::maybe_skip_mysql_integration_test;
    use common_telemetry::init_default_ut_logging;
    use sqlx::Connection;

@@ -886,7 +885,6 @@ mod tests {

    #[tokio::test]
    async fn test_mysql_crud() {
-        maybe_skip_mysql_integration_test!();
        let key = "test_key".to_string();
        let value = "test_value".to_string();

@@ -1016,7 +1014,6 @@ mod tests {

    #[tokio::test]
    async fn test_candidate_registration() {
-        maybe_skip_mysql_integration_test!();
        let leader_value_prefix = "test_leader".to_string();
        let candidate_lease_ttl_secs = 2;
        let uuid = uuid::Uuid::new_v4().to_string();
@@ -1102,7 +1099,6 @@ mod tests {

    #[tokio::test]
    async fn test_elected_and_step_down() {
-        maybe_skip_mysql_integration_test!();
        let leader_value = "test_leader".to_string();
        let candidate_lease_ttl_secs = 1;
        let uuid = uuid::Uuid::new_v4().to_string();
@@ -1186,7 +1182,6 @@ mod tests {

    #[tokio::test]
    async fn test_campaign() {
-        maybe_skip_mysql_integration_test!();
        let leader_value = "test_leader".to_string();
        let uuid = uuid::Uuid::new_v4().to_string();
        let table_name = "test_leader_action_greptime_metakv";
@@ -1368,7 +1363,6 @@ mod tests {

    #[tokio::test]
    async fn test_follower_action() {
-        maybe_skip_mysql_integration_test!();
        common_telemetry::init_default_ut_logging();
        let candidate_lease_ttl_secs = 5;
        let meta_lease_ttl_secs = 1;
--- a/src/meta-srv/src/election/postgres.rs
+++ b/src/meta-srv/src/election/postgres.rs
@@ -288,7 +288,7 @@ impl Election for PgElection {

    fn in_leader_infancy(&self) -> bool {
        self.leader_infancy
-            .compare_exchange(true, false, Ordering::AcqRel, Ordering::Acquire)
+            .compare_exchange(true, false, Ordering::Relaxed, Ordering::Relaxed)
            .is_ok()
    }

@@ -660,7 +660,7 @@ impl PgElection {
        };
        if self
            .is_leader
-            .compare_exchange(true, false, Ordering::AcqRel, Ordering::Acquire)
+            .compare_exchange(true, false, Ordering::Relaxed, Ordering::Relaxed)
            .is_ok()
        {
            self.delete_value(&key).await?;
@@ -688,7 +688,7 @@ impl PgElection {
        };
        if self
            .is_leader
-            .compare_exchange(true, false, Ordering::AcqRel, Ordering::Acquire)
+            .compare_exchange(true, false, Ordering::Relaxed, Ordering::Relaxed)
            .is_ok()
        {
            if let Err(e) = self
@@ -716,10 +716,10 @@ impl PgElection {

        if self
            .is_leader
-            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+            .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
            .is_ok()
        {
-            self.leader_infancy.store(true, Ordering::Release);
+            self.leader_infancy.store(true, Ordering::Relaxed);

            if let Err(e) = self
                .leader_watcher
@@ -736,7 +736,6 @@ impl PgElection {
 mod tests {
    use std::env;

-    use common_meta::maybe_skip_postgres_integration_test;
    use tokio_postgres::{Client, NoTls};

    use super::*;
@@ -773,7 +772,6 @@ mod tests {

    #[tokio::test]
    async fn test_postgres_crud() {
-        maybe_skip_postgres_integration_test!();
        let key = "test_key".to_string();
        let value = "test_value".to_string();

@@ -883,7 +881,6 @@ mod tests {

    #[tokio::test]
    async fn test_candidate_registration() {
-        maybe_skip_postgres_integration_test!();
        let leader_value_prefix = "test_leader".to_string();
        let candidate_lease_ttl_secs = 5;
        let uuid = uuid::Uuid::new_v4().to_string();
@@ -942,7 +939,6 @@ mod tests {

    #[tokio::test]
    async fn test_elected_and_step_down() {
-        maybe_skip_postgres_integration_test!();
        let leader_value = "test_leader".to_string();
        let candidate_lease_ttl_secs = 5;
        let uuid = uuid::Uuid::new_v4().to_string();
@@ -1056,7 +1052,6 @@ mod tests {

    #[tokio::test]
    async fn test_leader_action() {
-        maybe_skip_postgres_integration_test!();
        let leader_value = "test_leader".to_string();
        let uuid = uuid::Uuid::new_v4().to_string();
        let table_name = "test_leader_action_greptime_metakv";
@@ -1292,7 +1287,6 @@ mod tests {

    #[tokio::test]
    async fn test_follower_action() {
-        maybe_skip_postgres_integration_test!();
        common_telemetry::init_default_ut_logging();
        let candidate_lease_ttl_secs = 5;
        let uuid = uuid::Uuid::new_v4().to_string();
--- a/src/meta-srv/src/error.rs
+++ b/src/meta-srv/src/error.rs
@@ -69,18 +69,6 @@ pub enum Error {
        region_id: RegionId,
    },

-    #[snafu(display(
-        "The region migration procedure is completed for region: {}, target_peer: {}",
-        region_id,
-        target_peer_id
-    ))]
-    RegionMigrated {
-        #[snafu(implicit)]
-        location: Location,
-        region_id: RegionId,
-        target_peer_id: u64,
-    },
-
    #[snafu(display("The region migration procedure aborted, reason: {}", reason))]
    MigrationAbort {
        #[snafu(implicit)]
@@ -965,8 +953,7 @@ impl ErrorExt for Error {
            | Error::RegionOpeningRace { .. }
            | Error::RegionRouteNotFound { .. }
            | Error::MigrationAbort { .. }
-            | Error::MigrationRunning { .. }
-            | Error::RegionMigrated { .. } => StatusCode::Unexpected,
+            | Error::MigrationRunning { .. } => StatusCode::Unexpected,
            Error::TableNotFound { .. } => StatusCode::TableNotFound,
            Error::SaveClusterInfo { source, .. }
            | Error::InvalidClusterInfoFormat { source, .. }
--- a/src/meta-srv/src/metasrv.rs
+++ b/src/meta-srv/src/metasrv.rs
@@ -75,6 +75,11 @@ pub const TABLE_ID_SEQ: &str = "table_id";
 pub const FLOW_ID_SEQ: &str = "flow_id";
 pub const METASRV_HOME: &str = "./greptimedb_data/metasrv";

+#[cfg(any(feature = "pg_kvbackend", feature = "mysql_kvbackend"))]
+pub const DEFAULT_META_TABLE_NAME: &str = "greptime_metakv";
+#[cfg(any(feature = "pg_kvbackend", feature = "mysql_kvbackend"))]
+pub const DEFAULT_META_ELECTION_LOCK_ID: u64 = 1;
+
 // The datastores that implements metadata kvbackend.
 #[derive(Clone, Debug, PartialEq, Serialize, Default, Deserialize, ValueEnum)]
 #[serde(rename_all = "snake_case")]
@@ -241,9 +246,9 @@ impl Default for MetasrvOptions {
            tracing: TracingOptions::default(),
            backend: BackendImpl::EtcdStore,
            #[cfg(any(feature = "pg_kvbackend", feature = "mysql_kvbackend"))]
-            meta_table_name: common_meta::kv_backend::DEFAULT_META_TABLE_NAME.to_string(),
+            meta_table_name: DEFAULT_META_TABLE_NAME.to_string(),
            #[cfg(feature = "pg_kvbackend")]
-            meta_election_lock_id: common_meta::kv_backend::DEFAULT_META_ELECTION_LOCK_ID,
+            meta_election_lock_id: DEFAULT_META_ELECTION_LOCK_ID,
            node_max_idle_time: Duration::from_secs(24 * 60 * 60),
        }
    }
@@ -469,7 +474,7 @@ impl Metasrv {
    pub async fn try_start(&self) -> Result<()> {
        if self
            .started
-            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+            .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
            .is_err()
        {
            warn!("Metasrv already started");
@@ -566,7 +571,7 @@ impl Metasrv {
                let started = self.started.clone();
                let node_info = self.node_info();
                let _handle = common_runtime::spawn_global(async move {
-                    while started.load(Ordering::Acquire) {
+                    while started.load(Ordering::Relaxed) {
                        let res = election.register_candidate(&node_info).await;
                        if let Err(e) = res {
                            warn!(e; "Metasrv register candidate error");
@@ -580,7 +585,7 @@ impl Metasrv {
                let election = election.clone();
                let started = self.started.clone();
                let _handle = common_runtime::spawn_global(async move {
-                    while started.load(Ordering::Acquire) {
+                    while started.load(Ordering::Relaxed) {
                        let res = election.campaign().await;
                        if let Err(e) = res {
                            warn!(e; "Metasrv election error");
@@ -615,23 +620,11 @@ impl Metasrv {
    }

    pub async fn shutdown(&self) -> Result<()> {
-        if self
-            .started
-            .compare_exchange(true, false, Ordering::AcqRel, Ordering::Acquire)
-            .is_err()
-        {
-            warn!("Metasrv already stopped");
-            return Ok(());
-        }
-
+        self.started.store(false, Ordering::Relaxed);
        self.procedure_manager
            .stop()
            .await
-            .context(StopProcedureManagerSnafu)?;
-
-        info!("Metasrv stopped");
-
-        Ok(())
+            .context(StopProcedureManagerSnafu)
    }

    pub fn start_time_ms(&self) -> u64 {
@@ -648,9 +641,8 @@ impl Metasrv {
        }
    }

-    /// Looks up a datanode peer by peer_id, returning it only when it's alive.
-    /// A datanode is considered alive when it's still within the lease period.
-    pub(crate) async fn lookup_datanode_peer(&self, peer_id: u64) -> Result<Option<Peer>> {
+    /// Lookup a peer by peer_id, return it only when it's alive.
+    pub(crate) async fn lookup_peer(&self, peer_id: u64) -> Result<Option<Peer>> {
        lookup_datanode_peer(
            peer_id,
            &self.meta_peer_client,
--- a/src/meta-srv/src/metasrv/builder.rs
+++ b/src/meta-srv/src/metasrv/builder.rs
@@ -159,6 +159,8 @@ impl MetasrvBuilder {
    }

    pub async fn build(self) -> Result<Metasrv> {
+        let started = Arc::new(AtomicBool::new(false));
+
        let MetasrvBuilder {
            election,
            meta_peer_client,
@@ -433,7 +435,7 @@ impl MetasrvBuilder {

        Ok(Metasrv {
            state,
-            started: Arc::new(AtomicBool::new(false)),
+            started,
            start_time_ms: common_time::util::current_time_millis() as u64,
            options,
            in_memory,
--- a/src/meta-srv/src/procedure/region_migration/manager.rs
+++ b/src/meta-srv/src/procedure/region_migration/manager.rs
@@ -326,11 +326,7 @@ impl RegionMigrationManager {

        if self.has_migrated(&region_route, &task)? {
            info!("Skipping region migration task: {task}");
-            return error::RegionMigratedSnafu {
-                region_id,
-                target_peer_id: task.to_peer.id,
-            }
-            .fail();
+            return Ok(None);
        }

        self.verify_region_leader_peer(&region_route, &task)?;
@@ -571,8 +567,7 @@ mod test {
        env.create_physical_table_metadata(table_info, region_routes)
            .await;

-        let err = manager.submit_procedure(task).await.unwrap_err();
-        assert_matches!(err, error::Error::RegionMigrated { .. });
+        manager.submit_procedure(task).await.unwrap();
    }

    #[tokio::test]
--- a/src/meta-srv/src/region/supervisor.rs
+++ b/src/meta-srv/src/region/supervisor.rs
@@ -27,7 +27,7 @@ use common_meta::DatanodeId;
 use common_runtime::JoinHandle;
 use common_telemetry::{debug, error, info, warn};
 use common_time::util::current_time_millis;
-use error::Error::{LeaderPeerChanged, MigrationRunning, RegionMigrated, TableRouteNotFound};
+use error::Error::{LeaderPeerChanged, MigrationRunning, TableRouteNotFound};
 use snafu::{ensure, OptionExt, ResultExt};
 use store_api::storage::RegionId;
 use tokio::sync::mpsc::{Receiver, Sender};
@@ -527,7 +527,6 @@ impl RegionSupervisor {

    async fn do_failover(&mut self, task: RegionMigrationProcedureTask, count: u32) -> Result<()> {
        let from_peer_id = task.from_peer.id;
-        let to_peer_id = task.to_peer.id;
        let region_id = task.region_id;

        info!(
@@ -537,15 +536,6 @@ impl RegionSupervisor {

        if let Err(err) = self.region_migration_manager.submit_procedure(task).await {
            return match err {
-                RegionMigrated { .. } => {
-                    info!(
-                        "Region has been migrated to target peer: {}, removed failover detector for region: {}, datanode: {}",
-                        to_peer_id, region_id, from_peer_id
-                    );
-                    self.deregister_failure_detectors(vec![(from_peer_id, region_id)])
-                        .await;
-                    Ok(())
-                }
                // Returns Ok if it's running or table is dropped.
                MigrationRunning { .. } => {
                    info!(
--- a/src/meta-srv/src/service/procedure.rs
+++ b/src/meta-srv/src/service/procedure.rs
@@ -139,11 +139,11 @@ impl procedure_service_server::ProcedureService for Metasrv {

        let _header = header.context(error::MissingRequestHeaderSnafu)?;
        let from_peer = self
-            .lookup_datanode_peer(from_peer)
+            .lookup_peer(from_peer)
            .await?
            .context(error::PeerUnavailableSnafu { peer_id: from_peer })?;
        let to_peer = self
-            .lookup_datanode_peer(to_peer)
+            .lookup_peer(to_peer)
            .await?
            .context(error::PeerUnavailableSnafu { peer_id: to_peer })?;

--- a/src/metric-engine/src/data_region.rs
+++ b/src/metric-engine/src/data_region.rs
@@ -206,9 +206,7 @@ impl DataRegion {
    ) -> Result<AffectedRows> {
        match request.kind {
            AlterKind::SetRegionOptions { options: _ }
-            | AlterKind::UnsetRegionOptions { keys: _ }
-            | AlterKind::SetIndex { options: _ }
-            | AlterKind::UnsetIndex { options: _ } => {
+            | AlterKind::UnsetRegionOptions { keys: _ } => {
                let region_id = utils::to_data_region_id(region_id);
                self.mito
                    .handle_request(region_id, RegionRequest::Alter(request))
--- a/src/metric-engine/src/engine/read.rs
+++ b/src/metric-engine/src/engine/read.rs
@@ -15,7 +15,7 @@
 use std::sync::Arc;

 use api::v1::SemanticType;
-use common_telemetry::{debug, error, tracing};
+use common_telemetry::{error, info, tracing};
 use datafusion::logical_expr::{self, Expr};
 use snafu::{OptionExt, ResultExt};
 use store_api::metadata::{RegionMetadataBuilder, RegionMetadataRef};
@@ -40,7 +40,7 @@ impl MetricEngineInner {
        let is_reading_physical_region = self.is_physical_region(region_id);

        if is_reading_physical_region {
-            debug!(
+            info!(
                "Metric region received read request {request:?} on physical region {region_id:?}"
            );
            self.read_physical_region(region_id, request).await
--- a/src/mito2/Cargo.toml
+++ b/src/mito2/Cargo.toml
@@ -24,7 +24,6 @@ common-config.workspace = true
 common-datasource.workspace = true
 common-decimal.workspace = true
 common-error.workspace = true
-common-grpc.workspace = true
 common-macro.workspace = true
 common-meta.workspace = true
 common-query.workspace = true
@@ -98,8 +97,3 @@ required-features = ["test"]
 name = "bench_filter_time_partition"
 harness = false
 required-features = ["test"]
-
-[[bench]]
-name = "bench_compaction_picker"
-harness = false
-required-features = ["test"]
--- a/Show More
+++ b/Show More