chore: bump version to 0.13.2 (#5837 )

* fix: mysql prepare bool value (#5732) * fix: mysql prepare limit&offset param (#5734) * fix: prepare limit&offset param * test: sqlness * chore: per review * chore: per review * fix: wrap table name with `` (#5748) * fix: wrap table name with quotes * fix: minor fix * fix: handle nullable default value (#5747) * fix: handle nullable default value * chore: update sqlness * fix: properly give placeholder types (#5760) * fix: properly give placeholder types * chore: update sqlness * fix: support __name__ matcher in label values (#5773) * fix: typo variadic (#5800) Signed-off-by: Ruihang Xia <waynestxia@gmail.com> * fix: close issue #3902 since upstream fixed (#5801) Signed-off-by: yihong0618 <zouzou0208@gmail.com> * fix: correct error status code (#5802) * fix: interval cast expression can't work in range query, #5805 (#5813) * fix: interval cast expression can't work in range query, #5805 * fix: nested cast * test: make vector test stable * feat: introduce poison mechanism for procedure (#5822) * feat: introduce poison for procedure * tests: add unit tests * refactor: minor refactor * fix: unit tests * chore: fix unit tests * chore: apply suggestions from CR * chore: apply suggestions from CR * chore: update comments * chore: introduce `ProcedureStatus::Poisoned` * chore: upgrade greptime-proto to `2be0f` * chore: apply suggestions from CR * fix: throw errors instead of ignoring (#5792) * fix: throw errors instead of ignoring * fix: fix unit tests * refactor: remove schema version check * fix: fix clippy * chore: remove unused error * refactor: remove schema version check * feat: handle mutliple results * feat: introduce consistency guard * fix: release consistency guard on datanode operation completion * test: add tests * chore: remove schema version * refactor: rename * test: add more tests * chore: print all error * tests: query table after alteration * log ignored request * refine fuzz test * chore: fix clippy and log mailbox message * chore: close prepared statement after execution * chore: add comment * chore: remove log * chore: rename to `ConsistencyPoison` * chore: remove unused error * fix: fix unit tests * chore: apply suggestions from CR --------- Signed-off-by: Ruihang Xia <waynestxia@gmail.com> Signed-off-by: yihong0618 <zouzou0208@gmail.com> Co-authored-by: discord9 <55937128+discord9@users.noreply.github.com> Co-authored-by: Yohan Wal <profsyb@gmail.com> Co-authored-by: Yingwen <realevenyag@gmail.com> Co-authored-by: Ruihang Xia <waynestxia@gmail.com> Co-authored-by: yihong <zouzou0208@gmail.com> Co-authored-by: dennis zhuang <killme2008@gmail.com>
chore: use Bytes instead of string in bulk ingestion (#5717 )
2025-12-22 22:20:02 +00:00 · 2025-04-08 14:16:40 +08:00 · 2025-03-18 04:59:02 +08:00 · 2025-03-14 01:08:29 +00:00 · 2025-03-13 09:19:58 +00:00 · 2025-03-13 08:30:29 +00:00
279 changed files with 14634 additions and 6403 deletions
--- 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,pg_kvbackend
+        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,pg_kvbackend
+        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/actions/build-windows-artifacts/action.yml
+++ b/.github/actions/build-windows-artifacts/action.yml
@@ -47,7 +47,6 @@ runs:
      shell: pwsh
      run: make test sqlness-test
      env:
-        RUSTUP_WINDOWS_PATH_ADD_BIN: 1 # Workaround for https://github.com/nextest-rs/nextest/issues/1493
        RUST_BACKTRACE: 1
        SQLNESS_OPTS: "--preserve-state"

--- a/.github/workflows/dev-build.yml
+++ b/.github/workflows/dev-build.yml
@@ -238,6 +238,13 @@ jobs:
          version: ${{ needs.allocate-runners.outputs.version }}
          push-latest-tag: false # Don't push the latest tag to registry.
          dev-mode: true # Only build the standard images.
+          
+      - name: Echo Docker image tag to step summary
+        run: |
+          echo "## Docker Image Tag" >> $GITHUB_STEP_SUMMARY
+          echo "Image Tag: \`${{ needs.allocate-runners.outputs.version }}\`" >> $GITHUB_STEP_SUMMARY
+          echo "Full Image Name: \`docker.io/${{ vars.IMAGE_NAMESPACE }}/${{ vars.DEV_BUILD_IMAGE_NAME }}:${{ needs.allocate-runners.outputs.version }}\`" >> $GITHUB_STEP_SUMMARY
+          echo "Pull Command: \`docker pull docker.io/${{ vars.IMAGE_NAMESPACE }}/${{ vars.DEV_BUILD_IMAGE_NAME }}:${{ needs.allocate-runners.outputs.version }}\`" >> $GITHUB_STEP_SUMMARY

      - name: Set build result
        id: set-build-result
--- a/.github/workflows/develop.yml
+++ b/.github/workflows/develop.yml
@@ -111,7 +111,7 @@ jobs:
      - name: Build greptime binaries
        shell: bash
        # `cargo gc` will invoke `cargo build` with specified args
-        run: cargo gc -- --bin greptime --bin sqlness-runner --features pg_kvbackend
+        run: cargo gc -- --bin greptime --bin sqlness-runner --features "pg_kvbackend,mysql_kvbackend"
      - name: Pack greptime binaries
        shell: bash
        run: |
@@ -270,7 +270,7 @@ jobs:
      - name: Build greptime bianry
        shell: bash
        # `cargo gc` will invoke `cargo build` with specified args
-        run: cargo gc --profile ci -- --bin greptime --features pg_kvbackend
+        run: cargo gc --profile ci -- --bin greptime --features "pg_kvbackend,mysql_kvbackend"
      - name: Pack greptime binary
        shell: bash
        run: |
@@ -687,7 +687,7 @@ jobs:
        working-directory: tests-integration/fixtures
        run: docker compose up -d --wait
      - name: Run nextest cases
-        run: cargo nextest run --workspace -F dashboard -F pg_kvbackend
+        run: cargo nextest run --workspace -F dashboard -F pg_kvbackend -F mysql_kvbackend
        env:
          CARGO_BUILD_RUSTFLAGS: "-C link-arg=-fuse-ld=mold"
          RUST_BACKTRACE: 1
@@ -704,6 +704,7 @@ jobs:
          GT_MINIO_ENDPOINT_URL: http://127.0.0.1:9000
          GT_ETCD_ENDPOINTS: http://127.0.0.1:2379
          GT_POSTGRES_ENDPOINTS: postgres://greptimedb:admin@127.0.0.1:5432/postgres
+          GT_MYSQL_ENDPOINTS: mysql://greptimedb:admin@127.0.0.1:3306/mysql
          GT_KAFKA_ENDPOINTS: 127.0.0.1:9092
          GT_KAFKA_SASL_ENDPOINTS: 127.0.0.1:9093
          UNITTEST_LOG_DIR: "__unittest_logs"
@@ -739,7 +740,7 @@ jobs:
        working-directory: tests-integration/fixtures
        run: docker compose up -d --wait
      - name: Run nextest cases
-        run: cargo llvm-cov nextest --workspace --lcov --output-path lcov.info -F dashboard -F pg_kvbackend
+        run: cargo llvm-cov nextest --workspace --lcov --output-path lcov.info -F dashboard -F pg_kvbackend -F mysql_kvbackend
        env:
          CARGO_BUILD_RUSTFLAGS: "-C link-arg=-fuse-ld=mold"
          RUST_BACKTRACE: 1
@@ -755,6 +756,7 @@ jobs:
          GT_MINIO_ENDPOINT_URL: http://127.0.0.1:9000
          GT_ETCD_ENDPOINTS: http://127.0.0.1:2379
          GT_POSTGRES_ENDPOINTS: postgres://greptimedb:admin@127.0.0.1:5432/postgres
+          GT_MYSQL_ENDPOINTS: mysql://greptimedb:admin@127.0.0.1:3306/mysql
          GT_KAFKA_ENDPOINTS: 127.0.0.1:9092
          GT_KAFKA_SASL_ENDPOINTS: 127.0.0.1:9093
          UNITTEST_LOG_DIR: "__unittest_logs"
--- a/.github/workflows/grafana.yml
+++ b/.github/workflows/grafana.yml
@@ -0,0 +1,52 @@
+name: Check Grafana Panels
+
+on:
+  pull_request:
+    branches:
+      - main
+    paths:
+      - 'grafana/**'  # Trigger only when files under the grafana/ directory change
+
+jobs:
+  check-panels:
+    runs-on: ubuntu-latest
+
+    steps:
+      # Check out the repository
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # Install jq (required for the script)
+      - name: Install jq
+        run: sudo apt-get install -y jq
+
+      # Make the check.sh script executable
+      - name: Make check.sh executable
+        run: chmod +x grafana/check.sh
+
+      # Run the check.sh script
+      - name: Run check.sh
+        run: ./grafana/check.sh
+
+      # Only run summary.sh for pull_request events (not for merge queues or final pushes)
+      - name: Check if this is a pull request
+        id: check-pr
+        run: |
+          if [[ "${{ github.event_name }}" == "pull_request" ]]; then
+            echo "is_pull_request=true" >> $GITHUB_OUTPUT
+          else
+            echo "is_pull_request=false" >> $GITHUB_OUTPUT
+          fi
+
+      # Make the summary.sh script executable
+      - name: Make summary.sh executable
+        if: steps.check-pr.outputs.is_pull_request == 'true'
+        run: chmod +x grafana/summary.sh
+
+      # Run the summary.sh script and add its output to the GitHub Job Summary
+      - name: Run summary.sh and add to Job Summary
+        if: steps.check-pr.outputs.is_pull_request == 'true'
+        run: |
+          SUMMARY=$(./grafana/summary.sh)
+          echo "### Summary of Grafana Panels" >> $GITHUB_STEP_SUMMARY
+          echo "$SUMMARY" >> $GITHUB_STEP_SUMMARY
--- a/.github/workflows/nightly-ci.yml
+++ b/.github/workflows/nightly-ci.yml
@@ -107,7 +107,6 @@ jobs:
          CARGO_BUILD_RUSTFLAGS: "-C linker=lld-link"
          RUST_BACKTRACE: 1
          CARGO_INCREMENTAL: 0
-          RUSTUP_WINDOWS_PATH_ADD_BIN: 1 # Workaround for https://github.com/nextest-rs/nextest/issues/1493
          GT_S3_BUCKET: ${{ vars.AWS_CI_TEST_BUCKET }}
          GT_S3_ACCESS_KEY_ID: ${{ secrets.AWS_CI_TEST_ACCESS_KEY_ID }}
          GT_S3_ACCESS_KEY: ${{ secrets.AWS_CI_TEST_SECRET_ACCESS_KEY }}
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1693,6 +1693,7 @@ dependencies = [
 "humantime",
 "meta-client",
 "nu-ansi-term",
+ "opendal",
 "query",
 "rand",
 "reqwest",
@@ -2015,6 +2016,7 @@ dependencies = [
 "arc-swap",
 "async-trait",
 "bincode",
+ "chrono",
 "common-base",
 "common-catalog",
 "common-error",
@@ -2196,6 +2198,7 @@ dependencies = [
 "serde_with",
 "session",
 "snafu 0.8.5",
+ "sqlx",
 "store-api",
 "strum 0.25.0",
 "table",
@@ -2264,6 +2267,7 @@ version = "0.13.0"
 dependencies = [
 "async-trait",
 "common-procedure",
+ "snafu 0.8.5",
 ]

 [[package]]
@@ -4167,6 +4171,7 @@ dependencies = [
 "bytes",
 "cache",
 "catalog",
+ "chrono",
 "client",
 "common-base",
 "common-catalog",
@@ -4701,7 +4706,7 @@ dependencies = [
 [[package]]
 name = "greptime-proto"
 version = "0.1.0"
-source = "git+https://github.com/GreptimeTeam/greptime-proto.git?rev=d92c9ac4e90ef4abdcf5c2eaf5a164e18ba09486#d92c9ac4e90ef4abdcf5c2eaf5a164e18ba09486"
+source = "git+https://github.com/GreptimeTeam/greptime-proto.git?rev=2be0f36b3264e28ab0e1c22a980d0bb634eb3a77#2be0f36b3264e28ab0e1c22a980d0bb634eb3a77"
 dependencies = [
 "prost 0.13.3",
 "serde",
@@ -5566,6 +5571,7 @@ dependencies = [
 "rand",
 "regex",
 "regex-automata 0.4.8",
+ "roaring",
 "serde",
 "serde_json",
 "snafu 0.8.5",
@@ -5897,15 +5903,15 @@ dependencies = [

 [[package]]
 name = "jsonpath-rust"
-version = "0.7.3"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69a61b87f6a55cc6c28fed5739dd36b9642321ce63e4a5e4a4715d69106f4a10"
+checksum = "0c00ae348f9f8fd2d09f82a98ca381c60df9e0820d8d79fce43e649b4dc3128b"
 dependencies = [
 "pest",
 "pest_derive",
 "regex",
 "serde_json",
- "thiserror 1.0.64",
+ "thiserror 2.0.12",
 ]

 [[package]]
@@ -6716,6 +6722,7 @@ dependencies = [
 "session",
 "snafu 0.8.5",
 "store-api",
+ "strum 0.25.0",
 "table",
 "tokio",
 "tokio-postgres",
@@ -8270,7 +8277,7 @@ dependencies = [
 "rand",
 "ring",
 "rust_decimal",
- "thiserror 2.0.6",
+ "thiserror 2.0.12",
 "tokio",
 "tokio-rustls 0.26.0",
 "tokio-util",
@@ -8382,7 +8389,7 @@ dependencies = [
 "greptime-proto",
 "itertools 0.10.5",
 "jsonb",
- "jsonpath-rust 0.7.3",
+ "jsonpath-rust 0.7.5",
 "lazy_static",
 "moka",
 "once_cell",
@@ -8760,6 +8767,7 @@ dependencies = [
 "common-recordbatch",
 "common-telemetry",
 "datafusion",
+ "datafusion-common",
 "datafusion-expr",
 "datatypes",
 "futures",
@@ -8773,8 +8781,9 @@ dependencies = [

 [[package]]
 name = "promql-parser"
-version = "0.4.3"
-source = "git+https://github.com/GreptimeTeam/promql-parser.git?rev=27abb8e16003a50c720f00d6c85f41f5fa2a2a8e#27abb8e16003a50c720f00d6c85f41f5fa2a2a8e"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c6b1429bdd199d53bd58b745075c1652efedbe2746e5d4f0d56d3184dda48ec"
 dependencies = [
 "cfgrammar",
 "chrono",
@@ -9632,6 +9641,16 @@ dependencies = [
 "syn 1.0.109",
 ]

+[[package]]
+name = "roaring"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41589aba99537475bf697f2118357cad1c31590c5a1b9f6d9fc4ad6d07503661"
+dependencies = [
+ "bytemuck",
+ "byteorder",
+]
+
 [[package]]
 name = "robust"
 version = "1.1.0"
@@ -11051,7 +11070,7 @@ dependencies = [
 "serde_json",
 "sha2",
 "smallvec",
- "thiserror 2.0.6",
+ "thiserror 2.0.12",
 "tokio",
 "tokio-stream",
 "tracing",
@@ -11136,7 +11155,7 @@ dependencies = [
 "smallvec",
 "sqlx-core",
 "stringprep",
- "thiserror 2.0.6",
+ "thiserror 2.0.12",
 "tracing",
 "whoami",
 ]
@@ -11174,7 +11193,7 @@ dependencies = [
 "smallvec",
 "sqlx-core",
 "stringprep",
- "thiserror 2.0.6",
+ "thiserror 2.0.12",
 "tracing",
 "whoami",
 ]
@@ -11955,11 +11974,11 @@ dependencies = [

 [[package]]
 name = "thiserror"
-version = "2.0.6"
+version = "2.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fec2a1820ebd077e2b90c4df007bebf344cd394098a13c563957d0afc83ea47"
+checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
 dependencies = [
- "thiserror-impl 2.0.6",
+ "thiserror-impl 2.0.12",
 ]

 [[package]]
@@ -11975,9 +11994,9 @@ dependencies = [

 [[package]]
 name = "thiserror-impl"
-version = "2.0.6"
+version = "2.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d65750cab40f4ff1929fb1ba509e9914eb756131cef4210da8d5d700d26f6312"
+checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -129,7 +129,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 = "d92c9ac4e90ef4abdcf5c2eaf5a164e18ba09486" }
+greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "2be0f36b3264e28ab0e1c22a980d0bb634eb3a77" }
 hex = "0.4"
 http = "1"
 humantime = "2.1"
@@ -160,9 +160,7 @@ parquet = { version = "53.0.0", default-features = false, features = ["arrow", "
 paste = "1.0"
 pin-project = "1.0"
 prometheus = { version = "0.13.3", features = ["process"] }
-promql-parser = { git = "https://github.com/GreptimeTeam/promql-parser.git", features = [
-    "ser",
-], rev = "27abb8e16003a50c720f00d6c85f41f5fa2a2a8e" }
+promql-parser = { version = "0.5", features = ["ser"] }
 prost = "0.13"
 raft-engine = { version = "0.4.1", default-features = false }
 rand = "0.8"
@@ -190,6 +188,10 @@ shadow-rs = "0.38"
 similar-asserts = "1.6.0"
 smallvec = { version = "1", features = ["serde"] }
 snafu = "0.8"
+sqlx = { version = "0.8", features = [
+    "runtime-tokio-rustls",
+    "mysql",
+] }
 sysinfo = "0.30"
 # on branch v0.52.x
 sqlparser = { git = "https://github.com/GreptimeTeam/sqlparser-rs.git", rev = "71dd86058d2af97b9925093d40c4e03360403170", features = [
--- a/config/datanode.example.toml
+++ b/config/datanode.example.toml
@@ -231,6 +231,7 @@ overwrite_entry_start_id = false
 # secret_access_key = "123456"
 # endpoint = "https://s3.amazonaws.com"
 # region = "us-west-2"
+# enable_virtual_host_style = false

 # Example of using Oss as the storage.
 # [storage]
--- a/config/standalone.example.toml
+++ b/config/standalone.example.toml
@@ -318,6 +318,7 @@ retry_delay = "500ms"
 # secret_access_key = "123456"
 # endpoint = "https://s3.amazonaws.com"
 # region = "us-west-2"
+# enable_virtual_host_style = false

 # Example of using Oss as the storage.
 # [storage]
--- a/grafana/check.sh
+++ b/grafana/check.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+BASEDIR=$(dirname "$0")
+
+# Use jq to check for panels with empty or missing descriptions
+invalid_panels=$(cat $BASEDIR/greptimedb-cluster.json | jq -r '
+  .panels[]
+  | select((.type == "stats" or .type == "timeseries") and (.description == "" or .description == null))
+')
+
+# Check if any invalid panels were found
+if [[ -n "$invalid_panels" ]]; then
+  echo "Error: The following panels have empty or missing descriptions:"
+  echo "$invalid_panels"
+  exit 1
+else
+  echo "All panels with type 'stats' or 'timeseries' have valid descriptions."
+  exit 0
+fi
--- a/grafana/greptimedb-cluster.json
+++ b/grafana/greptimedb-cluster.json
--- a/grafana/summary.sh
+++ b/grafana/summary.sh
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+BASEDIR=$(dirname "$0")
+echo '| Title | Description | Expressions |
+|---|---|---|'
+
+cat $BASEDIR/greptimedb-cluster.json | jq -r '
+  .panels |
+  map(select(.type == "stat" or .type == "timeseries")) |
+  .[] | "| \(.title) | \(.description | gsub("\n"; "<br>")) | \(.targets | map(.expr // .rawSql | "`\(.|gsub("\n"; "<br>"))`")  | join("<br>")) |"
+'
--- a/src/api/src/helper.rs
+++ b/src/api/src/helper.rs
@@ -19,9 +19,7 @@ use common_decimal::decimal128::{DECIMAL128_DEFAULT_SCALE, DECIMAL128_MAX_PRECIS
 use common_decimal::Decimal128;
 use common_time::time::Time;
 use common_time::timestamp::TimeUnit;
-use common_time::{
-    Date, DateTime, IntervalDayTime, IntervalMonthDayNano, IntervalYearMonth, Timestamp,
-};
+use common_time::{Date, IntervalDayTime, IntervalMonthDayNano, IntervalYearMonth, Timestamp};
 use datatypes::prelude::{ConcreteDataType, ValueRef};
 use datatypes::scalars::ScalarVector;
 use datatypes::types::{
@@ -29,8 +27,8 @@ use datatypes::types::{
 };
 use datatypes::value::{OrderedF32, OrderedF64, Value};
 use datatypes::vectors::{
-    BinaryVector, BooleanVector, DateTimeVector, DateVector, Decimal128Vector, Float32Vector,
-    Float64Vector, Int32Vector, Int64Vector, IntervalDayTimeVector, IntervalMonthDayNanoVector,
+    BinaryVector, BooleanVector, DateVector, Decimal128Vector, Float32Vector, Float64Vector,
+    Int32Vector, Int64Vector, IntervalDayTimeVector, IntervalMonthDayNanoVector,
    IntervalYearMonthVector, PrimitiveVector, StringVector, TimeMicrosecondVector,
    TimeMillisecondVector, TimeNanosecondVector, TimeSecondVector, TimestampMicrosecondVector,
    TimestampMillisecondVector, TimestampNanosecondVector, TimestampSecondVector, UInt32Vector,
@@ -118,7 +116,7 @@ impl From<ColumnDataTypeWrapper> for ConcreteDataType {
            ColumnDataType::Json => ConcreteDataType::json_datatype(),
            ColumnDataType::String => ConcreteDataType::string_datatype(),
            ColumnDataType::Date => ConcreteDataType::date_datatype(),
-            ColumnDataType::Datetime => ConcreteDataType::datetime_datatype(),
+            ColumnDataType::Datetime => ConcreteDataType::timestamp_microsecond_datatype(),
            ColumnDataType::TimestampSecond => ConcreteDataType::timestamp_second_datatype(),
            ColumnDataType::TimestampMillisecond => {
                ConcreteDataType::timestamp_millisecond_datatype()
@@ -271,7 +269,6 @@ impl TryFrom<ConcreteDataType> for ColumnDataTypeWrapper {
            ConcreteDataType::Binary(_) => ColumnDataType::Binary,
            ConcreteDataType::String(_) => ColumnDataType::String,
            ConcreteDataType::Date(_) => ColumnDataType::Date,
-            ConcreteDataType::DateTime(_) => ColumnDataType::Datetime,
            ConcreteDataType::Timestamp(t) => match t {
                TimestampType::Second(_) => ColumnDataType::TimestampSecond,
                TimestampType::Millisecond(_) => ColumnDataType::TimestampMillisecond,
@@ -476,7 +473,6 @@ pub fn push_vals(column: &mut Column, origin_count: usize, vector: VectorRef) {
        Value::String(val) => values.string_values.push(val.as_utf8().to_string()),
        Value::Binary(val) => values.binary_values.push(val.to_vec()),
        Value::Date(val) => values.date_values.push(val.val()),
-        Value::DateTime(val) => values.datetime_values.push(val.val()),
        Value::Timestamp(val) => match val.unit() {
            TimeUnit::Second => values.timestamp_second_values.push(val.value()),
            TimeUnit::Millisecond => values.timestamp_millisecond_values.push(val.value()),
@@ -577,12 +573,11 @@ pub fn pb_value_to_value_ref<'a>(
        ValueData::BinaryValue(bytes) => ValueRef::Binary(bytes.as_slice()),
        ValueData::StringValue(string) => ValueRef::String(string.as_str()),
        ValueData::DateValue(d) => ValueRef::Date(Date::from(*d)),
-        ValueData::DatetimeValue(d) => ValueRef::DateTime(DateTime::new(*d)),
        ValueData::TimestampSecondValue(t) => ValueRef::Timestamp(Timestamp::new_second(*t)),
        ValueData::TimestampMillisecondValue(t) => {
            ValueRef::Timestamp(Timestamp::new_millisecond(*t))
        }
-        ValueData::TimestampMicrosecondValue(t) => {
+        ValueData::DatetimeValue(t) | ValueData::TimestampMicrosecondValue(t) => {
            ValueRef::Timestamp(Timestamp::new_microsecond(*t))
        }
        ValueData::TimestampNanosecondValue(t) => {
@@ -651,7 +646,6 @@ pub fn pb_values_to_vector_ref(data_type: &ConcreteDataType, values: Values) ->
        ConcreteDataType::Binary(_) => Arc::new(BinaryVector::from(values.binary_values)),
        ConcreteDataType::String(_) => Arc::new(StringVector::from_vec(values.string_values)),
        ConcreteDataType::Date(_) => Arc::new(DateVector::from_vec(values.date_values)),
-        ConcreteDataType::DateTime(_) => Arc::new(DateTimeVector::from_vec(values.datetime_values)),
        ConcreteDataType::Timestamp(unit) => match unit {
            TimestampType::Second(_) => Arc::new(TimestampSecondVector::from_vec(
                values.timestamp_second_values,
@@ -787,11 +781,6 @@ pub fn pb_values_to_values(data_type: &ConcreteDataType, values: Values) -> Vec<
            .into_iter()
            .map(|val| val.into())
            .collect(),
-        ConcreteDataType::DateTime(_) => values
-            .datetime_values
-            .into_iter()
-            .map(|v| Value::DateTime(v.into()))
-            .collect(),
        ConcreteDataType::Date(_) => values
            .date_values
            .into_iter()
@@ -947,9 +936,6 @@ pub fn to_proto_value(value: Value) -> Option<v1::Value> {
        Value::Date(v) => v1::Value {
            value_data: Some(ValueData::DateValue(v.val())),
        },
-        Value::DateTime(v) => v1::Value {
-            value_data: Some(ValueData::DatetimeValue(v.val())),
-        },
        Value::Timestamp(v) => match v.unit() {
            TimeUnit::Second => v1::Value {
                value_data: Some(ValueData::TimestampSecondValue(v.value())),
@@ -1066,7 +1052,6 @@ pub fn value_to_grpc_value(value: Value) -> GrpcValue {
            Value::String(v) => Some(ValueData::StringValue(v.as_utf8().to_string())),
            Value::Binary(v) => Some(ValueData::BinaryValue(v.to_vec())),
            Value::Date(v) => Some(ValueData::DateValue(v.val())),
-            Value::DateTime(v) => Some(ValueData::DatetimeValue(v.val())),
            Value::Timestamp(v) => Some(match v.unit() {
                TimeUnit::Second => ValueData::TimestampSecondValue(v.value()),
                TimeUnit::Millisecond => ValueData::TimestampMillisecondValue(v.value()),
@@ -1248,7 +1233,7 @@ mod tests {
            ColumnDataTypeWrapper::date_datatype().into()
        );
        assert_eq!(
-            ConcreteDataType::datetime_datatype(),
+            ConcreteDataType::timestamp_microsecond_datatype(),
            ColumnDataTypeWrapper::datetime_datatype().into()
        );
        assert_eq!(
@@ -1339,10 +1324,6 @@ mod tests {
            ColumnDataTypeWrapper::date_datatype(),
            ConcreteDataType::date_datatype().try_into().unwrap()
        );
-        assert_eq!(
-            ColumnDataTypeWrapper::datetime_datatype(),
-            ConcreteDataType::datetime_datatype().try_into().unwrap()
-        );
        assert_eq!(
            ColumnDataTypeWrapper::timestamp_millisecond_datatype(),
            ConcreteDataType::timestamp_millisecond_datatype()
@@ -1830,17 +1811,6 @@ mod tests {
        ]
    );

-    test_convert_values!(
-        datetime,
-        vec![1.into(), 2.into(), 3.into()],
-        datetime,
-        vec![
-            Value::DateTime(1.into()),
-            Value::DateTime(2.into()),
-            Value::DateTime(3.into())
-        ]
-    );
-
    #[test]
    fn test_vectors_to_rows_for_different_types() {
        let boolean_vec = BooleanVector::from_vec(vec![true, false, true]);
--- a/src/api/src/v1/column_def.rs
+++ b/src/api/src/v1/column_def.rs
@@ -132,6 +132,15 @@ pub fn options_from_skipping(skipping: &SkippingIndexOptions) -> Result<Option<C
    Ok((!options.options.is_empty()).then_some(options))
 }

+/// Tries to construct a `ColumnOptions` for inverted index.
+pub fn options_from_inverted() -> ColumnOptions {
+    let mut options = ColumnOptions::default();
+    options
+        .options
+        .insert(INVERTED_INDEX_GRPC_KEY.to_string(), "true".to_string());
+    options
+}
+
 /// Tries to construct a `FulltextAnalyzer` from the given analyzer.
 pub fn as_fulltext_option(analyzer: Analyzer) -> FulltextAnalyzer {
    match analyzer {
--- a/src/catalog/src/system_schema.rs
+++ b/src/catalog/src/system_schema.rs
@@ -77,7 +77,7 @@ trait SystemSchemaProviderInner {
    fn system_table(&self, name: &str) -> Option<SystemTableRef>;

    fn table_info(catalog_name: String, table: &SystemTableRef) -> TableInfoRef {
-        let table_meta = TableMetaBuilder::default()
+        let table_meta = TableMetaBuilder::empty()
            .schema(table.schema())
            .primary_key_indices(vec![])
            .next_column_id(0)
--- a/src/catalog/src/system_schema/information_schema/columns.rs
+++ b/src/catalog/src/system_schema/information_schema/columns.rs
@@ -365,10 +365,6 @@ impl InformationSchemaColumnsBuilder {
            self.numeric_scales.push(None);

            match &column_schema.data_type {
-                ConcreteDataType::DateTime(datetime_type) => {
-                    self.datetime_precisions
-                        .push(Some(datetime_type.precision() as i64));
-                }
                ConcreteDataType::Timestamp(ts_type) => {
                    self.datetime_precisions
                        .push(Some(ts_type.precision() as i64));
--- a/src/catalog/src/system_schema/information_schema/flows.rs
+++ b/src/catalog/src/system_schema/information_schema/flows.rs
@@ -28,16 +28,19 @@ use datafusion::physical_plan::streaming::PartitionStream as DfPartitionStream;
 use datatypes::prelude::ConcreteDataType as CDT;
 use datatypes::scalars::ScalarVectorBuilder;
 use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
+use datatypes::timestamp::TimestampMillisecond;
 use datatypes::value::Value;
 use datatypes::vectors::{
-    Int64VectorBuilder, StringVectorBuilder, UInt32VectorBuilder, UInt64VectorBuilder, VectorRef,
+    Int64VectorBuilder, StringVectorBuilder, TimestampMillisecondVectorBuilder,
+    UInt32VectorBuilder, UInt64VectorBuilder, VectorRef,
 };
 use futures::TryStreamExt;
 use snafu::{OptionExt, ResultExt};
 use store_api::storage::{ScanRequest, TableId};

 use crate::error::{
-    CreateRecordBatchSnafu, FlowInfoNotFoundSnafu, InternalSnafu, JsonSnafu, ListFlowsSnafu, Result,
+    CreateRecordBatchSnafu, FlowInfoNotFoundSnafu, InternalSnafu, JsonSnafu, ListFlowsSnafu,
+    Result, UpgradeWeakCatalogManagerRefSnafu,
 };
 use crate::information_schema::{Predicates, FLOWS};
 use crate::system_schema::information_schema::InformationTable;
@@ -59,6 +62,10 @@ pub const SOURCE_TABLE_IDS: &str = "source_table_ids";
 pub const SINK_TABLE_NAME: &str = "sink_table_name";
 pub const FLOWNODE_IDS: &str = "flownode_ids";
 pub const OPTIONS: &str = "options";
+pub const CREATED_TIME: &str = "created_time";
+pub const UPDATED_TIME: &str = "updated_time";
+pub const LAST_EXECUTION_TIME: &str = "last_execution_time";
+pub const SOURCE_TABLE_NAMES: &str = "source_table_names";

 /// The `information_schema.flows` to provides information about flows in databases.
 #[derive(Debug)]
@@ -99,6 +106,14 @@ impl InformationSchemaFlows {
                (SINK_TABLE_NAME, CDT::string_datatype(), false),
                (FLOWNODE_IDS, CDT::string_datatype(), true),
                (OPTIONS, CDT::string_datatype(), true),
+                (CREATED_TIME, CDT::timestamp_millisecond_datatype(), false),
+                (UPDATED_TIME, CDT::timestamp_millisecond_datatype(), false),
+                (
+                    LAST_EXECUTION_TIME,
+                    CDT::timestamp_millisecond_datatype(),
+                    true,
+                ),
+                (SOURCE_TABLE_NAMES, CDT::string_datatype(), true),
            ]
            .into_iter()
            .map(|(name, ty, nullable)| ColumnSchema::new(name, ty, nullable))
@@ -170,6 +185,10 @@ struct InformationSchemaFlowsBuilder {
    sink_table_names: StringVectorBuilder,
    flownode_id_groups: StringVectorBuilder,
    option_groups: StringVectorBuilder,
+    created_time: TimestampMillisecondVectorBuilder,
+    updated_time: TimestampMillisecondVectorBuilder,
+    last_execution_time: TimestampMillisecondVectorBuilder,
+    source_table_names: StringVectorBuilder,
 }

 impl InformationSchemaFlowsBuilder {
@@ -196,6 +215,10 @@ impl InformationSchemaFlowsBuilder {
            sink_table_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
            flownode_id_groups: StringVectorBuilder::with_capacity(INIT_CAPACITY),
            option_groups: StringVectorBuilder::with_capacity(INIT_CAPACITY),
+            created_time: TimestampMillisecondVectorBuilder::with_capacity(INIT_CAPACITY),
+            updated_time: TimestampMillisecondVectorBuilder::with_capacity(INIT_CAPACITY),
+            last_execution_time: TimestampMillisecondVectorBuilder::with_capacity(INIT_CAPACITY),
+            source_table_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
        }
    }

@@ -235,13 +258,14 @@ impl InformationSchemaFlowsBuilder {
                    catalog_name: catalog_name.to_string(),
                    flow_name: flow_name.to_string(),
                })?;
-            self.add_flow(&predicates, flow_id.flow_id(), flow_info, &flow_stat)?;
+            self.add_flow(&predicates, flow_id.flow_id(), flow_info, &flow_stat)
+                .await?;
        }

        self.finish()
    }

-    fn add_flow(
+    async fn add_flow(
        &mut self,
        predicates: &Predicates,
        flow_id: FlowId,
@@ -290,6 +314,36 @@ impl InformationSchemaFlowsBuilder {
                    input: format!("{:?}", flow_info.options()),
                },
            )?));
+        self.created_time
+            .push(Some(flow_info.created_time().timestamp_millis().into()));
+        self.updated_time
+            .push(Some(flow_info.updated_time().timestamp_millis().into()));
+        self.last_execution_time
+            .push(flow_stat.as_ref().and_then(|state| {
+                state
+                    .last_exec_time_map
+                    .get(&flow_id)
+                    .map(|v| TimestampMillisecond::new(*v))
+            }));
+
+        let mut source_table_names = vec![];
+        let catalog_name = self.catalog_name.clone();
+        let catalog_manager = self
+            .catalog_manager
+            .upgrade()
+            .context(UpgradeWeakCatalogManagerRefSnafu)?;
+        for schema_name in catalog_manager.schema_names(&catalog_name, None).await? {
+            source_table_names.extend(
+                catalog_manager
+                    .tables_by_ids(&catalog_name, &schema_name, flow_info.source_table_ids())
+                    .await?
+                    .into_iter()
+                    .map(|table| table.table_info().full_table_name()),
+            );
+        }
+
+        let source_table_names = source_table_names.join(",");
+        self.source_table_names.push(Some(&source_table_names));

        Ok(())
    }
@@ -307,6 +361,10 @@ impl InformationSchemaFlowsBuilder {
            Arc::new(self.sink_table_names.finish()),
            Arc::new(self.flownode_id_groups.finish()),
            Arc::new(self.option_groups.finish()),
+            Arc::new(self.created_time.finish()),
+            Arc::new(self.updated_time.finish()),
+            Arc::new(self.last_execution_time.finish()),
+            Arc::new(self.source_table_names.finish()),
        ];
        RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
    }
--- a/src/catalog/src/system_schema/information_schema/information_memory_table.rs
+++ b/src/catalog/src/system_schema/information_schema/information_memory_table.rs
@@ -20,7 +20,7 @@ use datatypes::vectors::{Int64Vector, StringVector, VectorRef};

 use super::table_names::*;
 use crate::system_schema::utils::tables::{
-    bigint_column, datetime_column, string_column, string_columns,
+    bigint_column, string_column, string_columns, timestamp_micro_column,
 };

 const NO_VALUE: &str = "NO";
@@ -163,17 +163,17 @@ pub(super) fn get_schema_columns(table_name: &str) -> (SchemaRef, Vec<VectorRef>
                string_column("EVENT_BODY"),
                string_column("EVENT_DEFINITION"),
                string_column("EVENT_TYPE"),
-                datetime_column("EXECUTE_AT"),
+                timestamp_micro_column("EXECUTE_AT"),
                bigint_column("INTERVAL_VALUE"),
                string_column("INTERVAL_FIELD"),
                string_column("SQL_MODE"),
-                datetime_column("STARTS"),
-                datetime_column("ENDS"),
+                timestamp_micro_column("STARTS"),
+                timestamp_micro_column("ENDS"),
                string_column("STATUS"),
                string_column("ON_COMPLETION"),
-                datetime_column("CREATED"),
-                datetime_column("LAST_ALTERED"),
-                datetime_column("LAST_EXECUTED"),
+                timestamp_micro_column("CREATED"),
+                timestamp_micro_column("LAST_ALTERED"),
+                timestamp_micro_column("LAST_EXECUTED"),
                string_column("EVENT_COMMENT"),
                bigint_column("ORIGINATOR"),
                string_column("CHARACTER_SET_CLIENT"),
@@ -204,10 +204,10 @@ pub(super) fn get_schema_columns(table_name: &str) -> (SchemaRef, Vec<VectorRef>
                bigint_column("INITIAL_SIZE"),
                bigint_column("MAXIMUM_SIZE"),
                bigint_column("AUTOEXTEND_SIZE"),
-                datetime_column("CREATION_TIME"),
-                datetime_column("LAST_UPDATE_TIME"),
-                datetime_column("LAST_ACCESS_TIME"),
-                datetime_column("RECOVER_TIME"),
+                timestamp_micro_column("CREATION_TIME"),
+                timestamp_micro_column("LAST_UPDATE_TIME"),
+                timestamp_micro_column("LAST_ACCESS_TIME"),
+                timestamp_micro_column("RECOVER_TIME"),
                bigint_column("TRANSACTION_COUNTER"),
                string_column("VERSION"),
                string_column("ROW_FORMAT"),
@@ -217,9 +217,9 @@ pub(super) fn get_schema_columns(table_name: &str) -> (SchemaRef, Vec<VectorRef>
                bigint_column("MAX_DATA_LENGTH"),
                bigint_column("INDEX_LENGTH"),
                bigint_column("DATA_FREE"),
-                datetime_column("CREATE_TIME"),
-                datetime_column("UPDATE_TIME"),
-                datetime_column("CHECK_TIME"),
+                timestamp_micro_column("CREATE_TIME"),
+                timestamp_micro_column("UPDATE_TIME"),
+                timestamp_micro_column("CHECK_TIME"),
                string_column("CHECKSUM"),
                string_column("STATUS"),
                string_column("EXTRA"),
@@ -330,8 +330,8 @@ pub(super) fn get_schema_columns(table_name: &str) -> (SchemaRef, Vec<VectorRef>
                string_column("SQL_DATA_ACCESS"),
                string_column("SQL_PATH"),
                string_column("SECURITY_TYPE"),
-                datetime_column("CREATED"),
-                datetime_column("LAST_ALTERED"),
+                timestamp_micro_column("CREATED"),
+                timestamp_micro_column("LAST_ALTERED"),
                string_column("SQL_MODE"),
                string_column("ROUTINE_COMMENT"),
                string_column("DEFINER"),
@@ -383,7 +383,7 @@ pub(super) fn get_schema_columns(table_name: &str) -> (SchemaRef, Vec<VectorRef>
                string_column("ACTION_REFERENCE_NEW_TABLE"),
                string_column("ACTION_REFERENCE_OLD_ROW"),
                string_column("ACTION_REFERENCE_NEW_ROW"),
-                datetime_column("CREATED"),
+                timestamp_micro_column("CREATED"),
                string_column("SQL_MODE"),
                string_column("DEFINER"),
                string_column("CHARACTER_SET_CLIENT"),
--- a/src/catalog/src/system_schema/information_schema/partitions.rs
+++ b/src/catalog/src/system_schema/information_schema/partitions.rs
@@ -20,17 +20,18 @@ use common_catalog::consts::INFORMATION_SCHEMA_PARTITIONS_TABLE_ID;
 use common_error::ext::BoxedError;
 use common_recordbatch::adapter::RecordBatchStreamAdapter;
 use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
-use common_time::datetime::DateTime;
 use datafusion::execution::TaskContext;
 use datafusion::physical_plan::stream::RecordBatchStreamAdapter as DfRecordBatchStreamAdapter;
 use datafusion::physical_plan::streaming::PartitionStream as DfPartitionStream;
 use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatchStream;
 use datatypes::prelude::{ConcreteDataType, ScalarVectorBuilder, VectorRef};
 use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
+use datatypes::timestamp::TimestampMicrosecond;
 use datatypes::value::Value;
 use datatypes::vectors::{
-    ConstantVector, DateTimeVector, DateTimeVectorBuilder, Int64Vector, Int64VectorBuilder,
-    MutableVector, StringVector, StringVectorBuilder, UInt64VectorBuilder,
+    ConstantVector, Int64Vector, Int64VectorBuilder, MutableVector, StringVector,
+    StringVectorBuilder, TimestampMicrosecondVector, TimestampMicrosecondVectorBuilder,
+    UInt64VectorBuilder,
 };
 use futures::{StreamExt, TryStreamExt};
 use partition::manager::PartitionInfo;
@@ -127,9 +128,21 @@ impl InformationSchemaPartitions {
            ColumnSchema::new("max_data_length", ConcreteDataType::int64_datatype(), true),
            ColumnSchema::new("index_length", ConcreteDataType::int64_datatype(), true),
            ColumnSchema::new("data_free", ConcreteDataType::int64_datatype(), true),
-            ColumnSchema::new("create_time", ConcreteDataType::datetime_datatype(), true),
-            ColumnSchema::new("update_time", ConcreteDataType::datetime_datatype(), true),
-            ColumnSchema::new("check_time", ConcreteDataType::datetime_datatype(), true),
+            ColumnSchema::new(
+                "create_time",
+                ConcreteDataType::timestamp_microsecond_datatype(),
+                true,
+            ),
+            ColumnSchema::new(
+                "update_time",
+                ConcreteDataType::timestamp_microsecond_datatype(),
+                true,
+            ),
+            ColumnSchema::new(
+                "check_time",
+                ConcreteDataType::timestamp_microsecond_datatype(),
+                true,
+            ),
            ColumnSchema::new("checksum", ConcreteDataType::int64_datatype(), true),
            ColumnSchema::new(
                "partition_comment",
@@ -200,7 +213,7 @@ struct InformationSchemaPartitionsBuilder {
    partition_names: StringVectorBuilder,
    partition_ordinal_positions: Int64VectorBuilder,
    partition_expressions: StringVectorBuilder,
-    create_times: DateTimeVectorBuilder,
+    create_times: TimestampMicrosecondVectorBuilder,
    partition_ids: UInt64VectorBuilder,
 }

@@ -220,7 +233,7 @@ impl InformationSchemaPartitionsBuilder {
            partition_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
            partition_ordinal_positions: Int64VectorBuilder::with_capacity(INIT_CAPACITY),
            partition_expressions: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            create_times: DateTimeVectorBuilder::with_capacity(INIT_CAPACITY),
+            create_times: TimestampMicrosecondVectorBuilder::with_capacity(INIT_CAPACITY),
            partition_ids: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
        }
    }
@@ -324,7 +337,7 @@ impl InformationSchemaPartitionsBuilder {
            };

            self.partition_expressions.push(expressions.as_deref());
-            self.create_times.push(Some(DateTime::from(
+            self.create_times.push(Some(TimestampMicrosecond::from(
                table_info.meta.created_on.timestamp_millis(),
            )));
            self.partition_ids.push(Some(partition.id.as_u64()));
@@ -342,8 +355,8 @@ impl InformationSchemaPartitionsBuilder {
            Arc::new(Int64Vector::from(vec![None])),
            rows_num,
        ));
-        let null_datetime_vector = Arc::new(ConstantVector::new(
-            Arc::new(DateTimeVector::from(vec![None])),
+        let null_timestampmicrosecond_vector = Arc::new(ConstantVector::new(
+            Arc::new(TimestampMicrosecondVector::from(vec![None])),
            rows_num,
        ));
        let partition_methods = Arc::new(ConstantVector::new(
@@ -373,8 +386,8 @@ impl InformationSchemaPartitionsBuilder {
            null_i64_vector.clone(),
            Arc::new(self.create_times.finish()),
            // TODO(dennis): supports update_time
-            null_datetime_vector.clone(),
-            null_datetime_vector,
+            null_timestampmicrosecond_vector.clone(),
+            null_timestampmicrosecond_vector,
            null_i64_vector,
            null_string_vector.clone(),
            null_string_vector.clone(),
--- a/src/catalog/src/system_schema/information_schema/tables.rs
+++ b/src/catalog/src/system_schema/information_schema/tables.rs
@@ -30,7 +30,8 @@ use datatypes::prelude::{ConcreteDataType, ScalarVectorBuilder, VectorRef};
 use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
 use datatypes::value::Value;
 use datatypes::vectors::{
-    DateTimeVectorBuilder, StringVectorBuilder, UInt32VectorBuilder, UInt64VectorBuilder,
+    StringVectorBuilder, TimestampMicrosecondVectorBuilder, UInt32VectorBuilder,
+    UInt64VectorBuilder,
 };
 use futures::TryStreamExt;
 use snafu::{OptionExt, ResultExt};
@@ -105,9 +106,21 @@ impl InformationSchemaTables {
            ColumnSchema::new(TABLE_ROWS, ConcreteDataType::uint64_datatype(), true),
            ColumnSchema::new(DATA_FREE, ConcreteDataType::uint64_datatype(), true),
            ColumnSchema::new(AUTO_INCREMENT, ConcreteDataType::uint64_datatype(), true),
-            ColumnSchema::new(CREATE_TIME, ConcreteDataType::datetime_datatype(), true),
-            ColumnSchema::new(UPDATE_TIME, ConcreteDataType::datetime_datatype(), true),
-            ColumnSchema::new(CHECK_TIME, ConcreteDataType::datetime_datatype(), true),
+            ColumnSchema::new(
+                CREATE_TIME,
+                ConcreteDataType::timestamp_microsecond_datatype(),
+                true,
+            ),
+            ColumnSchema::new(
+                UPDATE_TIME,
+                ConcreteDataType::timestamp_microsecond_datatype(),
+                true,
+            ),
+            ColumnSchema::new(
+                CHECK_TIME,
+                ConcreteDataType::timestamp_microsecond_datatype(),
+                true,
+            ),
            ColumnSchema::new(TABLE_COLLATION, ConcreteDataType::string_datatype(), true),
            ColumnSchema::new(CHECKSUM, ConcreteDataType::uint64_datatype(), true),
            ColumnSchema::new(CREATE_OPTIONS, ConcreteDataType::string_datatype(), true),
@@ -182,9 +195,9 @@ struct InformationSchemaTablesBuilder {
    max_index_length: UInt64VectorBuilder,
    data_free: UInt64VectorBuilder,
    auto_increment: UInt64VectorBuilder,
-    create_time: DateTimeVectorBuilder,
-    update_time: DateTimeVectorBuilder,
-    check_time: DateTimeVectorBuilder,
+    create_time: TimestampMicrosecondVectorBuilder,
+    update_time: TimestampMicrosecondVectorBuilder,
+    check_time: TimestampMicrosecondVectorBuilder,
    table_collation: StringVectorBuilder,
    checksum: UInt64VectorBuilder,
    create_options: StringVectorBuilder,
@@ -219,9 +232,9 @@ impl InformationSchemaTablesBuilder {
            max_index_length: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
            data_free: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
            auto_increment: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
-            create_time: DateTimeVectorBuilder::with_capacity(INIT_CAPACITY),
-            update_time: DateTimeVectorBuilder::with_capacity(INIT_CAPACITY),
-            check_time: DateTimeVectorBuilder::with_capacity(INIT_CAPACITY),
+            create_time: TimestampMicrosecondVectorBuilder::with_capacity(INIT_CAPACITY),
+            update_time: TimestampMicrosecondVectorBuilder::with_capacity(INIT_CAPACITY),
+            check_time: TimestampMicrosecondVectorBuilder::with_capacity(INIT_CAPACITY),
            table_collation: StringVectorBuilder::with_capacity(INIT_CAPACITY),
            checksum: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
            create_options: StringVectorBuilder::with_capacity(INIT_CAPACITY),
--- a/src/catalog/src/system_schema/utils/tables.rs
+++ b/src/catalog/src/system_schema/utils/tables.rs
@@ -51,10 +51,10 @@ pub fn bigint_column(name: &str) -> ColumnSchema {
    )
 }

-pub fn datetime_column(name: &str) -> ColumnSchema {
+pub fn timestamp_micro_column(name: &str) -> ColumnSchema {
    ColumnSchema::new(
        str::to_lowercase(name),
-        ConcreteDataType::datetime_datatype(),
+        ConcreteDataType::timestamp_microsecond_datatype(),
        false,
    )
 }
--- a/src/cli/Cargo.toml
+++ b/src/cli/Cargo.toml
@@ -6,6 +6,7 @@ license.workspace = true

 [features]
 pg_kvbackend = ["common-meta/pg_kvbackend"]
+mysql_kvbackend = ["common-meta/mysql_kvbackend"]

 [lints]
 workspace = true
@@ -43,6 +44,10 @@ futures.workspace = true
 humantime.workspace = true
 meta-client.workspace = true
 nu-ansi-term = "0.46"
+opendal = { version = "0.51.1", features = [
+    "services-fs",
+    "services-s3",
+] }
 query.workspace = true
 rand.workspace = true
 reqwest.workspace = true
--- a/src/cli/src/bench.rs
+++ b/src/cli/src/bench.rs
@@ -23,6 +23,8 @@ use common_error::ext::BoxedError;
 use common_meta::key::{TableMetadataManager, TableMetadataManagerRef};
 use common_meta::kv_backend::etcd::EtcdStore;
 use common_meta::kv_backend::memory::MemoryKvBackend;
+#[cfg(feature = "mysql_kvbackend")]
+use common_meta::kv_backend::rds::MySqlStore;
 #[cfg(feature = "pg_kvbackend")]
 use common_meta::kv_backend::rds::PgStore;
 use common_meta::peer::Peer;
@@ -63,6 +65,9 @@ pub struct BenchTableMetadataCommand {
    #[cfg(feature = "pg_kvbackend")]
    #[clap(long)]
    postgres_addr: Option<String>,
+    #[cfg(feature = "mysql_kvbackend")]
+    #[clap(long)]
+    mysql_addr: Option<String>,
    #[clap(long)]
    count: u32,
 }
@@ -86,6 +91,16 @@ impl BenchTableMetadataCommand {
            kv_backend
        };

+        #[cfg(feature = "mysql_kvbackend")]
+        let kv_backend = if let Some(mysql_addr) = &self.mysql_addr {
+            info!("Using mysql as kv backend");
+            MySqlStore::with_url(mysql_addr, "greptime_metakv", 128)
+                .await
+                .unwrap()
+        } else {
+            kv_backend
+        };
+
        let table_metadata_manager = Arc::new(TableMetadataManager::new(kv_backend));

        let tool = BenchTableMetadata {
--- a/src/cli/src/error.rs
+++ b/src/cli/src/error.rs
@@ -276,6 +276,24 @@ pub enum Error {
        #[snafu(implicit)]
        location: Location,
    },
+
+    #[snafu(display("OpenDAL operator failed"))]
+    OpenDal {
+        #[snafu(implicit)]
+        location: Location,
+        #[snafu(source)]
+        error: opendal::Error,
+    },
+    #[snafu(display("S3 config need be set"))]
+    S3ConfigNotSet {
+        #[snafu(implicit)]
+        location: Location,
+    },
+    #[snafu(display("Output directory not set"))]
+    OutputDirNotSet {
+        #[snafu(implicit)]
+        location: Location,
+    },
 }

 pub type Result<T> = std::result::Result<T, Error>;
@@ -319,6 +337,9 @@ impl ErrorExt for Error {
            | Error::BuildClient { .. } => StatusCode::Unexpected,

            Error::Other { source, .. } => source.status_code(),
+            Error::OpenDal { .. } => StatusCode::Internal,
+            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,15 +21,18 @@ use async_trait::async_trait;
 use clap::{Parser, ValueEnum};
 use common_error::ext::BoxedError;
 use common_telemetry::{debug, error, info};
+use opendal::layers::LoggingLayer;
+use opendal::{services, Operator};
 use serde_json::Value;
 use snafu::{OptionExt, ResultExt};
-use tokio::fs::File;
-use tokio::io::{AsyncWriteExt, BufWriter};
 use tokio::sync::Semaphore;
 use tokio::time::Instant;

 use crate::database::{parse_proxy_opts, DatabaseClient};
-use crate::error::{EmptyResultSnafu, Error, FileIoSnafu, Result, SchemaNotFoundSnafu};
+use crate::error::{
+    EmptyResultSnafu, Error, OpenDalSnafu, OutputDirNotSetSnafu, Result, S3ConfigNotSetSnafu,
+    SchemaNotFoundSnafu,
+};
 use crate::{database, Tool};

 type TableReference = (String, String, String);
@@ -52,8 +55,9 @@ pub struct ExportCommand {
    addr: String,

    /// Directory to put the exported data. E.g.: /tmp/greptimedb-export
+    /// for local export.
    #[clap(long)]
-    output_dir: String,
+    output_dir: Option<String>,

    /// The name of the catalog to export.
    #[clap(long, default_value = "greptime-*")]
@@ -101,10 +105,51 @@ pub struct ExportCommand {
    /// Disable proxy server, if set, will not use any proxy.
    #[clap(long)]
    no_proxy: bool,
+
+    /// if export data to s3
+    #[clap(long)]
+    s3: bool,
+
+    /// The s3 bucket name
+    /// if s3 is set, this is required
+    #[clap(long)]
+    s3_bucket: Option<String>,
+
+    /// The s3 endpoint
+    /// if s3 is set, this is required
+    #[clap(long)]
+    s3_endpoint: Option<String>,
+
+    /// The s3 access key
+    /// if s3 is set, this is required
+    #[clap(long)]
+    s3_access_key: Option<String>,
+
+    /// The s3 secret key
+    /// if s3 is set, this is required
+    #[clap(long)]
+    s3_secret_key: Option<String>,
+
+    /// The s3 region
+    /// if s3 is set, this is required
+    #[clap(long)]
+    s3_region: Option<String>,
 }

 impl ExportCommand {
    pub async fn build(&self) -> std::result::Result<Box<dyn Tool>, BoxedError> {
+        if self.s3
+            && (self.s3_bucket.is_none()
+                || self.s3_endpoint.is_none()
+                || self.s3_access_key.is_none()
+                || self.s3_secret_key.is_none()
+                || self.s3_region.is_none())
+        {
+            return Err(BoxedError::new(S3ConfigNotSetSnafu {}.build()));
+        }
+        if !self.s3 && self.output_dir.is_none() {
+            return Err(BoxedError::new(OutputDirNotSetSnafu {}.build()));
+        }
        let (catalog, schema) =
            database::split_database(&self.database).map_err(BoxedError::new)?;
        let proxy = parse_proxy_opts(self.proxy.clone(), self.no_proxy)?;
@@ -126,24 +171,43 @@ impl ExportCommand {
            target: self.target.clone(),
            start_time: self.start_time.clone(),
            end_time: self.end_time.clone(),
+            s3: self.s3,
+            s3_bucket: self.s3_bucket.clone(),
+            s3_endpoint: self.s3_endpoint.clone(),
+            s3_access_key: self.s3_access_key.clone(),
+            s3_secret_key: self.s3_secret_key.clone(),
+            s3_region: self.s3_region.clone(),
        }))
    }
 }

+#[derive(Clone)]
 pub struct Export {
    catalog: String,
    schema: Option<String>,
    database_client: DatabaseClient,
-    output_dir: String,
+    output_dir: Option<String>,
    parallelism: usize,
    target: ExportTarget,
    start_time: Option<String>,
    end_time: Option<String>,
+    s3: bool,
+    s3_bucket: Option<String>,
+    s3_endpoint: Option<String>,
+    s3_access_key: Option<String>,
+    s3_secret_key: Option<String>,
+    s3_region: Option<String>,
 }

 impl Export {
    fn catalog_path(&self) -> PathBuf {
-        PathBuf::from(&self.output_dir).join(&self.catalog)
+        if self.s3 {
+            PathBuf::from(&self.catalog)
+        } else if let Some(dir) = &self.output_dir {
+            PathBuf::from(dir).join(&self.catalog)
+        } else {
+            unreachable!("catalog_path: output_dir must be set when not using s3")
+        }
    }

    async fn get_db_names(&self) -> Result<Vec<String>> {
@@ -300,19 +364,23 @@ impl Export {
        let timer = Instant::now();
        let db_names = self.get_db_names().await?;
        let db_count = db_names.len();
+        let operator = self.build_operator().await?;
+
        for schema in db_names {
-            let db_dir = self.catalog_path().join(format!("{schema}/"));
-            tokio::fs::create_dir_all(&db_dir)
-                .await
-                .context(FileIoSnafu)?;
-            let file = db_dir.join("create_database.sql");
-            let mut file = File::create(file).await.context(FileIoSnafu)?;
            let create_database = self
                .show_create("DATABASE", &self.catalog, &schema, None)
                .await?;
-            file.write_all(create_database.as_bytes())
-                .await
-                .context(FileIoSnafu)?;
+
+            let file_path = self.get_file_path(&schema, "create_database.sql");
+            self.write_to_storage(&operator, &file_path, create_database.into_bytes())
+                .await?;
+
+            info!(
+                "Exported {}.{} database creation SQL to {}",
+                self.catalog,
+                schema,
+                self.format_output_path(&file_path)
+            );
        }

        let elapsed = timer.elapsed();
@@ -326,149 +394,267 @@ impl Export {
        let semaphore = Arc::new(Semaphore::new(self.parallelism));
        let db_names = self.get_db_names().await?;
        let db_count = db_names.len();
+        let operator = Arc::new(self.build_operator().await?);
        let mut tasks = Vec::with_capacity(db_names.len());
+
        for schema in db_names {
            let semaphore_moved = semaphore.clone();
+            let export_self = self.clone();
+            let operator = operator.clone();
            tasks.push(async move {
                let _permit = semaphore_moved.acquire().await.unwrap();
-                let (metric_physical_tables, remaining_tables, views) =
-                    self.get_table_list(&self.catalog, &schema).await?;
-                let table_count =
-                    metric_physical_tables.len() + remaining_tables.len() + views.len();
-                let db_dir = self.catalog_path().join(format!("{schema}/"));
-                tokio::fs::create_dir_all(&db_dir)
-                    .await
-                    .context(FileIoSnafu)?;
-                let file = db_dir.join("create_tables.sql");
-                let mut file = File::create(file).await.context(FileIoSnafu)?;
-                for (c, s, t) in metric_physical_tables.into_iter().chain(remaining_tables) {
-                    let create_table = self.show_create("TABLE", &c, &s, Some(&t)).await?;
-                    file.write_all(create_table.as_bytes())
-                        .await
-                        .context(FileIoSnafu)?;
-                }
-                for (c, s, v) in views {
-                    let create_view = self.show_create("VIEW", &c, &s, Some(&v)).await?;
-                    file.write_all(create_view.as_bytes())
-                        .await
-                        .context(FileIoSnafu)?;
+                let (metric_physical_tables, remaining_tables, views) = export_self
+                    .get_table_list(&export_self.catalog, &schema)
+                    .await?;
+
+                // Create directory if needed for file system storage
+                if !export_self.s3 {
+                    let db_dir = format!("{}/{}/", export_self.catalog, schema);
+                    operator.create_dir(&db_dir).await.context(OpenDalSnafu)?;
                }

+                let file_path = export_self.get_file_path(&schema, "create_tables.sql");
+                let mut content = Vec::new();
+
+                // Add table creation SQL
+                for (c, s, t) in metric_physical_tables.iter().chain(&remaining_tables) {
+                    let create_table = export_self.show_create("TABLE", c, s, Some(t)).await?;
+                    content.extend_from_slice(create_table.as_bytes());
+                }
+
+                // Add view creation SQL
+                for (c, s, v) in &views {
+                    let create_view = export_self.show_create("VIEW", c, s, Some(v)).await?;
+                    content.extend_from_slice(create_view.as_bytes());
+                }
+
+                // Write to storage
+                export_self
+                    .write_to_storage(&operator, &file_path, content)
+                    .await?;
+
                info!(
-                    "Finished exporting {}.{schema} with {table_count} table schemas to path: {}",
-                    self.catalog,
-                    db_dir.to_string_lossy()
+                    "Finished exporting {}.{schema} with {} table schemas to path: {}",
+                    export_self.catalog,
+                    metric_physical_tables.len() + remaining_tables.len() + views.len(),
+                    export_self.format_output_path(&file_path)
                );

                Ok::<(), Error>(())
            });
        }

-        let success = futures::future::join_all(tasks)
-            .await
-            .into_iter()
-            .filter(|r| match r {
-                Ok(_) => true,
-                Err(e) => {
-                    error!(e; "export schema job failed");
-                    false
-                }
-            })
-            .count();
-
+        let success = self.execute_tasks(tasks).await;
        let elapsed = timer.elapsed();
        info!("Success {success}/{db_count} jobs, cost: {elapsed:?}");

        Ok(())
    }

+    async fn build_operator(&self) -> Result<Operator> {
+        if self.s3 {
+            self.build_s3_operator().await
+        } else {
+            self.build_fs_operator().await
+        }
+    }
+
+    async fn build_s3_operator(&self) -> Result<Operator> {
+        let mut builder = services::S3::default().root("").bucket(
+            self.s3_bucket
+                .as_ref()
+                .expect("s3_bucket must be provided when s3 is enabled"),
+        );
+
+        if let Some(endpoint) = self.s3_endpoint.as_ref() {
+            builder = builder.endpoint(endpoint);
+        }
+
+        if let Some(region) = self.s3_region.as_ref() {
+            builder = builder.region(region);
+        }
+
+        if let Some(key_id) = self.s3_access_key.as_ref() {
+            builder = builder.access_key_id(key_id);
+        }
+
+        if let Some(secret_key) = self.s3_secret_key.as_ref() {
+            builder = builder.secret_access_key(secret_key);
+        }
+
+        let op = Operator::new(builder)
+            .context(OpenDalSnafu)?
+            .layer(LoggingLayer::default())
+            .finish();
+        Ok(op)
+    }
+
+    async fn build_fs_operator(&self) -> Result<Operator> {
+        let root = self
+            .output_dir
+            .as_ref()
+            .context(OutputDirNotSetSnafu)?
+            .clone();
+        let op = Operator::new(services::Fs::default().root(&root))
+            .context(OpenDalSnafu)?
+            .layer(LoggingLayer::default())
+            .finish();
+        Ok(op)
+    }
+
    async fn export_database_data(&self) -> Result<()> {
        let timer = Instant::now();
        let semaphore = Arc::new(Semaphore::new(self.parallelism));
        let db_names = self.get_db_names().await?;
        let db_count = db_names.len();
        let mut tasks = Vec::with_capacity(db_count);
+        let operator = Arc::new(self.build_operator().await?);
+        let with_options = build_with_options(&self.start_time, &self.end_time);
+
        for schema in db_names {
            let semaphore_moved = semaphore.clone();
+            let export_self = self.clone();
+            let with_options_clone = with_options.clone();
+            let operator = operator.clone();
+
            tasks.push(async move {
                let _permit = semaphore_moved.acquire().await.unwrap();
-                let db_dir = self.catalog_path().join(format!("{schema}/"));
-                tokio::fs::create_dir_all(&db_dir)
-                    .await
-                    .context(FileIoSnafu)?;

-                let with_options = match (&self.start_time, &self.end_time) {
-                    (Some(start_time), Some(end_time)) => {
-                        format!(
-                            "WITH (FORMAT='parquet', start_time='{}', end_time='{}')",
-                            start_time, end_time
-                        )
-                    }
-                    (Some(start_time), None) => {
-                        format!("WITH (FORMAT='parquet', start_time='{}')", start_time)
-                    }
-                    (None, Some(end_time)) => {
-                        format!("WITH (FORMAT='parquet', end_time='{}')", end_time)
-                    }
-                    (None, None) => "WITH (FORMAT='parquet')".to_string(),
-                };
+                // Create directory if not using S3
+                if !export_self.s3 {
+                    let db_dir = format!("{}/{}/", export_self.catalog, schema);
+                    operator.create_dir(&db_dir).await.context(OpenDalSnafu)?;
+                }

+                let (path, connection_part) = export_self.get_storage_params(&schema);
+
+                // Execute COPY DATABASE TO command
                let sql = format!(
-                    r#"COPY DATABASE "{}"."{}" TO '{}' {};"#,
-                    self.catalog,
-                    schema,
-                    db_dir.to_str().unwrap(),
-                    with_options
+                    r#"COPY DATABASE "{}"."{}" TO '{}' WITH ({}){};"#,
+                    export_self.catalog, schema, path, with_options_clone, connection_part
+                );
+                info!("Executing sql: {sql}");
+                export_self.database_client.sql_in_public(&sql).await?;
+                info!(
+                    "Finished exporting {}.{} data to {}",
+                    export_self.catalog, schema, path
                );

-                info!("Executing sql: {sql}");
+                // Create copy_from.sql file
+                let copy_database_from_sql = format!(
+                    r#"COPY DATABASE "{}"."{}" FROM '{}' WITH ({}){};"#,
+                    export_self.catalog, schema, path, with_options_clone, connection_part
+                );

-                self.database_client.sql_in_public(&sql).await?;
+                let copy_from_path = export_self.get_file_path(&schema, "copy_from.sql");
+                export_self
+                    .write_to_storage(
+                        &operator,
+                        &copy_from_path,
+                        copy_database_from_sql.into_bytes(),
+                    )
+                    .await?;

                info!(
-                    "Finished exporting {}.{schema} data into path: {}",
-                    self.catalog,
-                    db_dir.to_string_lossy()
-                );
-
-                // The export copy from sql
-                let copy_from_file = db_dir.join("copy_from.sql");
-                let mut writer =
-                    BufWriter::new(File::create(copy_from_file).await.context(FileIoSnafu)?);
-                let copy_database_from_sql = format!(
-                    r#"COPY DATABASE "{}"."{}" FROM '{}' WITH (FORMAT='parquet');"#,
-                    self.catalog,
+                    "Finished exporting {}.{} copy_from.sql to {}",
+                    export_self.catalog,
                    schema,
-                    db_dir.to_str().unwrap()
+                    export_self.format_output_path(&copy_from_path)
                );
-                writer
-                    .write(copy_database_from_sql.as_bytes())
-                    .await
-                    .context(FileIoSnafu)?;
-                writer.flush().await.context(FileIoSnafu)?;
-
-                info!("Finished exporting {}.{schema} copy_from.sql", self.catalog);

                Ok::<(), Error>(())
-            })
+            });
        }

-        let success = futures::future::join_all(tasks)
+        let success = self.execute_tasks(tasks).await;
+        let elapsed = timer.elapsed();
+        info!("Success {success}/{db_count} jobs, costs: {elapsed:?}");
+
+        Ok(())
+    }
+
+    fn get_file_path(&self, schema: &str, file_name: &str) -> String {
+        format!("{}/{}/{}", self.catalog, schema, file_name)
+    }
+
+    fn format_output_path(&self, file_path: &str) -> String {
+        if self.s3 {
+            format!(
+                "s3://{}/{}",
+                self.s3_bucket.as_ref().unwrap_or(&String::new()),
+                file_path
+            )
+        } else {
+            format!(
+                "{}/{}",
+                self.output_dir.as_ref().unwrap_or(&String::new()),
+                file_path
+            )
+        }
+    }
+
+    async fn write_to_storage(
+        &self,
+        op: &Operator,
+        file_path: &str,
+        content: Vec<u8>,
+    ) -> Result<()> {
+        op.write(file_path, content).await.context(OpenDalSnafu)
+    }
+
+    fn get_storage_params(&self, schema: &str) -> (String, String) {
+        if self.s3 {
+            let s3_path = format!(
+                "s3://{}/{}/{}/",
+                // Safety: s3_bucket is required when s3 is enabled
+                self.s3_bucket.as_ref().unwrap(),
+                self.catalog,
+                schema
+            );
+
+            // endpoint is optional
+            let endpoint_option = if let Some(endpoint) = self.s3_endpoint.as_ref() {
+                format!(", ENDPOINT='{}'", endpoint)
+            } else {
+                String::new()
+            };
+
+            // Safety: All s3 options are required
+            let connection_options = format!(
+                "ACCESS_KEY_ID='{}', SECRET_ACCESS_KEY='{}', REGION='{}'{}",
+                self.s3_access_key.as_ref().unwrap(),
+                self.s3_secret_key.as_ref().unwrap(),
+                self.s3_region.as_ref().unwrap(),
+                endpoint_option
+            );
+
+            (s3_path, format!(" CONNECTION ({})", connection_options))
+        } else {
+            (
+                self.catalog_path()
+                    .join(format!("{schema}/"))
+                    .to_string_lossy()
+                    .to_string(),
+                String::new(),
+            )
+        }
+    }
+
+    async fn execute_tasks(
+        &self,
+        tasks: Vec<impl std::future::Future<Output = Result<()>>>,
+    ) -> usize {
+        futures::future::join_all(tasks)
            .await
            .into_iter()
            .filter(|r| match r {
                Ok(_) => true,
                Err(e) => {
-                    error!(e; "export database job failed");
+                    error!(e; "export job failed");
                    false
                }
            })
-            .count();
-        let elapsed = timer.elapsed();
-
-        info!("Success {success}/{db_count} jobs, costs: {elapsed:?}");
-
-        Ok(())
+            .count()
    }
 }

@@ -493,3 +679,15 @@ impl Tool for Export {
        }
    }
 }
+
+/// Builds the WITH options string for SQL commands, assuming consistent syntax across S3 and local exports.
+fn build_with_options(start_time: &Option<String>, end_time: &Option<String>) -> String {
+    let mut options = vec!["format = 'parquet'".to_string()];
+    if let Some(start) = start_time {
+        options.push(format!("start_time = '{}'", start));
+    }
+    if let Some(end) = end_time {
+        options.push(format!("end_time = '{}'", end));
+    }
+    options.join(", ")
+}
--- a/src/common/function/Cargo.toml
+++ b/src/common/function/Cargo.toml
@@ -17,6 +17,7 @@ api.workspace = true
 arc-swap = "1.0"
 async-trait.workspace = true
 bincode = "1.3"
+chrono.workspace = true
 common-base.workspace = true
 common-catalog.workspace = true
 common-error.workspace = true
--- a/src/common/function/src/scalars/date/date_format.rs
+++ b/src/common/function/src/scalars/date/date_format.rs
@@ -43,7 +43,6 @@ impl Function for DateFormatFunction {
        helper::one_of_sigs2(
            vec![
                ConcreteDataType::date_datatype(),
-                ConcreteDataType::datetime_datatype(),
                ConcreteDataType::timestamp_second_datatype(),
                ConcreteDataType::timestamp_millisecond_datatype(),
                ConcreteDataType::timestamp_microsecond_datatype(),
@@ -105,22 +104,6 @@ impl Function for DateFormatFunction {
                    results.push(result.as_deref());
                }
            }
-            ConcreteDataType::DateTime(_) => {
-                for i in 0..size {
-                    let datetime = left.get(i).as_datetime();
-                    let format = formats.get(i).as_string();
-
-                    let result = match (datetime, format) {
-                        (Some(datetime), Some(fmt)) => datetime
-                            .as_formatted_string(&fmt, Some(&func_ctx.query_ctx.timezone()))
-                            .map_err(BoxedError::new)
-                            .context(error::ExecuteSnafu)?,
-                        _ => None,
-                    };
-
-                    results.push(result.as_deref());
-                }
-            }
            _ => {
                return UnsupportedInputDataTypeSnafu {
                    function: NAME,
@@ -147,7 +130,7 @@ mod tests {
    use common_query::prelude::{TypeSignature, Volatility};
    use datatypes::prelude::{ConcreteDataType, ScalarVector};
    use datatypes::value::Value;
-    use datatypes::vectors::{DateTimeVector, DateVector, StringVector, TimestampSecondVector};
+    use datatypes::vectors::{DateVector, StringVector, TimestampSecondVector};

    use super::{DateFormatFunction, *};

@@ -169,16 +152,11 @@ mod tests {
            ConcreteDataType::string_datatype(),
            f.return_type(&[ConcreteDataType::date_datatype()]).unwrap()
        );
-        assert_eq!(
-            ConcreteDataType::string_datatype(),
-            f.return_type(&[ConcreteDataType::datetime_datatype()])
-                .unwrap()
-        );
        assert!(matches!(f.signature(),
                         Signature {
                             type_signature: TypeSignature::OneOf(sigs),
                             volatility: Volatility::Immutable
-                         } if  sigs.len() == 6));
+                         } if  sigs.len() == 5));
    }

    #[test]
@@ -262,45 +240,4 @@ mod tests {
            }
        }
    }
-
-    #[test]
-    fn test_datetime_date_format() {
-        let f = DateFormatFunction;
-
-        let dates = vec![Some(123), None, Some(42), None];
-        let formats = vec![
-            "%Y-%m-%d %T.%3f",
-            "%Y-%m-%d %T.%3f",
-            "%Y-%m-%d %T.%3f",
-            "%Y-%m-%d %T.%3f",
-        ];
-        let results = [
-            Some("1970-01-01 00:00:00.123"),
-            None,
-            Some("1970-01-01 00:00:00.042"),
-            None,
-        ];
-
-        let date_vector = DateTimeVector::from(dates.clone());
-        let interval_vector = StringVector::from_vec(formats);
-        let args: Vec<VectorRef> = vec![Arc::new(date_vector), Arc::new(interval_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
-
-        assert_eq!(4, vector.len());
-        for (i, _t) in dates.iter().enumerate() {
-            let v = vector.get(i);
-            let result = results.get(i).unwrap();
-
-            if result.is_none() {
-                assert_eq!(Value::Null, v);
-                continue;
-            }
-            match v {
-                Value::String(s) => {
-                    assert_eq!(s.as_utf8(), result.unwrap());
-                }
-                _ => unreachable!(),
-            }
-        }
-    }
 }
--- a/src/common/function/src/scalars/date/date_sub.rs
+++ b/src/common/function/src/scalars/date/date_sub.rs
@@ -118,11 +118,6 @@ mod tests {
            ConcreteDataType::date_datatype(),
            f.return_type(&[ConcreteDataType::date_datatype()]).unwrap()
        );
-        assert_eq!(
-            ConcreteDataType::datetime_datatype(),
-            f.return_type(&[ConcreteDataType::datetime_datatype()])
-                .unwrap()
-        );
        assert!(
            matches!(f.signature(),
                         Signature {
--- a/src/common/function/src/scalars/timestamp/greatest.rs
+++ b/src/common/function/src/scalars/timestamp/greatest.rs
@@ -23,7 +23,7 @@ use datatypes::arrow::array::AsArray;
 use datatypes::arrow::compute::cast;
 use datatypes::arrow::compute::kernels::zip;
 use datatypes::arrow::datatypes::{
-    DataType as ArrowDataType, Date32Type, Date64Type, TimestampMicrosecondType,
+    DataType as ArrowDataType, Date32Type, TimeUnit, TimestampMicrosecondType,
    TimestampMillisecondType, TimestampNanosecondType, TimestampSecondType,
 };
 use datatypes::prelude::ConcreteDataType;
@@ -69,9 +69,8 @@ impl Function for GreatestFunction {
        );

        match &input_types[0] {
-            ConcreteDataType::String(_) => Ok(ConcreteDataType::datetime_datatype()),
+            ConcreteDataType::String(_) => Ok(ConcreteDataType::timestamp_millisecond_datatype()),
            ConcreteDataType::Date(_) => Ok(ConcreteDataType::date_datatype()),
-            ConcreteDataType::DateTime(_) => Ok(ConcreteDataType::datetime_datatype()),
            ConcreteDataType::Timestamp(ts_type) => Ok(ConcreteDataType::Timestamp(*ts_type)),
            _ => UnsupportedInputDataTypeSnafu {
                function: NAME,
@@ -87,7 +86,6 @@ impl Function for GreatestFunction {
            vec![
                ConcreteDataType::string_datatype(),
                ConcreteDataType::date_datatype(),
-                ConcreteDataType::datetime_datatype(),
                ConcreteDataType::timestamp_nanosecond_datatype(),
                ConcreteDataType::timestamp_microsecond_datatype(),
                ConcreteDataType::timestamp_millisecond_datatype(),
@@ -109,20 +107,24 @@ impl Function for GreatestFunction {
        );
        match columns[0].data_type() {
            ConcreteDataType::String(_) => {
-                // Treats string as `DateTime` type.
-                let column1 = cast(&columns[0].to_arrow_array(), &ArrowDataType::Date64)
-                    .context(ArrowComputeSnafu)?;
-                let column1 = column1.as_primitive::<Date64Type>();
-                let column2 = cast(&columns[1].to_arrow_array(), &ArrowDataType::Date64)
-                    .context(ArrowComputeSnafu)?;
-                let column2 = column2.as_primitive::<Date64Type>();
+                let column1 = cast(
+                    &columns[0].to_arrow_array(),
+                    &ArrowDataType::Timestamp(TimeUnit::Millisecond, None),
+                )
+                .context(ArrowComputeSnafu)?;
+                let column1 = column1.as_primitive::<TimestampMillisecondType>();
+                let column2 = cast(
+                    &columns[1].to_arrow_array(),
+                    &ArrowDataType::Timestamp(TimeUnit::Millisecond, None),
+                )
+                .context(ArrowComputeSnafu)?;
+                let column2 = column2.as_primitive::<TimestampMillisecondType>();
                let boolean_array = gt(&column1, &column2).context(ArrowComputeSnafu)?;
                let result =
                    zip::zip(&boolean_array, &column1, &column2).context(ArrowComputeSnafu)?;
                Ok(Helper::try_into_vector(&result).context(error::FromArrowArraySnafu)?)
            }
            ConcreteDataType::Date(_) => gt_time_types!(Date32Type, columns),
-            ConcreteDataType::DateTime(_) => gt_time_types!(Date64Type, columns),
            ConcreteDataType::Timestamp(ts_type) => match ts_type {
                TimestampType::Second(_) => gt_time_types!(TimestampSecondType, columns),
                TimestampType::Millisecond(_) => {
@@ -155,15 +157,15 @@ mod tests {
    use std::sync::Arc;

    use common_time::timestamp::TimeUnit;
-    use common_time::{Date, DateTime, Timestamp};
+    use common_time::{Date, Timestamp};
    use datatypes::types::{
-        DateTimeType, DateType, TimestampMicrosecondType, TimestampMillisecondType,
-        TimestampNanosecondType, TimestampSecondType,
+        DateType, TimestampMicrosecondType, TimestampMillisecondType, TimestampNanosecondType,
+        TimestampSecondType,
    };
    use datatypes::value::Value;
    use datatypes::vectors::{
-        DateTimeVector, DateVector, StringVector, TimestampMicrosecondVector,
-        TimestampMillisecondVector, TimestampNanosecondVector, TimestampSecondVector, Vector,
+        DateVector, StringVector, TimestampMicrosecondVector, TimestampMillisecondVector,
+        TimestampNanosecondVector, TimestampSecondVector, Vector,
    };
    use paste::paste;

@@ -178,7 +180,7 @@ mod tests {
                    ConcreteDataType::string_datatype()
                ])
                .unwrap(),
-            ConcreteDataType::DateTime(DateTimeType)
+            ConcreteDataType::timestamp_millisecond_datatype()
        );
        let columns = vec![
            Arc::new(StringVector::from(vec![
@@ -194,15 +196,18 @@ mod tests {
        let result = function
            .eval(&FunctionContext::default(), &columns)
            .unwrap();
-        let result = result.as_any().downcast_ref::<DateTimeVector>().unwrap();
+        let result = result
+            .as_any()
+            .downcast_ref::<TimestampMillisecondVector>()
+            .unwrap();
        assert_eq!(result.len(), 2);
        assert_eq!(
            result.get(0),
-            Value::DateTime(DateTime::from_str("2001-02-01 00:00:00", None).unwrap())
+            Value::Timestamp(Timestamp::from_str("2001-02-01 00:00:00", None).unwrap())
        );
        assert_eq!(
            result.get(1),
-            Value::DateTime(DateTime::from_str("2012-12-23 00:00:00", None).unwrap())
+            Value::Timestamp(Timestamp::from_str("2012-12-23 00:00:00", None).unwrap())
        );
    }

@@ -245,30 +250,33 @@ mod tests {
        assert_eq!(
            function
                .return_type(&[
-                    ConcreteDataType::datetime_datatype(),
-                    ConcreteDataType::datetime_datatype()
+                    ConcreteDataType::timestamp_millisecond_datatype(),
+                    ConcreteDataType::timestamp_millisecond_datatype()
                ])
                .unwrap(),
-            ConcreteDataType::DateTime(DateTimeType)
+            ConcreteDataType::timestamp_millisecond_datatype()
        );

        let columns = vec![
-            Arc::new(DateTimeVector::from_slice(vec![-1, 2])) as _,
-            Arc::new(DateTimeVector::from_slice(vec![0, 1])) as _,
+            Arc::new(TimestampMillisecondVector::from_slice(vec![-1, 2])) as _,
+            Arc::new(TimestampMillisecondVector::from_slice(vec![0, 1])) as _,
        ];

        let result = function
            .eval(&FunctionContext::default(), &columns)
            .unwrap();
-        let result = result.as_any().downcast_ref::<DateTimeVector>().unwrap();
+        let result = result
+            .as_any()
+            .downcast_ref::<TimestampMillisecondVector>()
+            .unwrap();
        assert_eq!(result.len(), 2);
        assert_eq!(
            result.get(0),
-            Value::DateTime(DateTime::from_str("1970-01-01 00:00:00", None).unwrap())
+            Value::Timestamp(Timestamp::from_str("1970-01-01 00:00:00", None).unwrap())
        );
        assert_eq!(
            result.get(1),
-            Value::DateTime(DateTime::from_str("1970-01-01 00:00:00.002", None).unwrap())
+            Value::Timestamp(Timestamp::from_str("1970-01-01 00:00:00.002", None).unwrap())
        );
    }

--- a/src/common/function/src/scalars/timestamp/to_unixtime.rs
+++ b/src/common/function/src/scalars/timestamp/to_unixtime.rs
@@ -17,7 +17,7 @@ use std::sync::Arc;

 use common_query::error::{InvalidFuncArgsSnafu, Result, UnsupportedInputDataTypeSnafu};
 use common_query::prelude::{Signature, Volatility};
-use common_time::{Date, DateTime, Timestamp};
+use common_time::{Date, Timestamp};
 use datatypes::prelude::ConcreteDataType;
 use datatypes::vectors::{Int64Vector, VectorRef};
 use snafu::ensure;
@@ -32,10 +32,6 @@ const NAME: &str = "to_unixtime";

 fn convert_to_seconds(arg: &str, func_ctx: &FunctionContext) -> Option<i64> {
    let timezone = &func_ctx.query_ctx.timezone();
-    if let Ok(dt) = DateTime::from_str(arg, Some(timezone)) {
-        return Some(dt.val() / 1000);
-    }
-
    if let Ok(ts) = Timestamp::from_str(arg, Some(timezone)) {
        return Some(ts.split().0);
    }
@@ -59,12 +55,6 @@ fn convert_dates_to_seconds(vector: &VectorRef) -> Vec<Option<i64>> {
        .collect::<Vec<Option<i64>>>()
 }

-fn convert_datetimes_to_seconds(vector: &VectorRef) -> Vec<Option<i64>> {
-    (0..vector.len())
-        .map(|i| vector.get(i).as_datetime().map(|dt| dt.val() / 1000))
-        .collect::<Vec<Option<i64>>>()
-}
-
 impl Function for ToUnixtimeFunction {
    fn name(&self) -> &str {
        NAME
@@ -82,7 +72,6 @@ impl Function for ToUnixtimeFunction {
                ConcreteDataType::int32_datatype(),
                ConcreteDataType::int64_datatype(),
                ConcreteDataType::date_datatype(),
-                ConcreteDataType::datetime_datatype(),
                ConcreteDataType::timestamp_second_datatype(),
                ConcreteDataType::timestamp_millisecond_datatype(),
                ConcreteDataType::timestamp_microsecond_datatype(),
@@ -119,10 +108,6 @@ impl Function for ToUnixtimeFunction {
                let seconds = convert_dates_to_seconds(vector);
                Ok(Arc::new(Int64Vector::from(seconds)))
            }
-            ConcreteDataType::DateTime(_) => {
-                let seconds = convert_datetimes_to_seconds(vector);
-                Ok(Arc::new(Int64Vector::from(seconds)))
-            }
            ConcreteDataType::Timestamp(_) => {
                let seconds = convert_timestamps_to_seconds(vector);
                Ok(Arc::new(Int64Vector::from(seconds)))
@@ -148,7 +133,7 @@ mod tests {
    use datatypes::prelude::ConcreteDataType;
    use datatypes::value::Value;
    use datatypes::vectors::{
-        DateTimeVector, DateVector, StringVector, TimestampMillisecondVector, TimestampSecondVector,
+        DateVector, StringVector, TimestampMillisecondVector, TimestampSecondVector,
    };

    use super::{ToUnixtimeFunction, *};
@@ -171,7 +156,6 @@ mod tests {
                             ConcreteDataType::int32_datatype(),
                             ConcreteDataType::int64_datatype(),
                             ConcreteDataType::date_datatype(),
-                             ConcreteDataType::datetime_datatype(),
                             ConcreteDataType::timestamp_second_datatype(),
                             ConcreteDataType::timestamp_millisecond_datatype(),
                             ConcreteDataType::timestamp_microsecond_datatype(),
@@ -253,31 +237,6 @@ mod tests {
        }
    }

-    #[test]
-    fn test_datetime_to_unixtime() {
-        let f = ToUnixtimeFunction;
-
-        let times = vec![Some(123000), None, Some(42000), None];
-        let results = [Some(123), None, Some(42), None];
-        let date_vector = DateTimeVector::from(times.clone());
-        let args: Vec<VectorRef> = vec![Arc::new(date_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
-        assert_eq!(4, vector.len());
-        for (i, _t) in times.iter().enumerate() {
-            let v = vector.get(i);
-            if i == 1 || i == 3 {
-                assert_eq!(Value::Null, v);
-                continue;
-            }
-            match v {
-                Value::Int64(ts) => {
-                    assert_eq!(ts, (*results.get(i).unwrap()).unwrap());
-                }
-                _ => unreachable!(),
-            }
-        }
-    }
-
    #[test]
    fn test_timestamp_to_unixtime() {
        let f = ToUnixtimeFunction;
--- a/src/common/grpc/src/select.rs
+++ b/src/common/grpc/src/select.rs
@@ -17,8 +17,8 @@ use api::v1::column::Values;
 use common_base::BitVec;
 use datatypes::types::{IntervalType, TimeType, TimestampType, WrapperType};
 use datatypes::vectors::{
-    BinaryVector, BooleanVector, DateTimeVector, DateVector, Decimal128Vector, Float32Vector,
-    Float64Vector, Int16Vector, Int32Vector, Int64Vector, Int8Vector, IntervalDayTimeVector,
+    BinaryVector, BooleanVector, DateVector, Decimal128Vector, Float32Vector, Float64Vector,
+    Int16Vector, Int32Vector, Int64Vector, Int8Vector, IntervalDayTimeVector,
    IntervalMonthDayNanoVector, IntervalYearMonthVector, StringVector, TimeMicrosecondVector,
    TimeMillisecondVector, TimeNanosecondVector, TimeSecondVector, TimestampMicrosecondVector,
    TimestampMillisecondVector, TimestampNanosecondVector, TimestampSecondVector, UInt16Vector,
@@ -141,12 +141,6 @@ pub fn values(arrays: &[VectorRef]) -> Result<Values> {
        (ConcreteDataType::Date(_), DateVector, date_values, |x| {
            x.val()
        }),
-        (
-            ConcreteDataType::DateTime(_),
-            DateTimeVector,
-            datetime_values,
-            |x| { x.val() }
-        ),
        (
            ConcreteDataType::Timestamp(TimestampType::Second(_)),
            TimestampSecondVector,
--- a/src/common/macro/src/lib.rs
+++ b/src/common/macro/src/lib.rs
@@ -18,11 +18,13 @@ mod print_caller;
 mod range_fn;
 mod stack_trace_debug;
 mod utils;
+
 use aggr_func::{impl_aggr_func_type_store, impl_as_aggr_func_creator};
 use print_caller::process_print_caller;
 use proc_macro::TokenStream;
+use quote::quote;
 use range_fn::process_range_fn;
-use syn::{parse_macro_input, DeriveInput};
+use syn::{parse_macro_input, Data, DeriveInput, Fields};

 use crate::admin_fn::process_admin_fn;

@@ -136,3 +138,51 @@ pub fn print_caller(args: TokenStream, input: TokenStream) -> TokenStream {
 pub fn stack_trace_debug(args: TokenStream, input: TokenStream) -> TokenStream {
    stack_trace_debug::stack_trace_style_impl(args.into(), input.into()).into()
 }
+
+/// Generates implementation for `From<&TableMeta> for TableMetaBuilder`
+#[proc_macro_derive(ToMetaBuilder)]
+pub fn derive_meta_builder(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+
+    let Data::Struct(data_struct) = input.data else {
+        panic!("ToMetaBuilder can only be derived for structs");
+    };
+
+    let Fields::Named(fields) = data_struct.fields else {
+        panic!("ToMetaBuilder can only be derived for structs with named fields");
+    };
+
+    // Check that this is being applied to TableMeta struct
+    if input.ident != "TableMeta" {
+        panic!("ToMetaBuilder can only be derived for TableMeta struct");
+    }
+
+    let field_init = fields.named.iter().map(|field| {
+        let field_name = field.ident.as_ref().unwrap();
+        quote! {
+            #field_name: Default::default(),
+        }
+    });
+
+    let field_assignments = fields.named.iter().map(|field| {
+        let field_name = field.ident.as_ref().unwrap();
+        quote! {
+            builder.#field_name(meta.#field_name.clone());
+        }
+    });
+
+    let gen = quote! {
+        impl From<&TableMeta> for TableMetaBuilder {
+            fn from(meta: &TableMeta) -> Self {
+                let mut builder = Self {
+                    #(#field_init)*
+                };
+
+                #(#field_assignments)*
+                builder
+            }
+        }
+    };
+
+    gen.into()
+}
--- a/src/common/meta/Cargo.toml
+++ b/src/common/meta/Cargo.toml
@@ -7,6 +7,7 @@ license.workspace = true
 [features]
 testing = []
 pg_kvbackend = ["dep:tokio-postgres", "dep:backon", "dep:deadpool-postgres", "dep:deadpool"]
+mysql_kvbackend = ["dep:sqlx", "dep:backon"]

 [lints]
 workspace = true
@@ -57,9 +58,10 @@ serde_json.workspace = true
 serde_with.workspace = true
 session.workspace = true
 snafu.workspace = true
+sqlx = { workspace = true, optional = true }
 store-api.workspace = true
 strum.workspace = true
-table.workspace = true
+table = { workspace = true, features = ["testing"] }
 tokio.workspace = true
 tokio-postgres = { workspace = true, optional = true }
 tonic.workspace = true
--- a/src/common/meta/src/cache/flow/table_flownode.rs
+++ b/src/common/meta/src/cache/flow/table_flownode.rs
@@ -192,6 +192,8 @@ mod tests {
                    expire_after: Some(300),
                    comment: "comment".to_string(),
                    options: Default::default(),
+                    created_time: chrono::Utc::now(),
+                    updated_time: chrono::Utc::now(),
                },
                (1..=3)
                    .map(|i| {
--- a/src/common/meta/src/ddl/alter_table.rs
+++ b/src/common/meta/src/ddl/alter_table.rs
@@ -22,30 +22,31 @@ use std::vec;
 use api::v1::alter_table_expr::Kind;
 use api::v1::RenameTable;
 use async_trait::async_trait;
-use common_error::ext::ErrorExt;
-use common_error::status_code::StatusCode;
+use common_error::ext::BoxedError;
 use common_procedure::error::{FromJsonSnafu, Result as ProcedureResult, ToJsonSnafu};
 use common_procedure::{
-    Context as ProcedureContext, Error as ProcedureError, LockKey, Procedure, Status, StringKey,
+    Context as ProcedureContext, ContextProvider, Error as ProcedureError, LockKey, PoisonKey,
+    PoisonKeys, Procedure, ProcedureId, Status, StringKey,
 };
 use common_telemetry::{debug, error, info};
 use futures::future;
 use serde::{Deserialize, Serialize};
-use snafu::ResultExt;
+use snafu::{ensure, ResultExt};
 use store_api::storage::RegionId;
 use strum::AsRefStr;
 use table::metadata::{RawTableInfo, TableId, TableInfo};
 use table::table_reference::TableReference;

 use crate::cache_invalidator::Context;
-use crate::ddl::utils::add_peer_context_if_needed;
+use crate::ddl::utils::{add_peer_context_if_needed, handle_multiple_results, MultipleResults};
 use crate::ddl::DdlContext;
-use crate::error::{Error, Result};
+use crate::error::{AbortProcedureSnafu, Error, NoLeaderSnafu, PutPoisonSnafu, Result};
 use crate::instruction::CacheIdent;
 use crate::key::table_info::TableInfoValue;
 use crate::key::{DeserializedValueWithBytes, RegionDistribution};
 use crate::lock_key::{CatalogLock, SchemaLock, TableLock, TableNameLock};
 use crate::metrics;
+use crate::poison_key::table_poison_key;
 use crate::rpc::ddl::AlterTableTask;
 use crate::rpc::router::{find_leader_regions, find_leaders, region_distribution};

@@ -104,7 +105,27 @@ impl AlterTableProcedure {
        Ok(Status::executing(true))
    }

-    pub async fn submit_alter_region_requests(&mut self) -> Result<Status> {
+    fn table_poison_key(&self) -> PoisonKey {
+        table_poison_key(self.data.table_id())
+    }
+
+    async fn put_poison(
+        &self,
+        ctx_provider: &dyn ContextProvider,
+        procedure_id: ProcedureId,
+    ) -> Result<()> {
+        let poison_key = self.table_poison_key();
+        ctx_provider
+            .try_put_poison(&poison_key, procedure_id)
+            .await
+            .context(PutPoisonSnafu)
+    }
+
+    pub async fn submit_alter_region_requests(
+        &mut self,
+        procedure_id: ProcedureId,
+        ctx_provider: &dyn ContextProvider,
+    ) -> Result<Status> {
        let table_id = self.data.table_id();
        let (_, physical_table_route) = self
            .context
@@ -127,6 +148,9 @@ impl AlterTableProcedure {
            alter_kind,
        );

+        ensure!(!leaders.is_empty(), NoLeaderSnafu { table_id });
+        // Puts the poison before submitting alter region requests to datanodes.
+        self.put_poison(ctx_provider, procedure_id).await?;
        for datanode in leaders {
            let requester = self.context.node_manager.datanode(&datanode).await;
            let regions = find_leader_regions(&physical_table_route.region_routes, &datanode);
@@ -140,28 +164,51 @@ impl AlterTableProcedure {
                let requester = requester.clone();

                alter_region_tasks.push(async move {
-                    if let Err(err) = requester.handle(request).await {
-                        if err.status_code() != StatusCode::RequestOutdated {
-                            // Treat request outdated as success.
-                            // The engine will throw this code when the schema version not match.
-                            // As this procedure has locked the table, the only reason for this error
-                            // is procedure is succeeded before and is retrying.
-                            return Err(add_peer_context_if_needed(datanode)(err));
-                        }
-                    }
-                    Ok(())
+                    requester
+                        .handle(request)
+                        .await
+                        .map_err(add_peer_context_if_needed(datanode))
                });
            }
        }

-        future::join_all(alter_region_tasks)
+        let results = future::join_all(alter_region_tasks)
            .await
            .into_iter()
-            .collect::<Result<Vec<_>>>()?;
+            .collect::<Vec<_>>();

-        self.data.state = AlterTableState::UpdateMetadata;
+        match handle_multiple_results(results) {
+            MultipleResults::PartialRetryable(error) => {
+                // Just returns the error, and wait for the next try.
+                Err(error)
+            }
+            MultipleResults::PartialNonRetryable(error) => {
+                error!(error; "Partial non-retryable errors occurred during alter table, table {}, table_id: {}", self.data.table_ref(), self.data.table_id());
+                // No retry will be done.
+                Ok(Status::poisoned(
+                    Some(self.table_poison_key()),
+                    ProcedureError::external(error),
+                ))
+            }
+            MultipleResults::AllRetryable(error) => {
+                // Just returns the error, and wait for the next try.
+                Err(error)
+            }
+            MultipleResults::Ok => {
+                self.data.state = AlterTableState::UpdateMetadata;
+                Ok(Status::executing_with_clean_poisons(true))
+            }
+            MultipleResults::AllNonRetryable(error) => {
+                error!(error; "All alter requests returned non-retryable errors for table {}, table_id: {}", self.data.table_ref(), self.data.table_id());
+                // It assumes the metadata on datanode is not changed.
+                // Case: The alter region request is sent but not applied. (e.g., InvalidArgument)

-        Ok(Status::executing(true))
+                let err = BoxedError::new(error);
+                Err(err).context(AbortProcedureSnafu {
+                    clean_poisons: true,
+                })
+            }
+        }
    }

    /// Update table metadata.
@@ -250,10 +297,12 @@ impl Procedure for AlterTableProcedure {
        Self::TYPE_NAME
    }

-    async fn execute(&mut self, _ctx: &ProcedureContext) -> ProcedureResult<Status> {
+    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)
            }
@@ -269,7 +318,10 @@ impl Procedure for AlterTableProcedure {

        match state {
            AlterTableState::Prepare => self.on_prepare().await,
-            AlterTableState::SubmitAlterRegionRequests => self.submit_alter_region_requests().await,
+            AlterTableState::SubmitAlterRegionRequests => {
+                self.submit_alter_region_requests(ctx.procedure_id, ctx.provider.as_ref())
+                    .await
+            }
            AlterTableState::UpdateMetadata => self.on_update_metadata().await,
            AlterTableState::InvalidateTableCache => self.on_broadcast().await,
        }
@@ -285,6 +337,10 @@ impl Procedure for AlterTableProcedure {

        LockKey::new(key)
    }
+
+    fn poison_keys(&self) -> PoisonKeys {
+        PoisonKeys::new(vec![self.table_poison_key()])
+    }
 }

 #[derive(Debug, Serialize, Deserialize, AsRefStr)]
--- a/src/common/meta/src/ddl/create_flow.rs
+++ b/src/common/meta/src/ddl/create_flow.rs
@@ -425,7 +425,14 @@ impl From<&CreateFlowData> for (FlowInfoValue, Vec<(FlowPartitionId, FlowRouteVa
        let flow_type = value.flow_type.unwrap_or_default().to_string();
        options.insert("flow_type".to_string(), flow_type);

-        let flow_info = FlowInfoValue {
+        let mut create_time = chrono::Utc::now();
+        if let Some(prev_flow_value) = value.prev_flow_info_value.as_ref()
+            && value.task.or_replace
+        {
+            create_time = prev_flow_value.get_inner_ref().created_time;
+        }
+
+        let flow_info: FlowInfoValue = FlowInfoValue {
            source_table_ids: value.source_table_ids.clone(),
            sink_table_name,
            flownode_ids,
@@ -435,6 +442,8 @@ impl From<&CreateFlowData> for (FlowInfoValue, Vec<(FlowPartitionId, FlowRouteVa
            expire_after,
            comment,
            options,
+            created_time: create_time,
+            updated_time: chrono::Utc::now(),
        };

        (flow_info, flow_routes)
--- a/src/common/meta/src/ddl/create_table.rs
+++ b/src/common/meta/src/ddl/create_table.rs
@@ -299,7 +299,9 @@ impl Procedure for CreateTableProcedure {
                .creator
                .register_opening_regions(&self.context, &x.region_routes)
                .map_err(BoxedError::new)
-                .context(ExternalSnafu)?;
+                .context(ExternalSnafu {
+                    clean_poisons: false,
+                })?;
        }

        Ok(())
--- a/src/common/meta/src/ddl/drop_database.rs
+++ b/src/common/meta/src/ddl/drop_database.rs
@@ -130,7 +130,9 @@ impl Procedure for DropDatabaseProcedure {
        self.state
            .recover(&self.runtime_context)
            .map_err(BoxedError::new)
-            .context(ExternalSnafu)
+            .context(ExternalSnafu {
+                clean_poisons: false,
+            })
    }

    async fn execute(&mut self, _ctx: &ProcedureContext) -> ProcedureResult<Status> {
--- a/src/common/meta/src/ddl/drop_table.rs
+++ b/src/common/meta/src/ddl/drop_table.rs
@@ -200,7 +200,9 @@ impl Procedure for DropTableProcedure {
        if register_operating_regions {
            self.register_dropping_regions()
                .map_err(BoxedError::new)
-                .context(ExternalSnafu)?;
+                .context(ExternalSnafu {
+                    clean_poisons: false,
+                })?;
        }

        Ok(())
--- a/src/common/meta/src/ddl/test_util.rs
+++ b/src/common/meta/src/ddl/test_util.rs
@@ -80,7 +80,13 @@ pub async fn create_logical_table(
    let tasks = vec![test_create_logical_table_task(table_name)];
    let mut procedure = CreateLogicalTablesProcedure::new(tasks, physical_table_id, ddl_context);
    let status = procedure.on_prepare().await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );
    let status = procedure.on_create_metadata().await.unwrap();
    assert_matches!(status, Status::Done { .. });

--- a/src/common/meta/src/ddl/test_util/datanode_handler.rs
+++ b/src/common/meta/src/ddl/test_util/datanode_handler.rs
@@ -171,3 +171,74 @@ impl MockDatanodeHandler for NaiveDatanodeHandler {
        unreachable!()
    }
 }
+
+#[derive(Clone)]
+pub struct PartialSuccessDatanodeHandler {
+    pub retryable: bool,
+}
+
+#[async_trait::async_trait]
+impl MockDatanodeHandler for PartialSuccessDatanodeHandler {
+    async fn handle(&self, peer: &Peer, _request: RegionRequest) -> Result<RegionResponse> {
+        let success = peer.id % 2 == 0;
+        if success {
+            Ok(RegionResponse::new(0))
+        } else if self.retryable {
+            Err(Error::RetryLater {
+                source: BoxedError::new(
+                    error::UnexpectedSnafu {
+                        err_msg: "retry later",
+                    }
+                    .build(),
+                ),
+            })
+        } else {
+            error::UnexpectedSnafu {
+                err_msg: "mock error",
+            }
+            .fail()
+        }
+    }
+
+    async fn handle_query(
+        &self,
+        _peer: &Peer,
+        _request: QueryRequest,
+    ) -> Result<SendableRecordBatchStream> {
+        unreachable!()
+    }
+}
+
+#[derive(Clone)]
+pub struct AllFailureDatanodeHandler {
+    pub retryable: bool,
+}
+
+#[async_trait::async_trait]
+impl MockDatanodeHandler for AllFailureDatanodeHandler {
+    async fn handle(&self, _peer: &Peer, _request: RegionRequest) -> Result<RegionResponse> {
+        if self.retryable {
+            Err(Error::RetryLater {
+                source: BoxedError::new(
+                    error::UnexpectedSnafu {
+                        err_msg: "retry later",
+                    }
+                    .build(),
+                ),
+            })
+        } else {
+            error::UnexpectedSnafu {
+                err_msg: "mock error",
+            }
+            .fail()
+        }
+    }
+
+    async fn handle_query(
+        &self,
+        _peer: &Peer,
+        _request: QueryRequest,
+    ) -> Result<SendableRecordBatchStream> {
+        unreachable!()
+    }
+}
--- a/src/common/meta/src/ddl/tests/alter_logical_tables.rs
+++ b/src/common/meta/src/ddl/tests/alter_logical_tables.rs
@@ -180,7 +180,13 @@ async fn test_on_prepare() {

    let mut procedure = AlterLogicalTablesProcedure::new(tasks, phy_id, ddl_context);
    let result = procedure.on_prepare().await;
-    assert_matches!(result, Ok(Status::Executing { persist: true }));
+    assert_matches!(
+        result,
+        Ok(Status::Executing {
+            persist: true,
+            clean_poisons: false
+        })
+    );
 }

 #[tokio::test]
@@ -205,7 +211,13 @@ async fn test_on_update_metadata() {

    let mut procedure = AlterLogicalTablesProcedure::new(tasks, phy_id, ddl_context);
    let mut status = procedure.on_prepare().await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );

    let ctx = common_procedure::Context {
        procedure_id: ProcedureId::random(),
@@ -213,10 +225,22 @@ async fn test_on_update_metadata() {
    };
    // on_submit_alter_region_requests
    status = procedure.execute(&ctx).await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );
    // on_update_metadata
    status = procedure.execute(&ctx).await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );
 }

 #[tokio::test]
@@ -237,7 +261,13 @@ async fn test_on_part_duplicate_alter_request() {

    let mut procedure = AlterLogicalTablesProcedure::new(tasks, phy_id, ddl_context.clone());
    let mut status = procedure.on_prepare().await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );

    let ctx = common_procedure::Context {
        procedure_id: ProcedureId::random(),
@@ -245,10 +275,22 @@ async fn test_on_part_duplicate_alter_request() {
    };
    // on_submit_alter_region_requests
    status = procedure.execute(&ctx).await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );
    // on_update_metadata
    status = procedure.execute(&ctx).await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );

    // re-alter
    let tasks = vec![
@@ -270,7 +312,13 @@ async fn test_on_part_duplicate_alter_request() {

    let mut procedure = AlterLogicalTablesProcedure::new(tasks, phy_id, ddl_context.clone());
    let mut status = procedure.on_prepare().await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );

    let ctx = common_procedure::Context {
        procedure_id: ProcedureId::random(),
@@ -278,10 +326,22 @@ async fn test_on_part_duplicate_alter_request() {
    };
    // on_submit_alter_region_requests
    status = procedure.execute(&ctx).await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );
    // on_update_metadata
    status = procedure.execute(&ctx).await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );

    let table_name_keys = vec![
        TableNameKey::new(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, "table1"),
--- a/src/common/meta/src/ddl/tests/alter_table.rs
+++ b/src/common/meta/src/ddl/tests/alter_table.rs
@@ -25,6 +25,9 @@ use api::v1::{
 use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
 use common_error::ext::ErrorExt;
 use common_error::status_code::StatusCode;
+use common_procedure::store::poison_store::PoisonStore;
+use common_procedure::{ProcedureId, Status};
+use common_procedure_test::MockContextProvider;
 use store_api::storage::RegionId;
 use table::requests::TTL_KEY;
 use tokio::sync::mpsc::{self};
@@ -33,16 +36,46 @@ use crate::ddl::alter_table::AlterTableProcedure;
 use crate::ddl::test_util::alter_table::TestAlterTableExprBuilder;
 use crate::ddl::test_util::create_table::test_create_table_task;
 use crate::ddl::test_util::datanode_handler::{
-    DatanodeWatcher, RequestOutdatedErrorDatanodeHandler,
+    AllFailureDatanodeHandler, DatanodeWatcher, PartialSuccessDatanodeHandler,
+    RequestOutdatedErrorDatanodeHandler,
 };
+use crate::error::Error;
 use crate::key::datanode_table::DatanodeTableKey;
 use crate::key::table_name::TableNameKey;
 use crate::key::table_route::TableRouteValue;
+use crate::node_manager::NodeManagerRef;
 use crate::peer::Peer;
+use crate::poison_key::table_poison_key;
 use crate::rpc::ddl::AlterTableTask;
 use crate::rpc::router::{Region, RegionRoute};
 use crate::test_util::{new_ddl_context, MockDatanodeManager};

+fn prepare_table_route(table_id: u32) -> TableRouteValue {
+    TableRouteValue::physical(vec![
+        RegionRoute {
+            region: Region::new_test(RegionId::new(table_id, 1)),
+            leader_peer: Some(Peer::empty(1)),
+            follower_peers: vec![Peer::empty(5)],
+            leader_state: None,
+            leader_down_since: None,
+        },
+        RegionRoute {
+            region: Region::new_test(RegionId::new(table_id, 2)),
+            leader_peer: Some(Peer::empty(2)),
+            follower_peers: vec![Peer::empty(4)],
+            leader_state: None,
+            leader_down_since: None,
+        },
+        RegionRoute {
+            region: Region::new_test(RegionId::new(table_id, 3)),
+            leader_peer: Some(Peer::empty(3)),
+            follower_peers: vec![],
+            leader_state: None,
+            leader_down_since: None,
+        },
+    ])
+}
+
 fn test_rename_alter_table_task(table_name: &str, new_table_name: &str) -> AlterTableTask {
    let builder = TestAlterTableExprBuilder::default()
        .table_name(table_name)
@@ -101,29 +134,7 @@ async fn test_on_submit_alter_request() {
        .table_metadata_manager
        .create_table_metadata(
            task.table_info.clone(),
-            TableRouteValue::physical(vec![
-                RegionRoute {
-                    region: Region::new_test(RegionId::new(table_id, 1)),
-                    leader_peer: Some(Peer::empty(1)),
-                    follower_peers: vec![Peer::empty(5)],
-                    leader_state: None,
-                    leader_down_since: None,
-                },
-                RegionRoute {
-                    region: Region::new_test(RegionId::new(table_id, 2)),
-                    leader_peer: Some(Peer::empty(2)),
-                    follower_peers: vec![Peer::empty(4)],
-                    leader_state: None,
-                    leader_down_since: None,
-                },
-                RegionRoute {
-                    region: Region::new_test(RegionId::new(table_id, 3)),
-                    leader_peer: Some(Peer::empty(3)),
-                    follower_peers: vec![],
-                    leader_state: None,
-                    leader_down_since: None,
-                },
-            ]),
+            prepare_table_route(table_id),
            HashMap::new(),
        )
        .await
@@ -141,9 +152,15 @@ async fn test_on_submit_alter_request() {
            })),
        },
    };
-    let mut procedure = AlterTableProcedure::new(table_id, alter_table_task, ddl_context).unwrap();
+    let procedure_id = ProcedureId::random();
+    let provider = Arc::new(MockContextProvider::default());
+    let mut procedure =
+        AlterTableProcedure::new(table_id, alter_table_task, ddl_context.clone()).unwrap();
    procedure.on_prepare().await.unwrap();
-    procedure.submit_alter_region_requests().await.unwrap();
+    procedure
+        .submit_alter_region_requests(procedure_id, provider.as_ref())
+        .await
+        .unwrap();

    let check = |peer: Peer,
                 request: RegionRequest,
@@ -185,29 +202,7 @@ async fn test_on_submit_alter_request_with_outdated_request() {
        .table_metadata_manager
        .create_table_metadata(
            task.table_info.clone(),
-            TableRouteValue::physical(vec![
-                RegionRoute {
-                    region: Region::new_test(RegionId::new(table_id, 1)),
-                    leader_peer: Some(Peer::empty(1)),
-                    follower_peers: vec![Peer::empty(5)],
-                    leader_state: None,
-                    leader_down_since: None,
-                },
-                RegionRoute {
-                    region: Region::new_test(RegionId::new(table_id, 2)),
-                    leader_peer: Some(Peer::empty(2)),
-                    follower_peers: vec![Peer::empty(4)],
-                    leader_state: None,
-                    leader_down_since: None,
-                },
-                RegionRoute {
-                    region: Region::new_test(RegionId::new(table_id, 3)),
-                    leader_peer: Some(Peer::empty(3)),
-                    follower_peers: vec![],
-                    leader_state: None,
-                    leader_down_since: None,
-                },
-            ]),
+            prepare_table_route(table_id),
            HashMap::new(),
        )
        .await
@@ -225,9 +220,15 @@ async fn test_on_submit_alter_request_with_outdated_request() {
            })),
        },
    };
+    let procedure_id = ProcedureId::random();
+    let provider = Arc::new(MockContextProvider::default());
    let mut procedure = AlterTableProcedure::new(table_id, alter_table_task, ddl_context).unwrap();
    procedure.on_prepare().await.unwrap();
-    procedure.submit_alter_region_requests().await.unwrap();
+    let err = procedure
+        .submit_alter_region_requests(procedure_id, provider.as_ref())
+        .await
+        .unwrap_err();
+    assert!(!err.is_retry_later());
 }

 #[tokio::test]
@@ -326,9 +327,14 @@ async fn test_on_update_metadata_add_columns() {
            })),
        },
    };
+    let procedure_id = ProcedureId::random();
+    let provider = Arc::new(MockContextProvider::default());
    let mut procedure = AlterTableProcedure::new(table_id, task, ddl_context.clone()).unwrap();
    procedure.on_prepare().await.unwrap();
-    procedure.submit_alter_region_requests().await.unwrap();
+    procedure
+        .submit_alter_region_requests(procedure_id, provider.as_ref())
+        .await
+        .unwrap();
    procedure.on_update_metadata().await.unwrap();

    let table_info = ddl_context
@@ -387,9 +393,14 @@ async fn test_on_update_table_options() {
            })),
        },
    };
+    let procedure_id = ProcedureId::random();
+    let provider = Arc::new(MockContextProvider::default());
    let mut procedure = AlterTableProcedure::new(table_id, task, ddl_context.clone()).unwrap();
    procedure.on_prepare().await.unwrap();
-    procedure.submit_alter_region_requests().await.unwrap();
+    procedure
+        .submit_alter_region_requests(procedure_id, provider.as_ref())
+        .await
+        .unwrap();
    procedure.on_update_metadata().await.unwrap();

    let table_info = ddl_context
@@ -417,3 +428,156 @@ async fn test_on_update_table_options() {
        HashMap::from(&table_info.meta.options)
    );
 }
+
+async fn prepare_alter_table_procedure(
+    node_manager: NodeManagerRef,
+) -> (AlterTableProcedure, ProcedureId) {
+    common_telemetry::init_default_ut_logging();
+    let ddl_context = new_ddl_context(node_manager);
+    let table_id = 1024;
+    let table_name = "foo";
+    let task = test_create_table_task(table_name, table_id);
+    // Puts a value to table name key.
+    ddl_context
+        .table_metadata_manager
+        .create_table_metadata(
+            task.table_info.clone(),
+            prepare_table_route(table_id),
+            HashMap::new(),
+        )
+        .await
+        .unwrap();
+
+    let alter_table_task = AlterTableTask {
+        alter_table: AlterTableExpr {
+            catalog_name: DEFAULT_CATALOG_NAME.to_string(),
+            schema_name: DEFAULT_SCHEMA_NAME.to_string(),
+            table_name: table_name.to_string(),
+            kind: Some(Kind::DropColumns(DropColumns {
+                drop_columns: vec![DropColumn {
+                    name: "cpu".to_string(),
+                }],
+            })),
+        },
+    };
+    let procedure_id = ProcedureId::random();
+    let mut procedure =
+        AlterTableProcedure::new(table_id, alter_table_task, ddl_context.clone()).unwrap();
+    procedure.on_prepare().await.unwrap();
+    (procedure, procedure_id)
+}
+
+#[tokio::test]
+async fn test_on_submit_alter_request_with_partial_success_retryable() {
+    let node_manager = Arc::new(MockDatanodeManager::new(PartialSuccessDatanodeHandler {
+        retryable: true,
+    }));
+    let provider = Arc::new(MockContextProvider::default());
+    let (mut procedure, procedure_id) = prepare_alter_table_procedure(node_manager).await;
+    let result = procedure
+        .submit_alter_region_requests(procedure_id, provider.as_ref())
+        .await
+        .unwrap_err();
+    assert!(result.is_retry_later());
+
+    // Submits again
+    let result = procedure
+        .submit_alter_region_requests(procedure_id, provider.as_ref())
+        .await
+        .unwrap_err();
+    assert!(result.is_retry_later());
+}
+
+#[tokio::test]
+async fn test_on_submit_alter_request_with_partial_success_non_retryable() {
+    let node_manager = Arc::new(MockDatanodeManager::new(PartialSuccessDatanodeHandler {
+        retryable: false,
+    }));
+    let provider = Arc::new(MockContextProvider::default());
+    let (mut procedure, procedure_id) = prepare_alter_table_procedure(node_manager).await;
+    let result = procedure
+        .submit_alter_region_requests(procedure_id, provider.as_ref())
+        .await
+        .unwrap();
+    assert_matches!(result, Status::Poisoned { .. });
+
+    // submits again
+    let result = procedure
+        .submit_alter_region_requests(procedure_id, provider.as_ref())
+        .await
+        .unwrap();
+    assert_matches!(result, Status::Poisoned { .. });
+}
+
+#[tokio::test]
+async fn test_on_submit_alter_request_with_all_failure_retrybale() {
+    common_telemetry::init_default_ut_logging();
+    let node_manager = Arc::new(MockDatanodeManager::new(AllFailureDatanodeHandler {
+        retryable: true,
+    }));
+    let provider = Arc::new(MockContextProvider::default());
+    let (mut procedure, procedure_id) = prepare_alter_table_procedure(node_manager).await;
+    let err = procedure
+        .submit_alter_region_requests(procedure_id, provider.as_ref())
+        .await
+        .unwrap_err();
+    assert!(err.is_retry_later());
+    // submits again
+    let err = procedure
+        .submit_alter_region_requests(procedure_id, provider.as_ref())
+        .await
+        .unwrap_err();
+    assert!(err.is_retry_later());
+}
+
+#[tokio::test]
+async fn test_on_submit_alter_request_with_all_failure_non_retrybale() {
+    common_telemetry::init_default_ut_logging();
+    let node_manager = Arc::new(MockDatanodeManager::new(AllFailureDatanodeHandler {
+        retryable: false,
+    }));
+    let provider = Arc::new(MockContextProvider::default());
+    let (mut procedure, procedure_id) = prepare_alter_table_procedure(node_manager).await;
+    let err = procedure
+        .submit_alter_region_requests(procedure_id, provider.as_ref())
+        .await
+        .unwrap_err();
+    assert_matches!(err, Error::AbortProcedure { .. });
+    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_matches!(err, Error::AbortProcedure { .. });
+    assert!(!err.is_retry_later());
+    assert!(err.need_clean_poisons());
+}
+
+#[tokio::test]
+async fn test_on_submit_alter_request_with_exist_poison() {
+    common_telemetry::init_default_ut_logging();
+    let node_manager = Arc::new(MockDatanodeManager::new(AllFailureDatanodeHandler {
+        retryable: false,
+    }));
+    let provider = Arc::new(MockContextProvider::default());
+    let (mut procedure, procedure_id) = prepare_alter_table_procedure(node_manager).await;
+
+    let table_id = 1024;
+    let key = table_poison_key(table_id).to_string();
+    let another_procedure_id = ProcedureId::random();
+    provider
+        .poison_manager()
+        .try_put_poison(key, another_procedure_id.to_string())
+        .await
+        .unwrap();
+
+    procedure.on_prepare().await.unwrap();
+    let err = procedure
+        .submit_alter_region_requests(procedure_id, provider.as_ref())
+        .await
+        .unwrap_err();
+    assert_matches!(err, Error::PutPoison { .. });
+}
--- a/src/common/meta/src/ddl/tests/create_logical_tables.rs
+++ b/src/common/meta/src/ddl/tests/create_logical_tables.rs
@@ -69,7 +69,13 @@ async fn test_on_prepare() {
    let physical_table_id = table_id;
    let mut procedure = CreateLogicalTablesProcedure::new(tasks, physical_table_id, ddl_context);
    let status = procedure.on_prepare().await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );
 }

 #[tokio::test]
@@ -202,7 +208,13 @@ async fn test_on_prepare_part_logical_tables_exist() {
        ddl_context,
    );
    let status = procedure.on_prepare().await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );
 }

 #[tokio::test]
@@ -238,7 +250,13 @@ async fn test_on_create_metadata() {
        ddl_context,
    );
    let status = procedure.on_prepare().await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );
    let ctx = ProcedureContext {
        procedure_id: ProcedureId::random(),
        provider: Arc::new(MockContextProvider::default()),
@@ -294,7 +312,13 @@ async fn test_on_create_metadata_part_logical_tables_exist() {
        ddl_context,
    );
    let status = procedure.on_prepare().await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );
    let ctx = ProcedureContext {
        procedure_id: ProcedureId::random(),
        provider: Arc::new(MockContextProvider::default()),
@@ -339,7 +363,13 @@ async fn test_on_create_metadata_err() {
        ddl_context.clone(),
    );
    let status = procedure.on_prepare().await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );
    let ctx = ProcedureContext {
        procedure_id: ProcedureId::random(),
        provider: Arc::new(MockContextProvider::default()),
--- a/src/common/meta/src/ddl/tests/create_table.rs
+++ b/src/common/meta/src/ddl/tests/create_table.rs
@@ -137,7 +137,13 @@ async fn test_on_prepare_without_create_if_table_exists() {
    task.create_table.create_if_not_exists = true;
    let mut procedure = CreateTableProcedure::new(task, ddl_context);
    let status = procedure.on_prepare().await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );
    assert_eq!(procedure.table_id(), 1024);
 }

--- a/src/common/meta/src/ddl/tests/create_view.rs
+++ b/src/common/meta/src/ddl/tests/create_view.rs
@@ -153,7 +153,13 @@ async fn test_on_prepare_without_create_if_table_exists() {
    task.create_view.create_if_not_exists = true;
    let mut procedure = CreateViewProcedure::new(task, ddl_context);
    let status = procedure.on_prepare().await.unwrap();
-    assert_matches!(status, Status::Executing { persist: true });
+    assert_matches!(
+        status,
+        Status::Executing {
+            persist: true,
+            clean_poisons: false
+        }
+    );
    assert_eq!(procedure.view_id(), 1024);
 }

--- a/src/common/meta/src/ddl/utils.rs
+++ b/src/common/meta/src/ddl/utils.rs
@@ -13,10 +13,12 @@
 // limitations under the License.

 use std::collections::HashMap;
+use std::fmt::Debug;

 use common_catalog::consts::METRIC_ENGINE;
 use common_error::ext::BoxedError;
 use common_procedure::error::Error as ProcedureError;
+use common_telemetry::{error, warn};
 use common_wal::options::WalOptions;
 use snafu::{ensure, OptionExt, ResultExt};
 use store_api::metric_engine_consts::LOGICAL_TABLE_METADATA_KEY;
@@ -38,6 +40,7 @@ use crate::rpc::router::RegionRoute;
 /// Adds [Peer] context if the error is unretryable.
 pub fn add_peer_context_if_needed(datanode: Peer) -> impl FnOnce(Error) -> Error {
    move |err| {
+        error!(err; "Failed to operate datanode, peer: {}", datanode);
        if !err.is_retry_later() {
            return Err::<(), BoxedError>(BoxedError::new(err))
                .context(OperateDatanodeSnafu { peer: datanode })
@@ -182,6 +185,85 @@ pub fn extract_region_wal_options(
    Ok(region_wal_options)
 }

+/// The result of multiple operations.
+///
+/// - Ok: all operations are successful.
+/// - PartialRetryable: if any operation is retryable and without non retryable error, the result is retryable.
+/// - PartialNonRetryable: if any operation is non retryable, the result is non retryable.
+/// - AllRetryable: all operations are retryable.
+/// - AllNonRetryable: all operations are not retryable.
+pub enum MultipleResults {
+    Ok,
+    PartialRetryable(Error),
+    PartialNonRetryable(Error),
+    AllRetryable(Error),
+    AllNonRetryable(Error),
+}
+
+/// Handles the results of alter region requests.
+///
+/// For partial success, we need to check if the errors are retryable.
+/// If all the errors are retryable, we return a retryable error.
+/// Otherwise, we return the first error.
+pub fn handle_multiple_results<T: Debug>(results: Vec<Result<T>>) -> MultipleResults {
+    if results.is_empty() {
+        return MultipleResults::Ok;
+    }
+    let num_results = results.len();
+    let mut retryable_results = Vec::new();
+    let mut non_retryable_results = Vec::new();
+    let mut ok_results = Vec::new();
+
+    for result in results {
+        match result {
+            Ok(_) => ok_results.push(result),
+            Err(err) => {
+                if err.is_retry_later() {
+                    retryable_results.push(err);
+                } else {
+                    non_retryable_results.push(err);
+                }
+            }
+        }
+    }
+
+    common_telemetry::debug!(
+        "retryable_results: {}, non_retryable_results: {}, ok_results: {}",
+        retryable_results.len(),
+        non_retryable_results.len(),
+        ok_results.len()
+    );
+
+    if retryable_results.len() == num_results {
+        return MultipleResults::AllRetryable(retryable_results.into_iter().next().unwrap());
+    } else if non_retryable_results.len() == num_results {
+        warn!("all non retryable results: {}", non_retryable_results.len());
+        for err in &non_retryable_results {
+            error!(err; "non retryable error");
+        }
+        return MultipleResults::AllNonRetryable(non_retryable_results.into_iter().next().unwrap());
+    } else if ok_results.len() == num_results {
+        return MultipleResults::Ok;
+    } else if !retryable_results.is_empty()
+        && !ok_results.is_empty()
+        && non_retryable_results.is_empty()
+    {
+        return MultipleResults::PartialRetryable(retryable_results.into_iter().next().unwrap());
+    }
+
+    warn!(
+        "partial non retryable results: {}, retryable results: {}, ok results: {}",
+        non_retryable_results.len(),
+        retryable_results.len(),
+        ok_results.len()
+    );
+    for err in &non_retryable_results {
+        error!(err; "non retryable error");
+    }
+    // non_retryable_results.len() > 0
+    MultipleResults::PartialNonRetryable(non_retryable_results.into_iter().next().unwrap())
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
--- a/src/common/meta/src/ddl_manager.rs
+++ b/src/common/meta/src/ddl_manager.rs
@@ -834,6 +834,7 @@ mod tests {
    use std::sync::Arc;

    use common_procedure::local::LocalManager;
+    use common_procedure::test_util::InMemoryPoisonStore;

    use super::DdlManager;
    use crate::cache_invalidator::DummyCacheInvalidator;
@@ -882,7 +883,12 @@ mod tests {
        ));

        let state_store = Arc::new(KvStateStore::new(kv_backend.clone()));
-        let procedure_manager = Arc::new(LocalManager::new(Default::default(), state_store));
+        let poison_manager = Arc::new(InMemoryPoisonStore::default());
+        let procedure_manager = Arc::new(LocalManager::new(
+            Default::default(),
+            state_store,
+            poison_manager,
+        ));

        let _ = DdlManager::try_new(
            DdlContext {
--- a/src/common/meta/src/error.rs
+++ b/src/common/meta/src/error.rs
@@ -449,6 +449,14 @@ pub enum Error {
    #[snafu(display("Retry later"))]
    RetryLater { source: BoxedError },

+    #[snafu(display("Abort procedure"))]
+    AbortProcedure {
+        #[snafu(implicit)]
+        location: Location,
+        source: BoxedError,
+        clean_poisons: bool,
+    },
+
    #[snafu(display(
        "Failed to encode a wal options to json string, wal_options: {:?}",
        wal_options
@@ -685,7 +693,36 @@ pub enum Error {
        operation: String,
    },

-    #[cfg(feature = "pg_kvbackend")]
+    #[cfg(feature = "mysql_kvbackend")]
+    #[snafu(display("Failed to execute via MySql, sql: {}", sql))]
+    MySqlExecution {
+        sql: String,
+        #[snafu(source)]
+        error: sqlx::Error,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[cfg(feature = "mysql_kvbackend")]
+    #[snafu(display("Failed to create connection pool for MySql"))]
+    CreateMySqlPool {
+        #[snafu(source)]
+        error: sqlx::Error,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[cfg(feature = "mysql_kvbackend")]
+    #[snafu(display("Failed to {} MySql transaction", operation))]
+    MySqlTransaction {
+        #[snafu(source)]
+        error: sqlx::Error,
+        #[snafu(implicit)]
+        location: Location,
+        operation: String,
+    },
+
+    #[cfg(any(feature = "pg_kvbackend", feature = "mysql_kvbackend"))]
    #[snafu(display("Rds transaction retry failed"))]
    RdsTransactionRetryFailed {
        #[snafu(implicit)]
@@ -719,6 +756,33 @@ pub enum Error {
        #[snafu(source)]
        error: serde_json::Error,
    },
+
+    #[snafu(display("No leader found for table_id: {}", table_id))]
+    NoLeader {
+        table_id: TableId,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display(
+        "Procedure poison key already exists with a different value, key: {}, value: {}",
+        key,
+        value
+    ))]
+    ProcedurePoisonConflict {
+        key: String,
+        value: String,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display("Failed to put poison, table metadata may be corrupted"))]
+    PutPoison {
+        #[snafu(implicit)]
+        location: Location,
+        #[snafu(source)]
+        source: common_procedure::error::Error,
+    },
 }

 pub type Result<T> = std::result::Result<T, Error>;
@@ -737,7 +801,8 @@ impl ErrorExt for Error {
            | SerializeToJson { .. }
            | DeserializeFromJson { .. } => StatusCode::Internal,

-            ValueNotExist { .. } => StatusCode::Unexpected,
+            NoLeader { .. } => StatusCode::TableUnavailable,
+            ValueNotExist { .. } | ProcedurePoisonConflict { .. } => StatusCode::Unexpected,

            Unsupported { .. } => StatusCode::Unsupported,

@@ -808,7 +873,9 @@ impl ErrorExt for Error {
            OperateDatanode { source, .. } => source.status_code(),
            Table { source, .. } => source.status_code(),
            RetryLater { source, .. } => source.status_code(),
+            AbortProcedure { source, .. } => source.status_code(),
            ConvertAlterTableRequest { source, .. } => source.status_code(),
+            PutPoison { source, .. } => source.status_code(),

            ParseProcedureId { .. }
            | InvalidNumTopics { .. }
@@ -823,8 +890,13 @@ impl ErrorExt for Error {
            PostgresExecution { .. }
            | CreatePostgresPool { .. }
            | GetPostgresConnection { .. }
-            | PostgresTransaction { .. }
-            | RdsTransactionRetryFailed { .. } => StatusCode::Internal,
+            | PostgresTransaction { .. } => StatusCode::Internal,
+            #[cfg(feature = "mysql_kvbackend")]
+            MySqlExecution { .. } | CreateMySqlPool { .. } | MySqlTransaction { .. } => {
+                StatusCode::Internal
+            }
+            #[cfg(any(feature = "pg_kvbackend", feature = "mysql_kvbackend"))]
+            RdsTransactionRetryFailed { .. } => StatusCode::Internal,
            Error::DatanodeTableInfoNotFound { .. } => StatusCode::Internal,
        }
    }
@@ -835,16 +907,29 @@ impl ErrorExt for Error {
 }

 impl Error {
-    #[cfg(feature = "pg_kvbackend")]
+    #[cfg(any(feature = "pg_kvbackend", feature = "mysql_kvbackend"))]
    /// Check if the error is a serialization error.
    pub fn is_serialization_error(&self) -> bool {
        match self {
+            #[cfg(feature = "pg_kvbackend")]
            Error::PostgresTransaction { error, .. } => {
                error.code() == Some(&tokio_postgres::error::SqlState::T_R_SERIALIZATION_FAILURE)
            }
+            #[cfg(feature = "pg_kvbackend")]
            Error::PostgresExecution { error, .. } => {
                error.code() == Some(&tokio_postgres::error::SqlState::T_R_SERIALIZATION_FAILURE)
            }
+            #[cfg(feature = "mysql_kvbackend")]
+            Error::MySqlExecution {
+                error: sqlx::Error::Database(database_error),
+                ..
+            } => {
+                matches!(
+                    database_error.message(),
+                    "Deadlock found when trying to get lock; try restarting transaction"
+                        | "can't serialize access for this transaction"
+                )
+            }
            _ => false,
        }
    }
@@ -861,6 +946,11 @@ impl Error {
        matches!(self, Error::RetryLater { .. })
    }

+    /// Determine whether it needs to clean poisons.
+    pub fn need_clean_poisons(&self) -> bool {
+        matches!(self, Error::AbortProcedure { clean_poisons, .. } if *clean_poisons)
+    }
+
    /// Returns true if the response exceeds the size limit.
    pub fn is_exceeded_size_limit(&self) -> bool {
        match self {
--- a/src/common/meta/src/key.rs
+++ b/src/common/meta/src/key.rs
@@ -156,6 +156,7 @@ use crate::kv_backend::txn::{Txn, TxnOp};
 use crate::kv_backend::KvBackendRef;
 use crate::rpc::router::{region_distribution, LeaderState, RegionRoute};
 use crate::rpc::store::BatchDeleteRequest;
+use crate::state_store::PoisonValue;
 use crate::DatanodeId;

 pub const NAME_PATTERN: &str = r"[a-zA-Z_:-][a-zA-Z0-9_:\-\.@#]*";
@@ -1320,7 +1321,8 @@ impl_metadata_value! {
    TableFlowValue,
    NodeAddressValue,
    SchemaNameValue,
-    FlowStateValue
+    FlowStateValue,
+    PoisonValue
 }

 impl_optional_metadata_value! {
--- a/src/common/meta/src/key/flow.rs
+++ b/src/common/meta/src/key/flow.rs
@@ -461,6 +461,8 @@ mod tests {
            expire_after: Some(300),
            comment: "hi".to_string(),
            options: Default::default(),
+            created_time: chrono::Utc::now(),
+            updated_time: chrono::Utc::now(),
        }
    }

@@ -632,6 +634,8 @@ mod tests {
            expire_after: Some(300),
            comment: "hi".to_string(),
            options: Default::default(),
+            created_time: chrono::Utc::now(),
+            updated_time: chrono::Utc::now(),
        };
        let err = flow_metadata_manager
            .create_flow_metadata(flow_id, flow_value, flow_routes.clone())
@@ -869,6 +873,8 @@ mod tests {
            expire_after: Some(300),
            comment: "hi".to_string(),
            options: Default::default(),
+            created_time: chrono::Utc::now(),
+            updated_time: chrono::Utc::now(),
        };
        let err = flow_metadata_manager
            .update_flow_metadata(
--- a/src/common/meta/src/key/flow/flow_info.rs
+++ b/src/common/meta/src/key/flow/flow_info.rs
@@ -15,6 +15,7 @@
 use std::collections::{BTreeMap, HashMap};
 use std::sync::Arc;

+use chrono::{DateTime, Utc};
 use lazy_static::lazy_static;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
@@ -131,6 +132,12 @@ pub struct FlowInfoValue {
    pub(crate) comment: String,
    /// The options.
    pub(crate) options: HashMap<String, String>,
+    /// The created time
+    #[serde(default)]
+    pub(crate) created_time: DateTime<Utc>,
+    /// The updated time.
+    #[serde(default)]
+    pub(crate) updated_time: DateTime<Utc>,
 }

 impl FlowInfoValue {
@@ -171,6 +178,14 @@ impl FlowInfoValue {
    pub fn options(&self) -> &HashMap<String, String> {
        &self.options
    }
+
+    pub fn created_time(&self) -> &DateTime<Utc> {
+        &self.created_time
+    }
+
+    pub fn updated_time(&self) -> &DateTime<Utc> {
+        &self.updated_time
+    }
 }

 pub type FlowInfoManagerRef = Arc<FlowInfoManager>;
--- a/src/common/meta/src/key/flow/flow_state.rs
+++ b/src/common/meta/src/key/flow/flow_state.rs
@@ -97,11 +97,19 @@ impl<'a> MetadataKey<'a, FlowStateKey> for FlowStateKey {
 pub struct FlowStateValue {
    /// For each key, the bytes of the state in memory
    pub state_size: BTreeMap<FlowId, usize>,
+    /// For each key, the last execution time of flow in unix timestamp milliseconds.
+    pub last_exec_time_map: BTreeMap<FlowId, i64>,
 }

 impl FlowStateValue {
-    pub fn new(state_size: BTreeMap<FlowId, usize>) -> Self {
-        Self { state_size }
+    pub fn new(
+        state_size: BTreeMap<FlowId, usize>,
+        last_exec_time_map: BTreeMap<FlowId, i64>,
+    ) -> Self {
+        Self {
+            state_size,
+            last_exec_time_map,
+        }
    }
 }

@@ -143,12 +151,15 @@ impl FlowStateManager {
 pub struct FlowStat {
    /// For each key, the bytes of the state in memory
    pub state_size: BTreeMap<u32, usize>,
+    /// For each key, the last execution time of flow in unix timestamp milliseconds.
+    pub last_exec_time_map: BTreeMap<FlowId, i64>,
 }

 impl From<FlowStateValue> for FlowStat {
    fn from(value: FlowStateValue) -> Self {
        Self {
            state_size: value.state_size,
+            last_exec_time_map: value.last_exec_time_map,
        }
    }
 }
@@ -157,6 +168,7 @@ impl From<FlowStat> for FlowStateValue {
    fn from(value: FlowStat) -> Self {
        Self {
            state_size: value.state_size,
+            last_exec_time_map: value.last_exec_time_map,
        }
    }
 }
--- a/src/common/meta/src/key/test_utils.rs
+++ b/src/common/meta/src/key/test_utils.rs
@@ -40,7 +40,7 @@ pub fn new_test_table_info_with_name<I: IntoIterator<Item = u32>>(
        .build()
        .unwrap();

-    let meta = TableMetaBuilder::default()
+    let meta = TableMetaBuilder::empty()
        .schema(Arc::new(schema))
        .primary_key_indices(vec![0])
        .engine("engine")
--- a/src/common/meta/src/kv_backend.rs
+++ b/src/common/meta/src/kv_backend.rs
@@ -31,7 +31,7 @@ use crate::rpc::KeyValue;
 pub mod chroot;
 pub mod etcd;
 pub mod memory;
-#[cfg(feature = "pg_kvbackend")]
+#[cfg(any(feature = "mysql_kvbackend", feature = "pg_kvbackend"))]
 pub mod rds;
 pub mod test;
 pub mod txn;
--- a/src/common/meta/src/kv_backend/memory.rs
+++ b/src/common/meta/src/kv_backend/memory.rs
@@ -14,13 +14,11 @@

 use std::any::Any;
 use std::collections::BTreeMap;
-use std::fmt::{Display, Formatter};
 use std::marker::PhantomData;
 use std::sync::{Arc, RwLock};

 use async_trait::async_trait;
 use common_error::ext::ErrorExt;
-use serde::Serializer;

 use super::{KvBackendRef, ResettableKvBackend};
 use crate::kv_backend::txn::{Txn, TxnOp, TxnOpResponse, TxnRequest, TxnResponse};
@@ -38,19 +36,6 @@ pub struct MemoryKvBackend<T> {
    _phantom: PhantomData<T>,
 }

-impl<T> Display for MemoryKvBackend<T> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let kvs = self.kvs.read().unwrap();
-        for (k, v) in kvs.iter() {
-            f.serialize_str(&String::from_utf8_lossy(k))?;
-            f.serialize_str(" -> ")?;
-            f.serialize_str(&String::from_utf8_lossy(v))?;
-            f.serialize_str("\n")?;
-        }
-        Ok(())
-    }
-}
-
 impl<T> Default for MemoryKvBackend<T> {
    fn default() -> Self {
        Self {
--- a/src/common/meta/src/kv_backend/rds.rs
+++ b/src/common/meta/src/kv_backend/rds.rs
@@ -33,10 +33,16 @@ use crate::rpc::store::{
 };
 use crate::rpc::KeyValue;

+#[cfg(feature = "pg_kvbackend")]
 mod postgres;
-
+#[cfg(feature = "pg_kvbackend")]
 pub use postgres::PgStore;

+#[cfg(feature = "mysql_kvbackend")]
+mod mysql;
+#[cfg(feature = "mysql_kvbackend")]
+pub use mysql::MySqlStore;
+
 const RDS_STORE_TXN_RETRY_COUNT: usize = 3;

 /// Query executor for rds. It can execute queries or generate a transaction executor.
@@ -106,6 +112,14 @@ impl<T: Executor> ExecutorImpl<'_, T> {
        }
    }

+    #[warn(dead_code)] // Used in #[cfg(feature = "mysql_kvbackend")]
+    async fn execute(&mut self, query: &str, params: &Vec<&Vec<u8>>) -> Result<()> {
+        match self {
+            Self::Default(executor) => executor.execute(query, params).await,
+            Self::Txn(executor) => executor.execute(query, params).await,
+        }
+    }
+
    async fn commit(self) -> Result<()> {
        match self {
            Self::Txn(executor) => executor.commit().await,
--- a/src/common/meta/src/kv_backend/rds/mysql.rs
+++ b/src/common/meta/src/kv_backend/rds/mysql.rs
@@ -0,0 +1,653 @@
+// 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::marker::PhantomData;
+use std::sync::Arc;
+
+use common_telemetry::debug;
+use snafu::ResultExt;
+use sqlx::mysql::MySqlRow;
+use sqlx::pool::Pool;
+use sqlx::{MySql, MySqlPool, Row, Transaction as MySqlTransaction};
+
+use crate::error::{CreateMySqlPoolSnafu, MySqlExecutionSnafu, MySqlTransactionSnafu, Result};
+use crate::kv_backend::rds::{
+    Executor, ExecutorFactory, ExecutorImpl, KvQueryExecutor, RdsStore, Transaction,
+    RDS_STORE_TXN_RETRY_COUNT,
+};
+use crate::kv_backend::KvBackendRef;
+use crate::rpc::store::{
+    BatchDeleteRequest, BatchDeleteResponse, BatchGetRequest, BatchGetResponse, BatchPutRequest,
+    BatchPutResponse, DeleteRangeRequest, DeleteRangeResponse, RangeRequest, RangeResponse,
+};
+use crate::rpc::KeyValue;
+
+type MySqlClient = Arc<Pool<MySql>>;
+pub struct MySqlTxnClient(MySqlTransaction<'static, MySql>);
+
+fn key_value_from_row(row: MySqlRow) -> KeyValue {
+    // Safety: key and value are the first two columns in the row
+    KeyValue {
+        key: row.get_unchecked(0),
+        value: row.get_unchecked(1),
+    }
+}
+
+const EMPTY: &[u8] = &[0];
+
+/// Type of range template.
+#[derive(Debug, Clone, Copy)]
+enum RangeTemplateType {
+    Point,
+    Range,
+    Full,
+    LeftBounded,
+    Prefix,
+}
+
+/// Builds params for the given range template type.
+impl RangeTemplateType {
+    fn build_params(&self, mut key: Vec<u8>, range_end: Vec<u8>) -> Vec<Vec<u8>> {
+        match self {
+            RangeTemplateType::Point => vec![key],
+            RangeTemplateType::Range => vec![key, range_end],
+            RangeTemplateType::Full => vec![],
+            RangeTemplateType::LeftBounded => vec![key],
+            RangeTemplateType::Prefix => {
+                key.push(b'%');
+                vec![key]
+            }
+        }
+    }
+}
+
+/// Templates for range request.
+#[derive(Debug, Clone)]
+struct RangeTemplate {
+    point: String,
+    range: String,
+    full: String,
+    left_bounded: String,
+    prefix: String,
+}
+
+impl RangeTemplate {
+    /// Gets the template for the given type.
+    fn get(&self, typ: RangeTemplateType) -> &str {
+        match typ {
+            RangeTemplateType::Point => &self.point,
+            RangeTemplateType::Range => &self.range,
+            RangeTemplateType::Full => &self.full,
+            RangeTemplateType::LeftBounded => &self.left_bounded,
+            RangeTemplateType::Prefix => &self.prefix,
+        }
+    }
+
+    /// Adds limit to the template.
+    fn with_limit(template: &str, limit: i64) -> String {
+        if limit == 0 {
+            return format!("{};", template);
+        }
+        format!("{} LIMIT {};", template, limit)
+    }
+}
+
+fn is_prefix_range(start: &[u8], end: &[u8]) -> bool {
+    if start.len() != end.len() {
+        return false;
+    }
+    let l = start.len();
+    let same_prefix = start[0..l - 1] == end[0..l - 1];
+    if let (Some(rhs), Some(lhs)) = (start.last(), end.last()) {
+        return same_prefix && (*rhs + 1) == *lhs;
+    }
+    false
+}
+
+/// Determine the template type for range request.
+fn range_template(key: &[u8], range_end: &[u8]) -> RangeTemplateType {
+    match (key, range_end) {
+        (_, &[]) => RangeTemplateType::Point,
+        (EMPTY, EMPTY) => RangeTemplateType::Full,
+        (_, EMPTY) => RangeTemplateType::LeftBounded,
+        (start, end) => {
+            if is_prefix_range(start, end) {
+                RangeTemplateType::Prefix
+            } else {
+                RangeTemplateType::Range
+            }
+        }
+    }
+}
+
+/// Generate in placeholders for MySQL.
+fn mysql_generate_in_placeholders(from: usize, to: usize) -> Vec<String> {
+    (from..=to).map(|_| "?".to_string()).collect()
+}
+
+/// Factory for building sql templates.
+struct MySqlTemplateFactory<'a> {
+    table_name: &'a str,
+}
+
+impl<'a> MySqlTemplateFactory<'a> {
+    /// Creates a new [`SqlTemplateFactory`] with the given table name.
+    fn new(table_name: &'a str) -> Self {
+        Self { table_name }
+    }
+
+    /// Builds the template set for the given table name.
+    fn build(&self) -> MySqlTemplateSet {
+        let table_name = self.table_name;
+        // Some of queries don't end with `;`, because we need to add `LIMIT` clause.
+        MySqlTemplateSet {
+            table_name: table_name.to_string(),
+            create_table_statement: format!(
+                // Cannot be more than 3072 bytes in PRIMARY KEY
+                "CREATE TABLE IF NOT EXISTS {table_name}(k VARBINARY(3072) PRIMARY KEY, v BLOB);",
+            ),
+            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"),
+                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"),
+            },
+            delete_template: RangeTemplate {
+                point: format!("DELETE FROM `{table_name}` WHERE k = ?;"),
+                range: format!("DELETE FROM `{table_name}` WHERE k >= ? AND k < ?;"),
+                full: format!("DELETE FROM `{table_name}`"),
+                left_bounded: format!("DELETE FROM `{table_name}` WHERE k >= ?;"),
+                prefix: format!("DELETE FROM `{table_name}` WHERE k LIKE ?;"),
+            },
+        }
+    }
+}
+
+/// Templates for the given table name.
+#[derive(Debug, Clone)]
+pub struct MySqlTemplateSet {
+    table_name: String,
+    create_table_statement: String,
+    range_template: RangeTemplate,
+    delete_template: RangeTemplate,
+}
+
+impl MySqlTemplateSet {
+    /// Generates the sql for batch get.
+    fn generate_batch_get_query(&self, key_len: usize) -> String {
+        let table_name = &self.table_name;
+        let in_clause = mysql_generate_in_placeholders(1, key_len).join(", ");
+        format!(
+            "SELECT k, v FROM `{table_name}` WHERE k in ({});",
+            in_clause
+        )
+    }
+
+    /// Generates the sql for batch delete.
+    fn generate_batch_delete_query(&self, key_len: usize) -> String {
+        let table_name = &self.table_name;
+        let in_clause = mysql_generate_in_placeholders(1, key_len).join(", ");
+        format!("DELETE FROM `{table_name}` WHERE k in ({});", in_clause)
+    }
+
+    /// Generates the sql for batch upsert.
+    /// For MySQL, it also generates a select query to get the previous values.
+    fn generate_batch_upsert_query(&self, kv_len: usize) -> (String, String) {
+        let table_name = &self.table_name;
+        let in_placeholders: Vec<String> = (1..=kv_len).map(|_| "?".to_string()).collect();
+        let in_clause = in_placeholders.join(", ");
+        let mut values_placeholders = Vec::new();
+        for _ in 0..kv_len {
+            values_placeholders.push("(?, ?)".to_string());
+        }
+        let values_clause = values_placeholders.join(", ");
+
+        (
+            format!(r#"SELECT k, v FROM `{table_name}` WHERE k IN ({in_clause})"#,),
+            format!(
+                r#"INSERT INTO `{table_name}` (k, v) VALUES {values_clause} ON DUPLICATE KEY UPDATE v = VALUES(v);"#,
+            ),
+        )
+    }
+}
+
+#[async_trait::async_trait]
+impl Executor for MySqlClient {
+    type Transaction<'a>
+        = MySqlTxnClient
+    where
+        Self: 'a;
+
+    fn name() -> &'static str {
+        "MySql"
+    }
+
+    async fn query(&mut self, raw_query: &str, params: &[&Vec<u8>]) -> Result<Vec<KeyValue>> {
+        let query = sqlx::query(raw_query);
+        let query = params.iter().fold(query, |query, param| query.bind(param));
+        let rows = query
+            .fetch_all(&**self)
+            .await
+            .context(MySqlExecutionSnafu { sql: raw_query })?;
+        Ok(rows.into_iter().map(key_value_from_row).collect())
+    }
+
+    async fn execute(&mut self, raw_query: &str, params: &[&Vec<u8>]) -> Result<()> {
+        let query = sqlx::query(raw_query);
+        let query = params.iter().fold(query, |query, param| query.bind(param));
+        query
+            .execute(&**self)
+            .await
+            .context(MySqlExecutionSnafu { sql: raw_query })?;
+        Ok(())
+    }
+
+    async fn txn_executor<'a>(&'a mut self) -> Result<Self::Transaction<'a>> {
+        // sqlx has no isolation level support for now, so we have to set it manually.
+        // TODO(CookiePie): Waiting for https://github.com/launchbadge/sqlx/pull/3614 and remove this.
+        sqlx::query("SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE")
+            .execute(&**self)
+            .await
+            .context(MySqlExecutionSnafu {
+                sql: "SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE",
+            })?;
+        let txn = self
+            .begin()
+            .await
+            .context(MySqlExecutionSnafu { sql: "begin" })?;
+        Ok(MySqlTxnClient(txn))
+    }
+}
+
+#[async_trait::async_trait]
+impl Transaction<'_> for MySqlTxnClient {
+    async fn query(&mut self, raw_query: &str, params: &[&Vec<u8>]) -> Result<Vec<KeyValue>> {
+        let query = sqlx::query(raw_query);
+        let query = params.iter().fold(query, |query, param| query.bind(param));
+        // As said in https://docs.rs/sqlx/latest/sqlx/trait.Executor.html, we need a `&mut *transaction`. Weird.
+        let rows = query
+            .fetch_all(&mut *(self.0))
+            .await
+            .context(MySqlExecutionSnafu { sql: raw_query })?;
+        Ok(rows.into_iter().map(key_value_from_row).collect())
+    }
+
+    async fn execute(&mut self, raw_query: &str, params: &[&Vec<u8>]) -> Result<()> {
+        let query = sqlx::query(raw_query);
+        let query = params.iter().fold(query, |query, param| query.bind(param));
+        // As said in https://docs.rs/sqlx/latest/sqlx/trait.Executor.html, we need a `&mut *transaction`. Weird.
+        query
+            .execute(&mut *(self.0))
+            .await
+            .context(MySqlExecutionSnafu { sql: raw_query })?;
+        Ok(())
+    }
+
+    /// Caution: sqlx will stuck on the query if two transactions conflict with each other.
+    /// Don't know if it's a feature or it depends on the database. Be careful.
+    async fn commit(self) -> Result<()> {
+        self.0.commit().await.context(MySqlTransactionSnafu {
+            operation: "commit",
+        })?;
+        Ok(())
+    }
+}
+
+pub struct MySqlExecutorFactory {
+    pool: Arc<Pool<MySql>>,
+}
+
+#[async_trait::async_trait]
+impl ExecutorFactory<MySqlClient> for MySqlExecutorFactory {
+    async fn default_executor(&self) -> Result<MySqlClient> {
+        Ok(self.pool.clone())
+    }
+
+    async fn txn_executor<'a>(
+        &self,
+        default_executor: &'a mut MySqlClient,
+    ) -> Result<MySqlTxnClient> {
+        default_executor.txn_executor().await
+    }
+}
+
+/// A MySQL-backed key-value store.
+/// It uses [sqlx::Pool<MySql>] as the connection pool for [RdsStore].
+pub type MySqlStore = RdsStore<MySqlClient, MySqlExecutorFactory, MySqlTemplateSet>;
+
+#[async_trait::async_trait]
+impl KvQueryExecutor<MySqlClient> for MySqlStore {
+    async fn range_with_query_executor(
+        &self,
+        query_executor: &mut ExecutorImpl<'_, MySqlClient>,
+        req: RangeRequest,
+    ) -> Result<RangeResponse> {
+        let template_type = range_template(&req.key, &req.range_end);
+        let template = self.sql_template_set.range_template.get(template_type);
+        let params = template_type.build_params(req.key, req.range_end);
+        let params_ref = params.iter().collect::<Vec<_>>();
+        // Always add 1 to limit to check if there is more data
+        let query =
+            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 = query_executor.query(&query, &params_ref).await?;
+        if req.keys_only {
+            kvs.iter_mut().for_each(|kv| kv.value = vec![]);
+        }
+        // If limit is 0, we always return all data
+        if limit == 0 || kvs.len() <= limit {
+            return Ok(RangeResponse { kvs, more: false });
+        }
+        // If limit is greater than the number of rows, we remove the last row and set more to true
+        let removed = kvs.pop();
+        debug_assert!(removed.is_some());
+        Ok(RangeResponse { kvs, more: true })
+    }
+
+    async fn batch_put_with_query_executor(
+        &self,
+        query_executor: &mut ExecutorImpl<'_, MySqlClient>,
+        req: BatchPutRequest,
+    ) -> Result<BatchPutResponse> {
+        let mut in_params = Vec::with_capacity(req.kvs.len() * 3);
+        let mut values_params = Vec::with_capacity(req.kvs.len() * 2);
+
+        for kv in &req.kvs {
+            let processed_key = &kv.key;
+            in_params.push(processed_key);
+
+            let processed_value = &kv.value;
+            values_params.push(processed_key);
+            values_params.push(processed_value);
+        }
+        let in_params = in_params.iter().map(|x| x as _).collect::<Vec<_>>();
+        let values_params = values_params.iter().map(|x| x as _).collect::<Vec<_>>();
+        let (select, update) = self
+            .sql_template_set
+            .generate_batch_upsert_query(req.kvs.len());
+
+        // Fast path: if we don't need previous kvs, we can just upsert the keys.
+        if !req.prev_kv {
+            query_executor.execute(&update, &values_params).await?;
+            return Ok(BatchPutResponse::default());
+        }
+        // Should use transaction to ensure atomicity.
+        if let ExecutorImpl::Default(query_executor) = query_executor {
+            let txn = query_executor.txn_executor().await?;
+            let mut txn = ExecutorImpl::Txn(txn);
+            let res = self.batch_put_with_query_executor(&mut txn, req).await;
+            txn.commit().await?;
+            return res;
+        }
+        let prev_kvs = query_executor.query(&select, &in_params).await?;
+        query_executor.execute(&update, &values_params).await?;
+        Ok(BatchPutResponse { prev_kvs })
+    }
+
+    async fn batch_get_with_query_executor(
+        &self,
+        query_executor: &mut ExecutorImpl<'_, MySqlClient>,
+        req: BatchGetRequest,
+    ) -> Result<BatchGetResponse> {
+        if req.keys.is_empty() {
+            return Ok(BatchGetResponse { kvs: vec![] });
+        }
+        let query = self
+            .sql_template_set
+            .generate_batch_get_query(req.keys.len());
+        let params = req.keys.iter().map(|x| x as _).collect::<Vec<_>>();
+        let kvs = query_executor.query(&query, &params).await?;
+        Ok(BatchGetResponse { kvs })
+    }
+
+    async fn delete_range_with_query_executor(
+        &self,
+        query_executor: &mut ExecutorImpl<'_, MySqlClient>,
+        req: DeleteRangeRequest,
+    ) -> Result<DeleteRangeResponse> {
+        // Since we need to know the number of deleted keys, we have no fast path here.
+        // Should use transaction to ensure atomicity.
+        if let ExecutorImpl::Default(query_executor) = query_executor {
+            let txn = query_executor.txn_executor().await?;
+            let mut txn = ExecutorImpl::Txn(txn);
+            let res = self.delete_range_with_query_executor(&mut txn, req).await;
+            txn.commit().await?;
+            return res;
+        }
+        let range_get_req = RangeRequest {
+            key: req.key.clone(),
+            range_end: req.range_end.clone(),
+            limit: 0,
+            keys_only: false,
+        };
+        let prev_kvs = self
+            .range_with_query_executor(query_executor, range_get_req)
+            .await?
+            .kvs;
+        let template_type = range_template(&req.key, &req.range_end);
+        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<_>>();
+        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);
+        }
+        Ok(resp)
+    }
+
+    async fn batch_delete_with_query_executor(
+        &self,
+        query_executor: &mut ExecutorImpl<'_, MySqlClient>,
+        req: BatchDeleteRequest,
+    ) -> Result<BatchDeleteResponse> {
+        if req.keys.is_empty() {
+            return Ok(BatchDeleteResponse::default());
+        }
+        let query = self
+            .sql_template_set
+            .generate_batch_delete_query(req.keys.len());
+        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 {
+            query_executor.execute(&query, &params).await?;
+            return Ok(BatchDeleteResponse::default());
+        }
+        // Should use transaction to ensure atomicity.
+        if let ExecutorImpl::Default(query_executor) = query_executor {
+            let txn = query_executor.txn_executor().await?;
+            let mut txn = ExecutorImpl::Txn(txn);
+            let res = self.batch_delete_with_query_executor(&mut txn, req).await;
+            txn.commit().await?;
+            return res;
+        }
+        // Should get previous kvs first
+        let batch_get_req = BatchGetRequest {
+            keys: req.keys.clone(),
+        };
+        let prev_kvs = self
+            .batch_get_with_query_executor(query_executor, batch_get_req)
+            .await?
+            .kvs;
+        // Pure `DELETE` has no return value, so we need to use `execute` instead of `query`.
+        query_executor.execute(&query, &params).await?;
+        if req.prev_kv {
+            Ok(BatchDeleteResponse { prev_kvs })
+        } else {
+            Ok(BatchDeleteResponse::default())
+        }
+    }
+}
+
+impl MySqlStore {
+    /// Create [MySqlStore] impl of [KvBackendRef] from url.
+    pub async fn with_url(url: &str, table_name: &str, max_txn_ops: usize) -> Result<KvBackendRef> {
+        let pool = MySqlPool::connect(url)
+            .await
+            .context(CreateMySqlPoolSnafu)?;
+        Self::with_mysql_pool(pool, table_name, max_txn_ops).await
+    }
+
+    /// Create [MySqlStore] impl of [KvBackendRef] from [sqlx::Pool<MySql>].
+    pub async fn with_mysql_pool(
+        pool: Pool<MySql>,
+        table_name: &str,
+        max_txn_ops: usize,
+    ) -> Result<KvBackendRef> {
+        // This step ensures the mysql metadata backend is ready to use.
+        // We check if greptime_metakv table exists, and we will create a new table
+        // if it does not exist.
+        let sql_template_set = MySqlTemplateFactory::new(table_name).build();
+        sqlx::query(&sql_template_set.create_table_statement)
+            .execute(&pool)
+            .await
+            .context(MySqlExecutionSnafu {
+                sql: sql_template_set.create_table_statement.to_string(),
+            })?;
+        Ok(Arc::new(MySqlStore {
+            max_txn_ops,
+            sql_template_set,
+            txn_retry_count: RDS_STORE_TXN_RETRY_COUNT,
+            executor_factory: MySqlExecutorFactory {
+                pool: Arc::new(pool),
+            },
+            _phantom: PhantomData,
+        }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use common_telemetry::init_default_ut_logging;
+
+    use super::*;
+    use crate::kv_backend::test::{
+        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_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,
+    };
+
+    async fn build_mysql_kv_backend(table_name: &str) -> Option<MySqlStore> {
+        init_default_ut_logging();
+        let endpoints = std::env::var("GT_MYSQL_ENDPOINTS").unwrap_or_default();
+        if endpoints.is_empty() {
+            return None;
+        }
+        let pool = MySqlPool::connect(&endpoints).await.unwrap();
+        let sql_templates = MySqlTemplateFactory::new(table_name).build();
+        sqlx::query(&sql_templates.create_table_statement)
+            .execute(&pool)
+            .await
+            .unwrap();
+        Some(MySqlStore {
+            max_txn_ops: 128,
+            sql_template_set: sql_templates,
+            txn_retry_count: RDS_STORE_TXN_RETRY_COUNT,
+            executor_factory: MySqlExecutorFactory {
+                pool: Arc::new(pool),
+            },
+            _phantom: PhantomData,
+        })
+    }
+
+    #[tokio::test]
+    async fn test_mysql_put() {
+        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;
+        test_kv_put_with_prefix(&kv_backend, prefix.to_vec()).await;
+        unprepare_kv(&kv_backend, prefix).await;
+    }
+
+    #[tokio::test]
+    async fn test_mysql_range() {
+        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;
+        test_kv_range_with_prefix(&kv_backend, prefix.to_vec()).await;
+        unprepare_kv(&kv_backend, prefix).await;
+    }
+
+    #[tokio::test]
+    async fn test_mysql_range_2() {
+        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_batch_get() {
+        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;
+        test_kv_batch_get_with_prefix(&kv_backend, prefix.to_vec()).await;
+        unprepare_kv(&kv_backend, prefix).await;
+    }
+
+    #[tokio::test]
+    async fn test_mysql_batch_delete() {
+        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;
+        test_kv_delete_range_with_prefix(&kv_backend, prefix.to_vec()).await;
+        unprepare_kv(&kv_backend, prefix).await;
+    }
+
+    #[tokio::test]
+    async fn test_mysql_batch_delete_with_prefix() {
+        let kv_backend = build_mysql_kv_backend("batch_delete_with_prefix_test")
+            .await
+            .unwrap();
+        let prefix = b"batch_delete/";
+        prepare_kv_with_prefix(&kv_backend, prefix.to_vec()).await;
+        test_kv_batch_delete_with_prefix(&kv_backend, prefix.to_vec()).await;
+        unprepare_kv(&kv_backend, prefix).await;
+    }
+
+    #[tokio::test]
+    async fn test_mysql_delete_range() {
+        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;
+        test_kv_delete_range_with_prefix(&kv_backend, prefix.to_vec()).await;
+        unprepare_kv(&kv_backend, prefix).await;
+    }
+
+    #[tokio::test]
+    async fn test_mysql_compare_and_put() {
+        let kv_backend = build_mysql_kv_backend("compare_and_put_test")
+            .await
+            .unwrap();
+        let prefix = b"compare_and_put/";
+        let kv_backend = Arc::new(kv_backend);
+        test_kv_compare_and_put_with_prefix(kv_backend.clone(), prefix.to_vec()).await;
+    }
+
+    #[tokio::test]
+    async fn test_mysql_txn() {
+        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;
+        test_txn_compare_equal(&kv_backend).await;
+        test_txn_compare_greater(&kv_backend).await;
+        test_txn_compare_less(&kv_backend).await;
+        test_txn_compare_not_equal(&kv_backend).await;
+    }
+}
--- a/src/common/meta/src/kv_backend/rds/postgres.rs
+++ b/src/common/meta/src/kv_backend/rds/postgres.rs
@@ -153,24 +153,29 @@ impl<'a> PgSqlTemplateFactory<'a> {
    /// Builds the template set for the given table name.
    fn build(&self) -> PgSqlTemplateSet {
        let table_name = self.table_name;
+        // Some of queries don't end with `;`, because we need to add `LIMIT` clause.
        PgSqlTemplateSet {
            table_name: table_name.to_string(),
            create_table_statement: format!(
-                "CREATE TABLE IF NOT EXISTS {table_name}(k bytea PRIMARY KEY, v bytea)",
+                "CREATE TABLE IF NOT EXISTS \"{table_name}\"(k bytea PRIMARY KEY, v bytea)",
            ),
            range_template: RangeTemplate {
-                point: format!("SELECT k, v FROM {table_name} WHERE k = $1"),
-                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} $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"),
+                point: format!("SELECT k, v FROM \"{table_name}\" WHERE k = $1"),
+                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}\" $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"),
            },
            delete_template: RangeTemplate {
-                point: format!("DELETE FROM {table_name} WHERE k = $1 RETURNING k,v;"),
-                range: format!("DELETE FROM {table_name} WHERE k >= $1 AND k < $2 RETURNING k,v;"),
-                full: format!("DELETE FROM {table_name} RETURNING k,v"),
-                left_bounded: format!("DELETE FROM {table_name} WHERE k >= $1 RETURNING k,v;"),
-                prefix: format!("DELETE FROM {table_name} WHERE k LIKE $1 RETURNING k,v;"),
+                point: format!("DELETE FROM \"{table_name}\" WHERE k = $1 RETURNING k,v;"),
+                range: format!(
+                    "DELETE FROM \"{table_name}\" WHERE k >= $1 AND k < $2 RETURNING k,v;"
+                ),
+                full: format!("DELETE FROM \"{table_name}\" RETURNING k,v"),
+                left_bounded: format!("DELETE FROM \"{table_name}\" WHERE k >= $1 RETURNING k,v;"),
+                prefix: format!("DELETE FROM \"{table_name}\" WHERE k LIKE $1 RETURNING k,v;"),
            },
        }
    }
@@ -190,7 +195,10 @@ impl PgSqlTemplateSet {
    fn generate_batch_get_query(&self, key_len: usize) -> String {
        let table_name = &self.table_name;
        let in_clause = pg_generate_in_placeholders(1, key_len).join(", ");
-        format!("SELECT k, v FROM {table_name} WHERE k in ({});", in_clause)
+        format!(
+            "SELECT k, v FROM \"{table_name}\" WHERE k in ({});",
+            in_clause
+        )
    }

    /// Generates the sql for batch delete.
@@ -198,7 +206,7 @@ impl PgSqlTemplateSet {
        let table_name = &self.table_name;
        let in_clause = pg_generate_in_placeholders(1, key_len).join(", ");
        format!(
-            "DELETE FROM {table_name} WHERE k in ({}) RETURNING k,v;",
+            "DELETE FROM \"{table_name}\" WHERE k in ({}) RETURNING k,v;",
            in_clause
        )
    }
@@ -219,9 +227,9 @@ impl PgSqlTemplateSet {
        format!(
            r#"
    WITH prev AS (
-        SELECT k,v FROM {table_name} WHERE k IN ({in_clause})
+        SELECT k,v FROM "{table_name}" WHERE k IN ({in_clause})
    ), update AS (
-    INSERT INTO {table_name} (k, v) VALUES
+    INSERT INTO "{table_name}" (k, v) VALUES
        {values_clause}
    ON CONFLICT (
        k
--- a/src/common/meta/src/lib.rs
+++ b/src/common/meta/src/lib.rs
@@ -37,6 +37,7 @@ pub mod metrics;
 pub mod node_expiry_listener;
 pub mod node_manager;
 pub mod peer;
+pub mod poison_key;
 pub mod range_stream;
 pub mod region_keeper;
 pub mod rpc;
--- a/src/common/meta/src/poison_key.rs
+++ b/src/common/meta/src/poison_key.rs
@@ -0,0 +1,22 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use common_procedure::PoisonKey;
+use store_api::storage::TableId;
+
+/// Returns the poison key for the table.
+pub fn table_poison_key(table_id: TableId) -> PoisonKey {
+    let key = format!("table/{}", table_id);
+    PoisonKey::new(&key)
+}
--- a/src/common/meta/src/rpc/ddl.rs
+++ b/src/common/meta/src/rpc/ddl.rs
@@ -1240,6 +1240,7 @@ impl From<QueryContext> for PbQueryContext {
            extensions,
            channel: channel as u32,
            snapshot_seqs: None,
+            explain: None,
        }
    }
 }
--- a/src/common/meta/src/rpc/procedure.rs
+++ b/src/common/meta/src/rpc/procedure.rs
@@ -34,6 +34,24 @@ pub struct MigrateRegionRequest {
    pub timeout: Duration,
 }

+/// A request to add region follower.
+#[derive(Debug, Clone)]
+pub struct AddRegionFollowerRequest {
+    /// The region id to add follower.
+    pub region_id: u64,
+    /// The peer id to add follower.
+    pub peer_id: u64,
+}
+
+/// A request to remove region follower.
+#[derive(Debug, Clone)]
+pub struct RemoveRegionFollowerRequest {
+    /// The region id to remove follower.
+    pub region_id: u64,
+    /// The peer id to remove follower.
+    pub peer_id: u64,
+}
+
 /// Cast the protobuf [`ProcedureId`] to common [`ProcedureId`].
 pub fn pb_pid_to_pid(pid: &PbProcedureId) -> Result<ProcedureId> {
    ProcedureId::parse_str(&String::from_utf8_lossy(&pid.key)).with_context(|_| {
@@ -63,6 +81,7 @@ pub fn procedure_state_to_pb_state(state: &ProcedureState) -> (PbProcedureStatus
        ProcedureState::RollingBack { error } => {
            (PbProcedureStatus::RollingBack, error.to_string())
        }
+        ProcedureState::Poisoned { error, .. } => (PbProcedureStatus::Poisoned, error.to_string()),
    }
 }

--- a/src/common/meta/src/state_store.rs
+++ b/src/common/meta/src/state_store.rs
@@ -14,16 +14,23 @@

 use async_trait::async_trait;
 use common_error::ext::BoxedError;
-use common_procedure::error::{DeleteStatesSnafu, ListStateSnafu, PutStateSnafu};
+use common_procedure::error::{
+    DeletePoisonSnafu, DeleteStatesSnafu, GetPoisonSnafu, ListStateSnafu, PutPoisonSnafu,
+    PutStateSnafu, Result as ProcedureResult,
+};
+use common_procedure::store::poison_store::PoisonStore;
 use common_procedure::store::state_store::{KeySet, KeyValueStream, StateStore};
 use common_procedure::store::util::multiple_value_stream;
-use common_procedure::Result as ProcedureResult;
 use futures::future::try_join_all;
 use futures::StreamExt;
 use itertools::Itertools;
-use snafu::ResultExt;
+use serde::{Deserialize, Serialize};
+use snafu::{ensure, OptionExt, ResultExt};

-use crate::error::Result;
+use crate::error::{ProcedurePoisonConflictSnafu, Result, UnexpectedSnafu};
+use crate::key::txn_helper::TxnOpGetResponseSet;
+use crate::key::{DeserializedValueWithBytes, MetadataValue};
+use crate::kv_backend::txn::{Compare, CompareOp, Txn, TxnOp};
 use crate::kv_backend::KvBackendRef;
 use crate::range_stream::PaginationStream;
 use crate::rpc::store::{BatchDeleteRequest, PutRequest, RangeRequest};
@@ -32,11 +39,16 @@ use crate::rpc::KeyValue;
 const DELIMITER: &str = "/";

 const PROCEDURE_PREFIX: &str = "/__procedure__/";
+const PROCEDURE_POISON_KEY_PREFIX: &str = "/__procedure_poison/";

 fn with_prefix(key: &str) -> String {
    format!("{PROCEDURE_PREFIX}{key}")
 }

+fn with_poison_prefix(key: &str) -> String {
+    format!("{}{}", PROCEDURE_POISON_KEY_PREFIX, key)
+}
+
 fn strip_prefix(key: &str) -> String {
    key.trim_start_matches(PROCEDURE_PREFIX).to_string()
 }
@@ -207,8 +219,168 @@ impl StateStore for KvStateStore {
    }
 }

+/// The value of the poison key.
+///
+/// Each poison value contains a unique token that identifies the procedure.
+/// While multiple procedures may use the same poison key (representing the same resource),
+/// each procedure will have a distinct token value to differentiate its ownership.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PoisonValue {
+    token: String,
+}
+
+type PoisonDecodeResult = Result<Option<DeserializedValueWithBytes<PoisonValue>>>;
+
+impl KvStateStore {
+    /// Builds a create poison transaction,
+    /// it expected the `__procedure_poison/{key}` wasn't occupied.
+    fn build_create_poison_txn(
+        &self,
+        key: &str,
+        value: &PoisonValue,
+    ) -> Result<(
+        Txn,
+        impl FnOnce(&mut TxnOpGetResponseSet) -> PoisonDecodeResult,
+    )> {
+        let key = key.as_bytes().to_vec();
+        let value = value.try_as_raw_value()?;
+        let txn = Txn::put_if_not_exists(key.clone(), value);
+
+        Ok((
+            txn,
+            TxnOpGetResponseSet::decode_with(TxnOpGetResponseSet::filter(key)),
+        ))
+    }
+
+    /// Builds a delete poison transaction,
+    /// it expected the `__procedure_poison/{key}` was occupied.
+    fn build_delete_poison_txn(
+        &self,
+        key: &str,
+        value: PoisonValue,
+    ) -> Result<(
+        Txn,
+        impl FnOnce(&mut TxnOpGetResponseSet) -> PoisonDecodeResult,
+    )> {
+        let key = key.as_bytes().to_vec();
+        let value = value.try_as_raw_value()?;
+
+        let txn = Txn::new()
+            .when(vec![Compare::with_value(
+                key.clone(),
+                CompareOp::Equal,
+                value,
+            )])
+            .and_then(vec![TxnOp::Delete(key.clone())])
+            .or_else(vec![TxnOp::Get(key.clone())]);
+
+        Ok((
+            txn,
+            TxnOpGetResponseSet::decode_with(TxnOpGetResponseSet::filter(key)),
+        ))
+    }
+
+    async fn get_poison_inner(&self, key: &str) -> Result<Option<PoisonValue>> {
+        let key = with_poison_prefix(key);
+        let value = self.kv_backend.get(key.as_bytes()).await?;
+        value
+            .map(|v| PoisonValue::try_from_raw_value(&v.value))
+            .transpose()
+    }
+
+    /// Put the poison.
+    ///
+    /// If the poison is already put by other procedure, it will return an error.
+    async fn set_poison_inner(&self, key: &str, token: &str) -> Result<()> {
+        let key = with_poison_prefix(key);
+        let (txn, on_failure) = self.build_create_poison_txn(
+            &key,
+            &PoisonValue {
+                token: token.to_string(),
+            },
+        )?;
+
+        let mut resp = self.kv_backend.txn(txn).await?;
+
+        if !resp.succeeded {
+            let mut set = TxnOpGetResponseSet::from(&mut resp.responses);
+            let remote_value = on_failure(&mut set)?
+                .context(UnexpectedSnafu {
+                    err_msg: "Reads the empty poison value in comparing operation of the put consistency poison",
+                })?
+                .into_inner();
+
+            ensure!(
+                remote_value.token == token,
+                ProcedurePoisonConflictSnafu {
+                    key: &key,
+                    value: &remote_value.token,
+                }
+            );
+        }
+
+        Ok(())
+    }
+
+    /// Deletes the poison.
+    ///
+    /// If the poison is not put by the procedure, it will return an error.
+    async fn delete_poison_inner(&self, key: &str, token: &str) -> Result<()> {
+        let key = with_poison_prefix(key);
+        let (txn, on_failure) = self.build_delete_poison_txn(
+            &key,
+            PoisonValue {
+                token: token.to_string(),
+            },
+        )?;
+
+        let mut resp = self.kv_backend.txn(txn).await?;
+
+        if !resp.succeeded {
+            let mut set = TxnOpGetResponseSet::from(&mut resp.responses);
+            let remote_value = on_failure(&mut set)?;
+
+            ensure!(
+                remote_value.is_none(),
+                ProcedurePoisonConflictSnafu {
+                    key: &key,
+                    value: &remote_value.unwrap().into_inner().token,
+                }
+            );
+        }
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl PoisonStore for KvStateStore {
+    async fn try_put_poison(&self, key: String, token: String) -> ProcedureResult<()> {
+        self.set_poison_inner(&key, &token)
+            .await
+            .map_err(BoxedError::new)
+            .context(PutPoisonSnafu { key, token })
+    }
+
+    async fn delete_poison(&self, key: String, token: String) -> ProcedureResult<()> {
+        self.delete_poison_inner(&key, &token)
+            .await
+            .map_err(BoxedError::new)
+            .context(DeletePoisonSnafu { key, token })
+    }
+
+    async fn get_poison(&self, key: &str) -> ProcedureResult<Option<String>> {
+        self.get_poison_inner(key)
+            .await
+            .map(|v| v.map(|v| v.token))
+            .map_err(BoxedError::new)
+            .context(GetPoisonSnafu { key })
+    }
+}
+
 #[cfg(test)]
 mod tests {
+    use std::assert_matches::assert_matches;
    use std::env;
    use std::sync::Arc;

@@ -219,6 +391,7 @@ mod tests {
    use uuid::Uuid;

    use super::*;
+    use crate::error::Error;
    use crate::kv_backend::chroot::ChrootKvBackend;
    use crate::kv_backend::etcd::EtcdStore;
    use crate::kv_backend::memory::MemoryKvBackend;
@@ -397,4 +570,73 @@ mod tests {
        )
        .await;
    }
+
+    #[tokio::test]
+    async fn test_poison() {
+        let mem_kv = Arc::new(MemoryKvBackend::default());
+        let poison_manager = KvStateStore::new(mem_kv.clone());
+
+        let key = "table/1";
+
+        let token = "expected_token";
+
+        poison_manager.set_poison_inner(key, token).await.unwrap();
+
+        // Put again, should be ok.
+        poison_manager.set_poison_inner(key, token).await.unwrap();
+
+        // Delete, should be ok.
+        poison_manager
+            .delete_poison_inner(key, token)
+            .await
+            .unwrap();
+
+        // Delete again, should be ok.
+        poison_manager
+            .delete_poison_inner(key, token)
+            .await
+            .unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_consistency_poison_failed() {
+        let mem_kv = Arc::new(MemoryKvBackend::default());
+        let poison_manager = KvStateStore::new(mem_kv.clone());
+
+        let key = "table/1";
+
+        let token = "expected_token";
+        let token2 = "expected_token2";
+
+        poison_manager.set_poison_inner(key, token).await.unwrap();
+
+        let err = poison_manager
+            .set_poison_inner(key, token2)
+            .await
+            .unwrap_err();
+        assert_matches!(err, Error::ProcedurePoisonConflict { .. });
+
+        let err = poison_manager
+            .delete_poison_inner(key, token2)
+            .await
+            .unwrap_err();
+        assert_matches!(err, Error::ProcedurePoisonConflict { .. });
+    }
+
+    #[test]
+    fn test_serialize_deserialize() {
+        let key = "table/1";
+        let value = PoisonValue {
+            token: "expected_token".to_string(),
+        };
+
+        let serialized_key = with_poison_prefix(key).as_bytes().to_vec();
+        let serialized_value = value.try_as_raw_value().unwrap();
+
+        let expected_key = "/__procedure_poison/table/1";
+        let expected_value = r#"{"token":"expected_token"}"#;
+
+        assert_eq!(expected_key.as_bytes(), serialized_key);
+        assert_eq!(expected_value.as_bytes(), serialized_value);
+    }
 }
--- a/src/common/procedure-test/Cargo.toml
+++ b/src/common/procedure-test/Cargo.toml
@@ -9,4 +9,5 @@ workspace = true

 [dependencies]
 async-trait.workspace = true
-common-procedure.workspace = true
+common-procedure = { workspace = true, features = ["testing"] }
+snafu.workspace = true
--- a/src/common/procedure-test/src/lib.rs
+++ b/src/common/procedure-test/src/lib.rs
@@ -18,21 +18,32 @@ use std::collections::HashMap;
 use std::sync::Arc;

 use async_trait::async_trait;
+use common_procedure::store::poison_store::PoisonStore;
+use common_procedure::test_util::InMemoryPoisonStore;
 use common_procedure::{
-    Context, ContextProvider, Output, Procedure, ProcedureId, ProcedureState, ProcedureWithId,
-    Result, Status,
+    Context, ContextProvider, Output, PoisonKey, Procedure, ProcedureId, ProcedureState,
+    ProcedureWithId, Result, Status,
 };

 /// A Mock [ContextProvider].
 #[derive(Default)]
 pub struct MockContextProvider {
    states: HashMap<ProcedureId, ProcedureState>,
+    poison_manager: InMemoryPoisonStore,
 }

 impl MockContextProvider {
    /// Returns a new provider.
    pub fn new(states: HashMap<ProcedureId, ProcedureState>) -> MockContextProvider {
-        MockContextProvider { states }
+        MockContextProvider {
+            states,
+            poison_manager: InMemoryPoisonStore::default(),
+        }
+    }
+
+    /// Returns a reference to the poison manager.
+    pub fn poison_manager(&self) -> &InMemoryPoisonStore {
+        &self.poison_manager
    }
 }

@@ -41,6 +52,12 @@ impl ContextProvider for MockContextProvider {
    async fn procedure_state(&self, procedure_id: ProcedureId) -> Result<Option<ProcedureState>> {
        Ok(self.states.get(&procedure_id).cloned())
    }
+
+    async fn try_put_poison(&self, key: &PoisonKey, procedure_id: ProcedureId) -> Result<()> {
+        self.poison_manager
+            .try_put_poison(key.to_string(), procedure_id.to_string())
+            .await
+    }
 }

 /// Executes a procedure until it returns [Status::Done].
@@ -61,6 +78,7 @@ pub async fn execute_procedure_until_done(procedure: &mut dyn Procedure) -> Opti
                "Executing subprocedure is unsupported"
            ),
            Status::Done { output } => return output,
+            Status::Poisoned { .. } => return None,
        }
    }
 }
@@ -88,6 +106,7 @@ pub async fn execute_procedure_once(
            false
        }
        Status::Done { .. } => true,
+        Status::Poisoned { .. } => false,
    }
 }

@@ -109,6 +128,7 @@ pub async fn execute_until_suspended_or_done(
            Status::Executing { .. } => (),
            Status::Suspended { subprocedures, .. } => return Some(subprocedures),
            Status::Done { .. } => break,
+            Status::Poisoned { .. } => unreachable!(),
        }
    }

--- a/src/common/procedure/src/error.rs
+++ b/src/common/procedure/src/error.rs
@@ -21,14 +21,21 @@ use common_macro::stack_trace_debug;
 use snafu::{Location, Snafu};

 use crate::procedure::ProcedureId;
+use crate::PoisonKey;

 /// Procedure error.
 #[derive(Snafu)]
 #[snafu(visibility(pub))]
 #[stack_trace_debug]
 pub enum Error {
-    #[snafu(display("Failed to execute procedure due to external error"))]
-    External { source: BoxedError },
+    #[snafu(display(
+        "Failed to execute procedure due to external error, clean poisons: {}",
+        clean_poisons
+    ))]
+    External {
+        source: BoxedError,
+        clean_poisons: bool,
+    },

    #[snafu(display("Loader {} is already registered", name))]
    LoaderConflict {
@@ -66,6 +73,32 @@ pub enum Error {
        source: BoxedError,
    },

+    #[snafu(display("Failed to put poison, key: '{key}', token: '{token}'"))]
+    PutPoison {
+        key: String,
+        token: String,
+        #[snafu(implicit)]
+        location: Location,
+        source: BoxedError,
+    },
+
+    #[snafu(display("Failed to get poison, key: '{key}'"))]
+    GetPoison {
+        key: String,
+        #[snafu(implicit)]
+        location: Location,
+        source: BoxedError,
+    },
+
+    #[snafu(display("Failed to delete poison, key: '{key}', token: '{token}'"))]
+    DeletePoison {
+        key: String,
+        token: String,
+        #[snafu(implicit)]
+        location: Location,
+        source: BoxedError,
+    },
+
    #[snafu(display("Failed to delete {}", key))]
    DeleteState {
        key: String,
@@ -175,6 +208,21 @@ pub enum Error {
        #[snafu(implicit)]
        location: Location,
    },
+
+    #[snafu(display("Procedure not found, procedure_id: {}", procedure_id))]
+    ProcedureNotFound {
+        procedure_id: ProcedureId,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display("Poison key not defined, key: '{key}', procedure_id: '{procedure_id}'"))]
+    PoisonKeyNotDefined {
+        key: PoisonKey,
+        procedure_id: ProcedureId,
+        #[snafu(implicit)]
+        location: Location,
+    },
 }

 pub type Result<T> = std::result::Result<T, Error>;
@@ -185,14 +233,18 @@ impl ErrorExt for Error {
            Error::External { source, .. }
            | Error::PutState { source, .. }
            | Error::DeleteStates { source, .. }
-            | Error::ListState { source, .. } => source.status_code(),
+            | Error::ListState { source, .. }
+            | Error::PutPoison { source, .. }
+            | Error::DeletePoison { source, .. }
+            | Error::GetPoison { source, .. } => source.status_code(),

            Error::ToJson { .. }
            | Error::DeleteState { .. }
            | Error::FromJson { .. }
            | Error::WaitWatcher { .. }
            | Error::RetryLater { .. }
-            | Error::RollbackProcedureRecovered { .. } => StatusCode::Internal,
+            | Error::RollbackProcedureRecovered { .. }
+            | Error::PoisonKeyNotDefined { .. } => StatusCode::Internal,

            Error::RetryTimesExceeded { .. }
            | Error::RollbackTimesExceeded { .. }
@@ -204,7 +256,8 @@ impl ErrorExt for Error {
            }
            Error::ProcedurePanic { .. }
            | Error::ParseSegmentKey { .. }
-            | Error::Unexpected { .. } => StatusCode::Unexpected,
+            | Error::Unexpected { .. }
+            | &Error::ProcedureNotFound { .. } => StatusCode::Unexpected,
            Error::ProcedureExec { source, .. } => source.status_code(),
            Error::StartRemoveOutdatedMetaTask { source, .. }
            | Error::StopRemoveOutdatedMetaTask { source, .. } => source.status_code(),
@@ -221,6 +274,15 @@ impl Error {
    pub fn external<E: ErrorExt + Send + Sync + 'static>(err: E) -> Error {
        Error::External {
            source: BoxedError::new(err),
+            clean_poisons: false,
+        }
+    }
+
+    /// Creates a new [Error::External] error from source `err` and clean poisons.
+    pub fn external_and_clean_poisons<E: ErrorExt + Send + Sync + 'static>(err: E) -> Error {
+        Error::External {
+            source: BoxedError::new(err),
+            clean_poisons: true,
        }
    }

@@ -236,6 +298,11 @@ impl Error {
        matches!(self, Error::RetryLater { .. })
    }

+    /// Determine whether it needs to clean poisons.
+    pub fn need_clean_poisons(&self) -> bool {
+        matches!(self, Error::External { clean_poisons, .. } if *clean_poisons)
+    }
+
    /// Creates a new [Error::RetryLater] or [Error::External] error from source `err` according
    /// to its [StatusCode].
    pub fn from_error_ext<E: ErrorExt + Send + Sync + 'static>(err: E) -> Self {
--- a/src/common/procedure/src/lib.rs
+++ b/src/common/procedure/src/lib.rs
@@ -23,10 +23,13 @@ mod procedure;
 pub mod store;
 pub mod watcher;

+#[cfg(any(test, feature = "testing"))]
+pub mod test_util;
+
 pub use crate::error::{Error, Result};
 pub use crate::procedure::{
    BoxedProcedure, BoxedProcedureLoader, Context, ContextProvider, LockKey, Output, ParseIdError,
-    Procedure, ProcedureId, ProcedureInfo, ProcedureManager, ProcedureManagerRef, ProcedureState,
-    ProcedureWithId, Status, StringKey,
+    PoisonKey, PoisonKeys, Procedure, ProcedureId, ProcedureInfo, ProcedureManager,
+    ProcedureManagerRef, ProcedureState, ProcedureWithId, Status, StringKey,
 };
 pub use crate::watcher::Watcher;
--- a/src/common/procedure/src/local.rs
+++ b/src/common/procedure/src/local.rs
@@ -25,21 +25,23 @@ use backon::ExponentialBuilder;
 use common_runtime::{RepeatedTask, TaskFunction};
 use common_telemetry::tracing_context::{FutureExt, TracingContext};
 use common_telemetry::{error, info, tracing};
-use snafu::{ensure, ResultExt};
+use snafu::{ensure, OptionExt, ResultExt};
 use tokio::sync::watch::{self, Receiver, Sender};
 use tokio::sync::{Mutex as TokioMutex, Notify};

 use self::rwlock::KeyRwLock;
 use crate::error::{
-    self, DuplicateProcedureSnafu, Error, LoaderConflictSnafu, ManagerNotStartSnafu, Result,
-    StartRemoveOutdatedMetaTaskSnafu, StopRemoveOutdatedMetaTaskSnafu,
+    self, DuplicateProcedureSnafu, Error, LoaderConflictSnafu, ManagerNotStartSnafu,
+    PoisonKeyNotDefinedSnafu, ProcedureNotFoundSnafu, Result, StartRemoveOutdatedMetaTaskSnafu,
+    StopRemoveOutdatedMetaTaskSnafu,
 };
 use crate::local::runner::Runner;
-use crate::procedure::{BoxedProcedureLoader, InitProcedureState, ProcedureInfo};
+use crate::procedure::{BoxedProcedureLoader, InitProcedureState, PoisonKeys, ProcedureInfo};
+use crate::store::poison_store::PoisonStoreRef;
 use crate::store::{ProcedureMessage, ProcedureMessages, ProcedureStore, StateStoreRef};
 use crate::{
-    BoxedProcedure, ContextProvider, LockKey, ProcedureId, ProcedureManager, ProcedureState,
-    ProcedureWithId, Watcher,
+    BoxedProcedure, ContextProvider, LockKey, PoisonKey, ProcedureId, ProcedureManager,
+    ProcedureState, ProcedureWithId, Watcher,
 };

 /// The expired time of a procedure's metadata.
@@ -65,6 +67,8 @@ pub(crate) struct ProcedureMeta {
    child_notify: Notify,
    /// Lock required by this procedure.
    lock_key: LockKey,
+    /// Poison keys that may cause this procedure to become poisoned during execution.
+    poison_keys: PoisonKeys,
    /// Sender to notify the procedure state.
    state_sender: Sender<ProcedureState>,
    /// Receiver to watch the procedure state.
@@ -83,6 +87,7 @@ impl ProcedureMeta {
        procedure_state: ProcedureState,
        parent_id: Option<ProcedureId>,
        lock_key: LockKey,
+        poison_keys: PoisonKeys,
        type_name: &str,
    ) -> ProcedureMeta {
        let (state_sender, state_receiver) = watch::channel(procedure_state);
@@ -91,6 +96,7 @@ impl ProcedureMeta {
            parent_id,
            child_notify: Notify::new(),
            lock_key,
+            poison_keys,
            state_sender,
            state_receiver,
            children: Mutex::new(Vec::new()),
@@ -163,6 +169,8 @@ pub(crate) struct ManagerContext {
    finished_procedures: Mutex<VecDeque<(ProcedureId, Instant)>>,
    /// Running flag.
    running: Arc<AtomicBool>,
+    /// Poison manager.
+    poison_manager: PoisonStoreRef,
 }

 #[async_trait]
@@ -170,11 +178,33 @@ impl ContextProvider for ManagerContext {
    async fn procedure_state(&self, procedure_id: ProcedureId) -> Result<Option<ProcedureState>> {
        Ok(self.state(procedure_id))
    }
+
+    async fn try_put_poison(&self, key: &PoisonKey, procedure_id: ProcedureId) -> Result<()> {
+        {
+            // validate the procedure exists
+            let procedures = self.procedures.read().unwrap();
+            let procedure = procedures
+                .get(&procedure_id)
+                .context(ProcedureNotFoundSnafu { procedure_id })?;
+
+            // validate the poison key is defined
+            ensure!(
+                procedure.poison_keys.contains(key),
+                PoisonKeyNotDefinedSnafu {
+                    key: key.clone(),
+                    procedure_id
+                }
+            );
+        }
+        let key = key.to_string();
+        let procedure_id = procedure_id.to_string();
+        self.poison_manager.try_put_poison(key, procedure_id).await
+    }
 }

 impl ManagerContext {
    /// Returns a new [ManagerContext].
-    fn new() -> ManagerContext {
+    fn new(poison_manager: PoisonStoreRef) -> ManagerContext {
        ManagerContext {
            key_lock: KeyRwLock::new(),
            loaders: Mutex::new(HashMap::new()),
@@ -182,6 +212,7 @@ impl ManagerContext {
            messages: Mutex::new(HashMap::new()),
            finished_procedures: Mutex::new(VecDeque::new()),
            running: Arc::new(AtomicBool::new(false)),
+            poison_manager,
        }
    }

@@ -437,8 +468,12 @@ pub struct LocalManager {

 impl LocalManager {
    /// Create a new [LocalManager] with specific `config`.
-    pub fn new(config: ManagerConfig, state_store: StateStoreRef) -> LocalManager {
-        let manager_ctx = Arc::new(ManagerContext::new());
+    pub fn new(
+        config: ManagerConfig,
+        state_store: StateStoreRef,
+        poison_store: PoisonStoreRef,
+    ) -> LocalManager {
+        let manager_ctx = Arc::new(ManagerContext::new(poison_store));

        LocalManager {
            manager_ctx,
@@ -476,6 +511,7 @@ impl LocalManager {
            procedure_state,
            None,
            procedure.lock_key(),
+            procedure.poison_keys(),
            procedure.type_name(),
        ));
        let runner = Runner {
@@ -718,6 +754,7 @@ pub(crate) mod test_util {
            ProcedureState::Running,
            None,
            LockKey::default(),
+            PoisonKeys::default(),
            "ProcedureAdapter",
        )
    }
@@ -741,11 +778,17 @@ mod tests {
    use super::*;
    use crate::error::{self, Error};
    use crate::store::state_store::ObjectStateStore;
+    use crate::test_util::InMemoryPoisonStore;
    use crate::{Context, Procedure, Status};

+    fn new_test_manager_context() -> ManagerContext {
+        let poison_manager = Arc::new(InMemoryPoisonStore::default());
+        ManagerContext::new(poison_manager)
+    }
+
    #[test]
    fn test_manager_context() {
-        let ctx = ManagerContext::new();
+        let ctx = new_test_manager_context();
        let meta = Arc::new(test_util::procedure_meta_for_test());

        assert!(!ctx.contains_procedure(meta.id));
@@ -761,7 +804,7 @@ mod tests {

    #[test]
    fn test_manager_context_insert_duplicate() {
-        let ctx = ManagerContext::new();
+        let ctx = new_test_manager_context();
        let meta = Arc::new(test_util::procedure_meta_for_test());

        assert!(ctx.try_insert_procedure(meta.clone()));
@@ -783,7 +826,7 @@ mod tests {

    #[test]
    fn test_procedures_in_tree() {
-        let ctx = ManagerContext::new();
+        let ctx = new_test_manager_context();
        let root = Arc::new(test_util::procedure_meta_for_test());
        assert!(ctx.try_insert_procedure(root.clone()));

@@ -807,6 +850,7 @@ mod tests {
    struct ProcedureToLoad {
        content: String,
        lock_key: LockKey,
+        poison_keys: PoisonKeys,
    }

    #[async_trait]
@@ -826,6 +870,10 @@ mod tests {
        fn lock_key(&self) -> LockKey {
            self.lock_key.clone()
        }
+
+        fn poison_keys(&self) -> PoisonKeys {
+            self.poison_keys.clone()
+        }
    }

    impl ProcedureToLoad {
@@ -833,6 +881,7 @@ mod tests {
            ProcedureToLoad {
                content: content.to_string(),
                lock_key: LockKey::default(),
+                poison_keys: PoisonKeys::default(),
            }
        }

@@ -855,7 +904,8 @@ mod tests {
            ..Default::default()
        };
        let state_store = Arc::new(ObjectStateStore::new(test_util::new_object_store(&dir)));
-        let manager = LocalManager::new(config, state_store);
+        let poison_manager = Arc::new(InMemoryPoisonStore::new());
+        let manager = LocalManager::new(config, state_store, poison_manager);
        manager.manager_ctx.start();

        manager
@@ -879,7 +929,8 @@ mod tests {
            ..Default::default()
        };
        let state_store = Arc::new(ObjectStateStore::new(object_store.clone()));
-        let manager = LocalManager::new(config, state_store);
+        let poison_manager = Arc::new(InMemoryPoisonStore::new());
+        let manager = LocalManager::new(config, state_store, poison_manager);
        manager.manager_ctx.start();

        manager
@@ -932,7 +983,8 @@ mod tests {
            ..Default::default()
        };
        let state_store = Arc::new(ObjectStateStore::new(test_util::new_object_store(&dir)));
-        let manager = LocalManager::new(config, state_store);
+        let poison_manager = Arc::new(InMemoryPoisonStore::new());
+        let manager = LocalManager::new(config, state_store, poison_manager);
        manager.manager_ctx.start();

        let procedure_id = ProcedureId::random();
@@ -983,7 +1035,8 @@ mod tests {
            ..Default::default()
        };
        let state_store = Arc::new(ObjectStateStore::new(test_util::new_object_store(&dir)));
-        let manager = LocalManager::new(config, state_store);
+        let poison_manager = Arc::new(InMemoryPoisonStore::new());
+        let manager = LocalManager::new(config, state_store, poison_manager);
        manager.manager_ctx.start();

        #[derive(Debug)]
@@ -1022,6 +1075,10 @@ mod tests {
            fn lock_key(&self) -> LockKey {
                LockKey::single_exclusive("test.submit")
            }
+
+            fn poison_keys(&self) -> PoisonKeys {
+                PoisonKeys::default()
+            }
        }

        let check_procedure = |procedure| async {
@@ -1059,7 +1116,8 @@ mod tests {
            ..Default::default()
        };
        let state_store = Arc::new(ObjectStateStore::new(test_util::new_object_store(&dir)));
-        let manager = LocalManager::new(config, state_store);
+        let poison_manager = Arc::new(InMemoryPoisonStore::new());
+        let manager = LocalManager::new(config, state_store, poison_manager);

        let mut procedure = ProcedureToLoad::new("submit");
        procedure.lock_key = LockKey::single_exclusive("test.submit");
@@ -1086,7 +1144,8 @@ mod tests {
            ..Default::default()
        };
        let state_store = Arc::new(ObjectStateStore::new(test_util::new_object_store(&dir)));
-        let manager = LocalManager::new(config, state_store);
+        let poison_manager = Arc::new(InMemoryPoisonStore::new());
+        let manager = LocalManager::new(config, state_store, poison_manager);

        manager.start().await.unwrap();
        manager.stop().await.unwrap();
@@ -1121,7 +1180,8 @@ mod tests {
            remove_outdated_meta_ttl: Duration::from_millis(1),
        };
        let state_store = Arc::new(ObjectStateStore::new(object_store.clone()));
-        let manager = LocalManager::new(config, state_store);
+        let poison_manager = Arc::new(InMemoryPoisonStore::new());
+        let manager = LocalManager::new(config, state_store, poison_manager);
        manager.manager_ctx.set_running();

        let mut procedure = ProcedureToLoad::new("submit");
@@ -1196,6 +1256,7 @@ mod tests {
        content: String,
        lock_key: LockKey,
        notify: Option<Arc<Notify>>,
+        poison_keys: PoisonKeys,
    }

    #[async_trait]
@@ -1220,6 +1281,10 @@ mod tests {
            self.notify.as_ref().unwrap().notify_one();
            Ok(())
        }
+
+        fn poison_keys(&self) -> PoisonKeys {
+            self.poison_keys.clone()
+        }
    }

    impl ProcedureToRecover {
@@ -1227,6 +1292,7 @@ mod tests {
            ProcedureToRecover {
                content: content.to_string(),
                lock_key: LockKey::default(),
+                poison_keys: PoisonKeys::default(),
                notify: None,
            }
        }
@@ -1236,6 +1302,7 @@ mod tests {
                let procedure = ProcedureToRecover {
                    content: json.to_string(),
                    lock_key: LockKey::default(),
+                    poison_keys: PoisonKeys::default(),
                    notify: Some(notify.clone()),
                };
                Ok(Box::new(procedure) as _)
@@ -1256,7 +1323,8 @@ mod tests {
            ..Default::default()
        };
        let state_store = Arc::new(ObjectStateStore::new(object_store.clone()));
-        let manager = LocalManager::new(config, state_store);
+        let poison_manager = Arc::new(InMemoryPoisonStore::new());
+        let manager = LocalManager::new(config, state_store, poison_manager);
        manager.manager_ctx.start();

        let notify = Arc::new(Notify::new());
--- a/src/common/procedure/src/local/runner.rs
+++ b/src/common/procedure/src/local/runner.rs
@@ -238,11 +238,34 @@ impl Runner {
                }
                ProcedureState::Done { .. } => return,
                ProcedureState::Failed { .. } => return,
+                ProcedureState::Poisoned { .. } => return,
            }
            self.execute_once(ctx).await;
        }
    }

+    async fn clean_poisons(&mut self) -> Result<()> {
+        let mut error = None;
+        for key in self.meta.poison_keys.iter() {
+            let key = key.to_string();
+            if let Err(e) = self
+                .manager_ctx
+                .poison_manager
+                .delete_poison(key, self.meta.id.to_string())
+                .await
+            {
+                error!(e; "Failed to clean poisons for procedure: {}", self.meta.id);
+                error = Some(e);
+            }
+        }
+
+        // returns the last error if any.
+        if let Some(e) = error {
+            return Err(e);
+        }
+        Ok(())
+    }
+
    async fn rollback(&mut self, ctx: &Context, err: Arc<Error>) {
        if self.procedure.rollback_supported() {
            if let Err(e) = self.procedure.rollback(ctx).await {
@@ -255,7 +278,7 @@ impl Runner {
    }

    async fn prepare_rollback(&mut self, err: Arc<Error>) {
-        if let Err(e) = self.write_procedure_state(err.to_string()).await {
+        if let Err(e) = self.write_rollback_procedure_state(err.to_string()).await {
            self.meta
                .set_state(ProcedureState::prepare_rollback(Arc::new(e)));
            return;
@@ -288,26 +311,48 @@ impl Runner {
                            return;
                        }

+                        // Cleans poisons before persist.
+                        if status.need_clean_poisons() {
+                            if let Err(e) = self.clean_poisons().await {
+                                error!(e; "Failed to clean poison for procedure: {}", self.meta.id);
+                                self.meta.set_state(ProcedureState::retrying(Arc::new(e)));
+                                return;
+                            }
+                        }
+
                        if status.need_persist() {
-                            if let Err(err) = self.persist_procedure().await {
-                                self.meta.set_state(ProcedureState::retrying(Arc::new(err)));
+                            if let Err(e) = self.persist_procedure().await {
+                                error!(e; "Failed to persist procedure: {}", self.meta.id);
+                                self.meta.set_state(ProcedureState::retrying(Arc::new(e)));
                                return;
                            }
                        }

                        match status {
-                            Status::Executing { .. } => (),
+                            Status::Executing { .. } => {}
                            Status::Suspended { subprocedures, .. } => {
                                self.on_suspended(subprocedures).await;
                            }
                            Status::Done { output } => {
                                if let Err(e) = self.commit_procedure().await {
+                                    error!(e; "Failed to commit procedure: {}", self.meta.id);
                                    self.meta.set_state(ProcedureState::retrying(Arc::new(e)));
                                    return;
                                }

                                self.done(output);
                            }
+                            Status::Poisoned { error, keys } => {
+                                error!(
+                                    error;
+                                    "Procedure {}-{} is poisoned, keys: {:?}",
+                                    self.procedure.type_name(),
+                                    self.meta.id,
+                                    keys,
+                                );
+                                self.meta
+                                    .set_state(ProcedureState::poisoned(keys, Arc::new(error)));
+                            }
                        }
                    }
                    Err(e) => {
@@ -327,6 +372,14 @@ impl Runner {
                            return;
                        }

+                        if e.need_clean_poisons() {
+                            if let Err(e) = self.clean_poisons().await {
+                                error!(e; "Failed to clean poison for procedure: {}", self.meta.id);
+                                self.meta.set_state(ProcedureState::retrying(Arc::new(e)));
+                                return;
+                            }
+                        }
+
                        if e.is_retry_later() {
                            self.meta.set_state(ProcedureState::retrying(Arc::new(e)));
                            return;
@@ -339,7 +392,9 @@ impl Runner {
            }
            ProcedureState::PrepareRollback { error } => self.prepare_rollback(error).await,
            ProcedureState::RollingBack { error } => self.rollback(ctx, error).await,
-            ProcedureState::Failed { .. } | ProcedureState::Done { .. } => (),
+            ProcedureState::Failed { .. }
+            | ProcedureState::Done { .. }
+            | ProcedureState::Poisoned { .. } => (),
        }
    }

@@ -372,6 +427,7 @@ impl Runner {
            procedure_state,
            Some(self.meta.id),
            procedure.lock_key(),
+            procedure.poison_keys(),
            procedure.type_name(),
        ));
        let runner = Runner {
@@ -494,7 +550,7 @@ impl Runner {
        Ok(())
    }

-    async fn write_procedure_state(&mut self, error: String) -> Result<()> {
+    async fn write_rollback_procedure_state(&mut self, error: String) -> Result<()> {
        // Persists procedure state
        let type_name = self.procedure.type_name().to_string();
        let data = self.procedure.dump()?;
@@ -549,8 +605,10 @@ mod tests {

    use super::*;
    use crate::local::test_util;
+    use crate::procedure::PoisonKeys;
    use crate::store::proc_path;
-    use crate::{ContextProvider, Error, LockKey, Procedure};
+    use crate::test_util::InMemoryPoisonStore;
+    use crate::{ContextProvider, Error, LockKey, PoisonKey, Procedure};

    const ROOT_ID: &str = "9f805a1f-05f7-490c-9f91-bd56e3cc54c1";

@@ -562,7 +620,9 @@ mod tests {
        Runner {
            meta,
            procedure,
-            manager_ctx: Arc::new(ManagerContext::new()),
+            manager_ctx: Arc::new(ManagerContext::new(
+                Arc::new(InMemoryPoisonStore::default()),
+            )),
            step: 0,
            exponential_builder: ExponentialBuilder::default(),
            store,
@@ -587,6 +647,16 @@ mod tests {
        assert_eq!(files, files_in_dir);
    }

+    fn context_with_provider(
+        procedure_id: ProcedureId,
+        provider: Arc<dyn ContextProvider>,
+    ) -> Context {
+        Context {
+            procedure_id,
+            provider,
+        }
+    }
+
    fn context_without_provider(procedure_id: ProcedureId) -> Context {
        struct MockProvider;

@@ -598,6 +668,14 @@ mod tests {
            ) -> Result<Option<ProcedureState>> {
                unimplemented!()
            }
+
+            async fn try_put_poison(
+                &self,
+                _key: &PoisonKey,
+                _procedure_id: ProcedureId,
+            ) -> Result<()> {
+                unimplemented!()
+            }
        }

        Context {
@@ -611,6 +689,7 @@ mod tests {
    struct ProcedureAdapter<F> {
        data: String,
        lock_key: LockKey,
+        poison_keys: PoisonKeys,
        exec_fn: F,
        rollback_fn: Option<RollbackFn>,
    }
@@ -620,6 +699,7 @@ mod tests {
            let mut meta = test_util::procedure_meta_for_test();
            meta.id = ProcedureId::parse_str(uuid).unwrap();
            meta.lock_key = self.lock_key.clone();
+            meta.poison_keys = self.poison_keys.clone();

            Arc::new(meta)
        }
@@ -657,6 +737,10 @@ mod tests {
        fn lock_key(&self) -> LockKey {
            self.lock_key.clone()
        }
+
+        fn poison_keys(&self) -> PoisonKeys {
+            self.poison_keys.clone()
+        }
    }

    async fn execute_once_normal(persist: bool, first_files: &[&str], second_files: &[&str]) {
@@ -665,7 +749,7 @@ mod tests {
            times += 1;
            async move {
                if times == 1 {
-                    Ok(Status::Executing { persist })
+                    Ok(Status::executing(persist))
                } else {
                    Ok(Status::done())
                }
@@ -675,6 +759,7 @@ mod tests {
        let normal = ProcedureAdapter {
            data: "normal".to_string(),
            lock_key: LockKey::single_exclusive("catalog.schema.table"),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: None,
        };
@@ -739,6 +824,7 @@ mod tests {
        let suspend = ProcedureAdapter {
            data: "suspend".to_string(),
            lock_key: LockKey::single_exclusive("catalog.schema.table"),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: None,
        };
@@ -763,7 +849,7 @@ mod tests {
            async move {
                if times == 1 {
                    time::sleep(Duration::from_millis(200)).await;
-                    Ok(Status::Executing { persist: true })
+                    Ok(Status::executing(true))
                } else {
                    Ok(Status::done())
                }
@@ -773,6 +859,7 @@ mod tests {
        let child = ProcedureAdapter {
            data: "child".to_string(),
            lock_key: LockKey::new_exclusive(keys.iter().map(|k| k.to_string())),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: None,
        };
@@ -842,6 +929,7 @@ mod tests {
        let parent = ProcedureAdapter {
            data: "parent".to_string(),
            lock_key: LockKey::single_exclusive("catalog.schema.table"),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: None,
        };
@@ -853,7 +941,8 @@ mod tests {
        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(parent), procedure_store.clone());
-        let manager_ctx = Arc::new(ManagerContext::new());
+        let poison_manager = Arc::new(InMemoryPoisonStore::default());
+        let manager_ctx = Arc::new(ManagerContext::new(poison_manager));
        manager_ctx.start();
        // Manually add this procedure to the manager ctx.
        assert!(manager_ctx.try_insert_procedure(meta));
@@ -885,10 +974,11 @@ mod tests {

    #[tokio::test]
    async fn test_running_is_stopped() {
-        let exec_fn = move |_| async move { Ok(Status::Executing { persist: true }) }.boxed();
+        let exec_fn = move |_| async move { Ok(Status::executing(true)) }.boxed();
        let normal = ProcedureAdapter {
            data: "normal".to_string(),
            lock_key: LockKey::single_exclusive("catalog.schema.table"),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: None,
        };
@@ -933,6 +1023,7 @@ mod tests {
        let normal = ProcedureAdapter {
            data: "fail".to_string(),
            lock_key: LockKey::single_exclusive("catalog.schema.table"),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: None,
        };
@@ -959,6 +1050,7 @@ mod tests {
        let fail = ProcedureAdapter {
            data: "fail".to_string(),
            lock_key: LockKey::single_exclusive("catalog.schema.table"),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: None,
        };
@@ -995,6 +1087,7 @@ mod tests {
        let fail = ProcedureAdapter {
            data: "fail".to_string(),
            lock_key: LockKey::single_exclusive("catalog.schema.table"),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: Some(Box::new(rollback_fn)),
        };
@@ -1046,6 +1139,7 @@ mod tests {
        let retry_later = ProcedureAdapter {
            data: "retry_later".to_string(),
            lock_key: LockKey::single_exclusive("catalog.schema.table"),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: None,
        };
@@ -1082,6 +1176,7 @@ mod tests {
        let exceed_max_retry_later = ProcedureAdapter {
            data: "exceed_max_retry_later".to_string(),
            lock_key: LockKey::single_exclusive("catalog.schema.table"),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: None,
        };
@@ -1117,6 +1212,7 @@ mod tests {
        let exceed_max_retry_later = ProcedureAdapter {
            data: "exceed_max_rollback".to_string(),
            lock_key: LockKey::single_exclusive("catalog.schema.table"),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: Some(Box::new(rollback_fn)),
        };
@@ -1159,6 +1255,7 @@ mod tests {
        let retry_later = ProcedureAdapter {
            data: "rollback_after_retry_fail".to_string(),
            lock_key: LockKey::single_exclusive("catalog.schema.table"),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: Some(Box::new(rollback_fn)),
        };
@@ -1203,6 +1300,7 @@ mod tests {
                    let fail = ProcedureAdapter {
                        data: "fail".to_string(),
                        lock_key: LockKey::single_exclusive("catalog.schema.table.region-0"),
+                        poison_keys: PoisonKeys::default(),
                        exec_fn,
                        rollback_fn: None,
                    };
@@ -1238,6 +1336,7 @@ mod tests {
        let parent = ProcedureAdapter {
            data: "parent".to_string(),
            lock_key: LockKey::single_exclusive("catalog.schema.table"),
+            poison_keys: PoisonKeys::default(),
            exec_fn,
            rollback_fn: None,
        };
@@ -1248,7 +1347,8 @@ mod tests {
        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(parent), procedure_store);
-        let manager_ctx = Arc::new(ManagerContext::new());
+        let poison_manager = Arc::new(InMemoryPoisonStore::default());
+        let manager_ctx = Arc::new(ManagerContext::new(poison_manager));
        manager_ctx.start();
        // Manually add this procedure to the manager ctx.
        assert!(manager_ctx.try_insert_procedure(meta.clone()));
@@ -1261,4 +1361,327 @@ mod tests {
        let err = meta.state().error().unwrap().output_msg();
        assert!(err.contains("subprocedure failed"), "{err}");
    }
+
+    #[tokio::test]
+    async fn test_execute_with_clean_poisons() {
+        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 {
+                    // Put the poison to the context.
+                    ctx.provider
+                        .try_put_poison(&poison_key, ctx.procedure_id)
+                        .await
+                        .unwrap();
+
+                    Ok(Status::executing(true))
+                } else {
+                    Ok(Status::executing_with_clean_poisons(true))
+                }
+            }
+            .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("clean_poisons");
+        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.clone());
+
+        // 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());
+
+        runner.manager_ctx.start();
+        runner.execute_once(&ctx).await;
+        let state = runner.meta.state();
+        assert!(state.is_running(), "{state:?}");
+
+        let procedure_id = runner
+            .manager_ctx
+            .poison_manager
+            .get_poison(&poison_key.to_string())
+            .await
+            .unwrap();
+        // poison key should be exist.
+        assert!(procedure_id.is_some());
+
+        runner.execute_once(&ctx).await;
+        let state = runner.meta.state();
+        assert!(state.is_running(), "{state:?}");
+
+        let procedure_id = runner
+            .manager_ctx
+            .poison_manager
+            .get_poison(&poison_key.to_string())
+            .await
+            .unwrap();
+        // poison key should be deleted.
+        assert!(procedure_id.is_none());
+    }
+
+    #[tokio::test]
+    async fn test_execute_error_with_clean_poisons() {
+        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 {
+                    // Put the poison to the context.
+                    ctx.provider
+                        .try_put_poison(&poison_key, ctx.procedure_id)
+                        .await
+                        .unwrap();
+
+                    Ok(Status::executing(true))
+                } else {
+                    Err(Error::external_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("error_with_clean_poisons");
+        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.clone());
+
+        // 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());
+
+        runner.manager_ctx.start();
+        runner.execute_once(&ctx).await;
+        let state = runner.meta.state();
+        assert!(state.is_running(), "{state:?}");
+
+        let procedure_id = runner
+            .manager_ctx
+            .poison_manager
+            .get_poison(&poison_key.to_string())
+            .await
+            .unwrap();
+        // poison key should be exist.
+        assert!(procedure_id.is_some());
+
+        runner.execute_once(&ctx).await;
+        let state = runner.meta.state();
+        assert!(state.is_prepare_rollback(), "{state:?}");
+
+        let procedure_id = runner
+            .manager_ctx
+            .poison_manager
+            .get_poison(&poison_key.to_string())
+            .await
+            .unwrap();
+        // poison key should be deleted.
+        assert!(procedure_id.is_none());
+    }
+
+    #[tokio::test]
+    async fn test_execute_failed_after_set_poison() {
+        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::external(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("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.clone());
+
+        // 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());
+
+        runner.manager_ctx.start();
+        runner.execute_once(&ctx).await;
+        let state = runner.meta.state();
+        assert!(state.is_running(), "{state:?}");
+
+        runner.execute_once(&ctx).await;
+        let state = runner.meta.state();
+        assert!(state.is_prepare_rollback(), "{state:?}");
+        assert!(meta.state().is_prepare_rollback());
+
+        runner.execute_once(&ctx).await;
+        let state = runner.meta.state();
+        assert!(state.is_failed(), "{state:?}");
+        assert!(meta.state().is_failed());
+
+        // Check the poison is set.
+        let procedure_id = runner
+            .manager_ctx
+            .poison_manager
+            .get_poison(&poison_key.to_string())
+            .await
+            .unwrap()
+            .unwrap();
+
+        // If the procedure is poisoned, the poison key shouldn't be deleted.
+        assert_eq!(&procedure_id.to_string(), ROOT_ID);
+    }
+
+    #[tokio::test]
+    async fn test_execute_poisoned() {
+        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();
+                    Ok(Status::Poisoned {
+                        keys: PoisonKeys::new(vec![poison_key.clone()]),
+                        error: Error::external(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("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.clone());
+
+        // 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());
+
+        runner.manager_ctx.start();
+        runner.execute_once(&ctx).await;
+        let state = runner.meta.state();
+        assert!(state.is_running(), "{state:?}");
+
+        runner.execute_once(&ctx).await;
+        let state = runner.meta.state();
+        assert!(state.is_poisoned(), "{state:?}");
+        assert!(meta.state().is_poisoned());
+        check_files(
+            &object_store,
+            &procedure_store,
+            ctx.procedure_id,
+            &["0000000000.step"],
+        )
+        .await;
+
+        // Check the poison is set.
+        let procedure_id = runner
+            .manager_ctx
+            .poison_manager
+            .get_poison(&poison_key.to_string())
+            .await
+            .unwrap()
+            .unwrap();
+
+        // If the procedure is poisoned, the poison key shouldn't be deleted.
+        assert_eq!(procedure_id, ROOT_ID);
+    }
 }
--- a/src/common/procedure/src/procedure.rs
+++ b/src/common/procedure/src/procedure.rs
@@ -14,6 +14,7 @@

 use std::any::Any;
 use std::fmt;
+use std::fmt::Display;
 use std::str::FromStr;
 use std::sync::Arc;

@@ -35,6 +36,8 @@ pub enum Status {
    Executing {
        /// Whether the framework needs to persist the procedure.
        persist: bool,
+        /// Whether the framework needs to clean the poisons.
+        clean_poisons: bool,
    },
    /// The procedure has suspended itself and is waiting for subprocedures.
    Suspended {
@@ -42,14 +45,40 @@ pub enum Status {
        /// Whether the framework needs to persist the procedure.
        persist: bool,
    },
+    /// The procedure is poisoned.
+    Poisoned {
+        /// The keys that cause the procedure to be poisoned.
+        keys: PoisonKeys,
+        /// The error that cause the procedure to be poisoned.
+        error: Error,
+    },
    /// the procedure is done.
    Done { output: Option<Output> },
 }

 impl Status {
+    /// Returns a [Status::Poisoned] with given `keys` and `error`.
+    pub fn poisoned(keys: impl IntoIterator<Item = PoisonKey>, error: Error) -> Status {
+        Status::Poisoned {
+            keys: PoisonKeys::new(keys),
+            error,
+        }
+    }
+
    /// Returns a [Status::Executing] with given `persist` flag.
    pub fn executing(persist: bool) -> Status {
-        Status::Executing { persist }
+        Status::Executing {
+            persist,
+            clean_poisons: false,
+        }
+    }
+
+    /// Returns a [Status::Executing] with given `persist` flag and clean poisons.
+    pub fn executing_with_clean_poisons(persist: bool) -> Status {
+        Status::Executing {
+            persist,
+            clean_poisons: true,
+        }
    }

    /// Returns a [Status::Done] without output.
@@ -86,11 +115,20 @@ impl Status {

    /// Returns `true` if the procedure needs the framework to persist its intermediate state.
    pub fn need_persist(&self) -> bool {
-        // If the procedure is done, the framework doesn't need to persist the procedure
-        // anymore. It only needs to mark the procedure as committed.
        match self {
-            Status::Executing { persist } | Status::Suspended { persist, .. } => *persist,
-            Status::Done { .. } => false,
+            // If the procedure is done/poisoned, the framework doesn't need to persist the procedure
+            // anymore. It only needs to mark the procedure as committed.
+            Status::Executing { persist, .. } | Status::Suspended { persist, .. } => *persist,
+            Status::Done { .. } | Status::Poisoned { .. } => false,
+        }
+    }
+
+    /// Returns `true` if the framework needs to clean the poisons.
+    pub fn need_clean_poisons(&self) -> bool {
+        match self {
+            Status::Executing { clean_poisons, .. } => *clean_poisons,
+            Status::Done { .. } => true,
+            _ => false,
        }
    }
 }
@@ -100,6 +138,12 @@ impl Status {
 pub trait ContextProvider: Send + Sync {
    /// Query the procedure state.
    async fn procedure_state(&self, procedure_id: ProcedureId) -> Result<Option<ProcedureState>>;
+
+    /// Try to put a poison key for a procedure.
+    ///
+    /// This method is used to mark a resource as being operated on by a procedure.
+    /// If the poison key already exists with a different value, the operation will fail.
+    async fn try_put_poison(&self, key: &PoisonKey, procedure_id: ProcedureId) -> Result<()>;
 }

 /// Reference-counted pointer to [ContextProvider].
@@ -147,6 +191,11 @@ pub trait Procedure: Send {

    /// Returns the [LockKey] that this procedure needs to acquire.
    fn lock_key(&self) -> LockKey;
+
+    /// Returns the [PoisonKeys] that may cause this procedure to become poisoned during execution.
+    fn poison_keys(&self) -> PoisonKeys {
+        PoisonKeys::default()
+    }
 }

 #[async_trait]
@@ -174,6 +223,54 @@ impl<T: Procedure + ?Sized> Procedure for Box<T> {
    fn lock_key(&self) -> LockKey {
        (**self).lock_key()
    }
+
+    fn poison_keys(&self) -> PoisonKeys {
+        (**self).poison_keys()
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct PoisonKey(String);
+
+impl Display for PoisonKey {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl PoisonKey {
+    /// Creates a new [PoisonKey] from a [String].
+    pub fn new(key: impl Into<String>) -> Self {
+        Self(key.into())
+    }
+}
+
+/// A collection of [PoisonKey]s.
+///
+/// This type is used to represent the keys that may cause the procedure to become poisoned during execution.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
+pub struct PoisonKeys(SmallVec<[PoisonKey; 2]>);
+
+impl PoisonKeys {
+    /// Creates a new [PoisonKeys] from a [String].
+    pub fn single(key: impl Into<String>) -> Self {
+        Self(smallvec![PoisonKey::new(key)])
+    }
+
+    /// Creates a new [PoisonKeys] from a [PoisonKey].
+    pub fn new(keys: impl IntoIterator<Item = PoisonKey>) -> Self {
+        Self(keys.into_iter().collect())
+    }
+
+    /// Returns `true` if the [PoisonKeys] contains the given [PoisonKey].
+    pub fn contains(&self, key: &PoisonKey) -> bool {
+        self.0.contains(key)
+    }
+
+    /// Returns an iterator over the [PoisonKey]s.
+    pub fn iter(&self) -> impl Iterator<Item = &PoisonKey> {
+        self.0.iter()
+    }
 }

 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -325,6 +422,8 @@ pub enum ProcedureState {
    RollingBack { error: Arc<Error> },
    /// The procedure is failed and cannot proceed anymore.
    Failed { error: Arc<Error> },
+    /// The procedure is poisoned.
+    Poisoned { keys: PoisonKeys, error: Arc<Error> },
 }

 impl ProcedureState {
@@ -348,6 +447,11 @@ impl ProcedureState {
        ProcedureState::Retrying { error }
    }

+    /// Returns a [ProcedureState] with poisoned state.
+    pub fn poisoned(keys: PoisonKeys, error: Arc<Error>) -> ProcedureState {
+        ProcedureState::Poisoned { keys, error }
+    }
+
    /// Returns true if the procedure state is running.
    pub fn is_running(&self) -> bool {
        matches!(self, ProcedureState::Running)
@@ -358,6 +462,11 @@ impl ProcedureState {
        matches!(self, ProcedureState::Done { .. })
    }

+    /// Returns true if the procedure state is poisoned.
+    pub fn is_poisoned(&self) -> bool {
+        matches!(self, ProcedureState::Poisoned { .. })
+    }
+
    /// Returns true if the procedure state failed.
    pub fn is_failed(&self) -> bool {
        matches!(self, ProcedureState::Failed { .. })
@@ -384,6 +493,7 @@ impl ProcedureState {
            ProcedureState::Failed { error } => Some(error),
            ProcedureState::Retrying { error } => Some(error),
            ProcedureState::RollingBack { error } => Some(error),
+            ProcedureState::Poisoned { error, .. } => Some(error),
            _ => None,
        }
    }
@@ -397,6 +507,7 @@ impl ProcedureState {
            ProcedureState::Failed { .. } => "Failed",
            ProcedureState::PrepareRollback { .. } => "PrepareRollback",
            ProcedureState::RollingBack { .. } => "RollingBack",
+            ProcedureState::Poisoned { .. } => "Poisoned",
        }
    }
 }
@@ -470,12 +581,18 @@ mod tests {

    #[test]
    fn test_status() {
-        let status = Status::Executing { persist: false };
+        let status = Status::executing(false);
        assert!(!status.need_persist());

-        let status = Status::Executing { persist: true };
+        let status = Status::executing(true);
        assert!(status.need_persist());

+        let status = Status::executing_with_clean_poisons(false);
+        assert!(status.need_clean_poisons());
+
+        let status = Status::executing_with_clean_poisons(true);
+        assert!(status.need_clean_poisons());
+
        let status = Status::Suspended {
            subprocedures: Vec::new(),
            persist: false,
@@ -490,6 +607,7 @@ mod tests {

        let status = Status::done();
        assert!(!status.need_persist());
+        assert!(status.need_clean_poisons());
    }

    #[test]
--- a/src/common/procedure/src/store.rs
+++ b/src/common/procedure/src/store.rs
@@ -24,6 +24,7 @@ use crate::error::{Result, ToJsonSnafu};
 pub(crate) use crate::store::state_store::StateStoreRef;
 use crate::ProcedureId;

+pub mod poison_store;
 pub mod state_store;
 pub mod util;

@@ -341,6 +342,7 @@ mod tests {

    use object_store::ObjectStore;

+    use crate::procedure::PoisonKeys;
    use crate::store::state_store::ObjectStateStore;
    use crate::BoxedProcedure;

@@ -503,6 +505,10 @@ mod tests {
        fn lock_key(&self) -> LockKey {
            LockKey::default()
        }
+
+        fn poison_keys(&self) -> PoisonKeys {
+            PoisonKeys::default()
+        }
    }

    #[tokio::test]
--- a/src/common/procedure/src/store/poison_store.rs
+++ b/src/common/procedure/src/store/poison_store.rs
@@ -0,0 +1,59 @@
+// 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 crate::error::Result;
+
+pub type PoisonStoreRef = Arc<dyn PoisonStore>;
+
+/// Poison store.
+///
+/// This trait is used to manage the state of operations on resources, particularly
+/// when an operation encounters an unrecoverable error, potentially leading to
+/// metadata inconsistency. In such cases, manual intervention is required to
+/// resolve the issue before any further operations can be performed on the resource.
+///
+/// ## Behavior:
+/// - **Insertion**: When an operation begins on a resource, a "poison" key is inserted
+///   into the state store to indicate the operation is in progress.
+/// - **Deletion**: If the operation completes successfully or
+///   other cases can ensure the resource is in a consistent state, the poison key is removed
+///   from the state store, indicating the resource is in a consistent state.
+/// - **Failure Handling**:
+///   - If the operation fails or other cases may lead to metadata inconsistency,
+///     the poison key remains in the state store.
+///   - The presence of this key indicates that the resource has encountered an
+///     unrecoverable error and the metadata may be inconsistent.
+///   - New operations on the same resource are rejected until the resource is
+///     manually recovered and the poison key is removed.
+#[async_trait]
+pub trait PoisonStore: Send + Sync {
+    /// Try to put the poison key.
+    ///
+    /// If the poison key already exists with a different value, the operation will fail.
+    async fn try_put_poison(&self, key: String, token: String) -> Result<()>;
+
+    /// Delete the poison key.
+    ///
+    /// If the poison key exists with a different value, the operation will fail.
+    async fn delete_poison(&self, key: String, token: String) -> Result<()>;
+
+    /// Get the poison key.
+    ///
+    /// If the poison key does not exist, the operation will return `None`.
+    async fn get_poison(&self, key: &str) -> Result<Option<String>>;
+}
--- a/src/common/procedure/src/test_util.rs
+++ b/src/common/procedure/src/test_util.rs
@@ -0,0 +1,85 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+
+use snafu::ensure;
+
+use super::*;
+use crate::error;
+use crate::store::poison_store::PoisonStore;
+
+/// A poison store that uses an in-memory map to store the poison state.
+#[derive(Debug, Default)]
+pub struct InMemoryPoisonStore {
+    map: Arc<RwLock<HashMap<String, String>>>,
+}
+
+impl InMemoryPoisonStore {
+    /// Create a new in-memory poison manager.
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+#[async_trait::async_trait]
+impl PoisonStore for InMemoryPoisonStore {
+    async fn try_put_poison(&self, key: String, token: String) -> Result<()> {
+        let mut map = self.map.write().unwrap();
+        match map.entry(key) {
+            Entry::Vacant(v) => {
+                v.insert(token.to_string());
+            }
+            Entry::Occupied(o) => {
+                let value = o.get();
+                ensure!(
+                    value == &token,
+                    error::UnexpectedSnafu {
+                        err_msg: format!("The poison is already set by other token {}", value)
+                    }
+                );
+            }
+        }
+        Ok(())
+    }
+
+    async fn delete_poison(&self, key: String, token: String) -> Result<()> {
+        let mut map = self.map.write().unwrap();
+        match map.entry(key) {
+            Entry::Vacant(_) => {
+                // do nothing
+            }
+            Entry::Occupied(o) => {
+                let value = o.get();
+                ensure!(
+                    value == &token,
+                    error::UnexpectedSnafu {
+                        err_msg: format!("The poison is not set by the token {}", value)
+                    }
+                );
+
+                o.remove();
+            }
+        }
+        Ok(())
+    }
+
+    async fn get_poison(&self, key: &str) -> Result<Option<String>> {
+        let map = self.map.read().unwrap();
+        let key = key.to_string();
+        Ok(map.get(&key).cloned())
+    }
+}
--- a/src/common/procedure/src/watcher.rs
+++ b/src/common/procedure/src/watcher.rs
@@ -43,6 +43,10 @@ pub async fn wait(watcher: &mut Watcher) -> Result<Option<Output>> {
            ProcedureState::PrepareRollback { error } => {
                debug!("commit rollback, source: {}", error)
            }
+            ProcedureState::Poisoned { error, .. } => {
+                debug!("poisoned, source: {}", error);
+                return Err(error.clone()).context(ProcedureExecSnafu);
+            }
        }
    }
 }
@@ -61,7 +65,9 @@ mod tests {
    use super::*;
    use crate::error::Error;
    use crate::local::{test_util, LocalManager, ManagerConfig};
+    use crate::procedure::PoisonKeys;
    use crate::store::state_store::ObjectStateStore;
+    use crate::test_util::InMemoryPoisonStore;
    use crate::{
        Context, LockKey, Procedure, ProcedureId, ProcedureManager, ProcedureWithId, Status,
    };
@@ -76,7 +82,8 @@ mod tests {
            ..Default::default()
        };
        let state_store = Arc::new(ObjectStateStore::new(test_util::new_object_store(&dir)));
-        let manager = LocalManager::new(config, state_store);
+        let poison_manager = Arc::new(InMemoryPoisonStore::default());
+        let manager = LocalManager::new(config, state_store, poison_manager);
        manager.start().await.unwrap();

        #[derive(Debug)]
@@ -106,6 +113,10 @@ mod tests {
            fn lock_key(&self) -> LockKey {
                LockKey::single_exclusive("test.submit")
            }
+
+            fn poison_keys(&self) -> PoisonKeys {
+                PoisonKeys::default()
+            }
        }

        let procedure_id = ProcedureId::random();
--- a/src/common/recordbatch/src/filter.rs
+++ b/src/common/recordbatch/src/filter.rs
@@ -26,6 +26,7 @@ use datafusion_common::cast::{as_boolean_array, as_null_array};
 use datafusion_common::{internal_err, DataFusionError, ScalarValue};
 use datatypes::arrow::array::{Array, BooleanArray, RecordBatch};
 use datatypes::arrow::compute::filter_record_batch;
+use datatypes::compute::or_kleene;
 use datatypes::vectors::VectorRef;
 use snafu::ResultExt;

@@ -47,6 +48,8 @@ pub struct SimpleFilterEvaluator {
    literal: Scalar<ArrayRef>,
    /// The operator.
    op: Operator,
+    /// Only used when the operator is `Or`-chain.
+    literal_list: Vec<Scalar<ArrayRef>>,
 }

 impl SimpleFilterEvaluator {
@@ -69,6 +72,7 @@ impl SimpleFilterEvaluator {
            column_name,
            literal: val.to_scalar().ok()?,
            op,
+            literal_list: vec![],
        })
    }

@@ -83,6 +87,35 @@ impl SimpleFilterEvaluator {
                    | Operator::LtEq
                    | Operator::Gt
                    | Operator::GtEq => {}
+                    Operator::Or => {
+                        let lhs = Self::try_new(&binary.left)?;
+                        let rhs = Self::try_new(&binary.right)?;
+                        if lhs.column_name != rhs.column_name
+                            || !matches!(lhs.op, Operator::Eq | Operator::Or)
+                            || !matches!(rhs.op, Operator::Eq | Operator::Or)
+                        {
+                            return None;
+                        }
+                        let mut list = vec![];
+                        let placeholder_literal = lhs.literal.clone();
+                        // above check guarantees the op is either `Eq` or `Or`
+                        if matches!(lhs.op, Operator::Or) {
+                            list.extend(lhs.literal_list);
+                        } else {
+                            list.push(lhs.literal);
+                        }
+                        if matches!(rhs.op, Operator::Or) {
+                            list.extend(rhs.literal_list);
+                        } else {
+                            list.push(rhs.literal);
+                        }
+                        return Some(Self {
+                            column_name: lhs.column_name,
+                            literal: placeholder_literal,
+                            op: Operator::Or,
+                            literal_list: list,
+                        });
+                    }
                    _ => return None,
                }

@@ -103,6 +136,7 @@ impl SimpleFilterEvaluator {
                    column_name: lhs.name.clone(),
                    literal,
                    op,
+                    literal_list: vec![],
                })
            }
            _ => None,
@@ -118,19 +152,19 @@ impl SimpleFilterEvaluator {
        let input = input
            .to_scalar()
            .with_context(|_| ToArrowScalarSnafu { v: input.clone() })?;
-        let result = self.evaluate_datum(&input)?;
+        let result = self.evaluate_datum(&input, 1)?;
        Ok(result.value(0))
    }

    pub fn evaluate_array(&self, input: &ArrayRef) -> Result<BooleanBuffer> {
-        self.evaluate_datum(input)
+        self.evaluate_datum(input, input.len())
    }

    pub fn evaluate_vector(&self, input: &VectorRef) -> Result<BooleanBuffer> {
-        self.evaluate_datum(&input.to_arrow_array())
+        self.evaluate_datum(&input.to_arrow_array(), input.len())
    }

-    fn evaluate_datum(&self, input: &impl Datum) -> Result<BooleanBuffer> {
+    fn evaluate_datum(&self, input: &impl Datum, input_len: usize) -> Result<BooleanBuffer> {
        let result = match self.op {
            Operator::Eq => cmp::eq(input, &self.literal),
            Operator::NotEq => cmp::neq(input, &self.literal),
@@ -138,6 +172,15 @@ impl SimpleFilterEvaluator {
            Operator::LtEq => cmp::lt_eq(input, &self.literal),
            Operator::Gt => cmp::gt(input, &self.literal),
            Operator::GtEq => cmp::gt_eq(input, &self.literal),
+            Operator::Or => {
+                // OR operator stands for OR-chained EQs (or INLIST in other words)
+                let mut result: BooleanArray = vec![false; input_len].into();
+                for literal in &self.literal_list {
+                    let rhs = cmp::eq(input, literal).context(ArrowComputeSnafu)?;
+                    result = or_kleene(&result, &rhs).context(ArrowComputeSnafu)?;
+                }
+                Ok(result)
+            }
            _ => {
                return UnsupportedOperationSnafu {
                    reason: format!("{:?}", self.op),
@@ -349,4 +392,49 @@ mod test {
        let expected = datatypes::arrow::array::Int32Array::from(vec![5, 6]);
        assert_eq!(first_column_values, &expected);
    }
+
+    #[test]
+    fn test_complex_filter_expression() {
+        // Create an expression tree for: col = 'B' OR col = 'C' OR col = 'D'
+        let col_eq_b = col("col").eq(lit("B"));
+        let col_eq_c = col("col").eq(lit("C"));
+        let col_eq_d = col("col").eq(lit("D"));
+
+        // Build the OR chain
+        let col_or_expr = col_eq_b.or(col_eq_c).or(col_eq_d);
+
+        // Check that SimpleFilterEvaluator can handle OR chain
+        let or_evaluator = SimpleFilterEvaluator::try_new(&col_or_expr).unwrap();
+        assert_eq!(or_evaluator.column_name, "col");
+        assert_eq!(or_evaluator.op, Operator::Or);
+        assert_eq!(or_evaluator.literal_list.len(), 3);
+        assert_eq!(format!("{:?}", or_evaluator.literal_list), "[Scalar(StringArray\n[\n  \"B\",\n]), Scalar(StringArray\n[\n  \"C\",\n]), Scalar(StringArray\n[\n  \"D\",\n])]");
+
+        // Create a schema and batch for testing
+        let schema = Schema::new(vec![Field::new("col", DataType::Utf8, false)]);
+        let df_schema = DFSchema::try_from(schema.clone()).unwrap();
+        let props = ExecutionProps::new();
+        let physical_expr = create_physical_expr(&col_or_expr, &df_schema, &props).unwrap();
+
+        // Create test data
+        let col_data = Arc::new(datatypes::arrow::array::StringArray::from(vec![
+            "B", "C", "E", "B", "C", "D", "F",
+        ]));
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![col_data]).unwrap();
+        let expected = datatypes::arrow::array::StringArray::from(vec!["B", "C", "B", "C", "D"]);
+
+        // Filter the batch
+        let filtered_batch = batch_filter(&batch, &physical_expr).unwrap();
+
+        // Expected: rows with col in ("B", "C", "D")
+        // That would be rows 0, 1, 3, 4, 5
+        assert_eq!(filtered_batch.num_rows(), 5);
+
+        let col_filtered = filtered_batch
+            .column(0)
+            .as_any()
+            .downcast_ref::<datatypes::arrow::array::StringArray>()
+            .unwrap();
+        assert_eq!(col_filtered, &expected);
+    }
 }
--- a/src/common/time/src/datetime.rs
+++ b/src/common/time/src/datetime.rs
@@ -1,407 +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::fmt::{Display, Formatter, Write};
-
-use chrono::{
-    Days, LocalResult, Months, NaiveDateTime, TimeDelta, TimeZone as ChronoTimeZone, Utc,
-};
-use serde::{Deserialize, Serialize};
-use snafu::ResultExt;
-
-use crate::error::{InvalidDateStrSnafu, Result};
-use crate::interval::{IntervalDayTime, IntervalMonthDayNano, IntervalYearMonth};
-use crate::timezone::{get_timezone, Timezone};
-use crate::util::{datetime_to_utc, format_utc_datetime};
-use crate::Date;
-
-const DATETIME_FORMAT: &str = "%F %H:%M:%S%.f";
-const DATETIME_FORMAT_WITH_TZ: &str = "%F %H:%M:%S%.f%z";
-
-/// [DateTime] represents the **milliseconds elapsed since "1970-01-01 00:00:00 UTC" (UNIX Epoch)**.
-#[derive(
-    Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
-)]
-pub struct DateTime(i64);
-
-impl Display for DateTime {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        if let Some(abs_time) = chrono::DateTime::from_timestamp_millis(self.0) {
-            write!(
-                f,
-                "{}",
-                format_utc_datetime(&abs_time.naive_utc(), DATETIME_FORMAT_WITH_TZ)
-            )
-        } else {
-            write!(f, "DateTime({})", self.0)
-        }
-    }
-}
-
-impl From<DateTime> for serde_json::Value {
-    fn from(d: DateTime) -> Self {
-        serde_json::Value::String(d.to_string())
-    }
-}
-
-impl From<NaiveDateTime> for DateTime {
-    fn from(value: NaiveDateTime) -> Self {
-        DateTime::from(value.and_utc().timestamp_millis())
-    }
-}
-
-impl From<i64> for DateTime {
-    fn from(v: i64) -> Self {
-        Self(v)
-    }
-}
-
-impl From<Date> for DateTime {
-    fn from(value: Date) -> Self {
-        // It's safe, i32 * 86400000 won't be overflow
-        Self(value.to_secs() * 1000)
-    }
-}
-
-impl DateTime {
-    /// Try parsing a string into [`DateTime`] with the system timezone.
-    /// See `DateTime::from_str`.
-    pub fn from_str_system(s: &str) -> Result<Self> {
-        Self::from_str(s, None)
-    }
-
-    /// Try parsing a string into [`DateTime`] with the given timezone.
-    /// Supported format:
-    /// - RFC3339 in the naive UTC timezone.
-    /// - `%F %T`  with the given timezone
-    /// - `%F %T%z`  with the timezone in string
-    pub fn from_str(s: &str, timezone: Option<&Timezone>) -> Result<Self> {
-        let s = s.trim();
-        let timestamp_millis = if let Ok(dt) = chrono::DateTime::parse_from_rfc3339(s) {
-            dt.naive_utc().and_utc().timestamp_millis()
-        } else if let Ok(d) = NaiveDateTime::parse_from_str(s, DATETIME_FORMAT) {
-            match datetime_to_utc(&d, get_timezone(timezone)) {
-                LocalResult::None => {
-                    return InvalidDateStrSnafu { raw: s }.fail();
-                }
-                LocalResult::Single(t) | LocalResult::Ambiguous(t, _) => {
-                    t.and_utc().timestamp_millis()
-                }
-            }
-        } else if let Ok(v) = chrono::DateTime::parse_from_str(s, DATETIME_FORMAT_WITH_TZ) {
-            v.timestamp_millis()
-        } else {
-            return InvalidDateStrSnafu { raw: s }.fail();
-        };
-
-        Ok(Self(timestamp_millis))
-    }
-
-    /// Create a new [DateTime] from milliseconds elapsed since "1970-01-01 00:00:00 UTC" (UNIX Epoch).
-    pub fn new(millis: i64) -> Self {
-        Self(millis)
-    }
-
-    /// Get the milliseconds elapsed since "1970-01-01 00:00:00 UTC" (UNIX Epoch).
-    pub fn val(&self) -> i64 {
-        self.0
-    }
-
-    /// Convert to [NaiveDateTime].
-    pub fn to_chrono_datetime(&self) -> Option<NaiveDateTime> {
-        chrono::DateTime::from_timestamp_millis(self.0).map(|x| x.naive_utc())
-    }
-
-    /// Format DateTime for given format and timezone.
-    /// If `tz==None`, the server default timezone will used.
-    pub fn as_formatted_string(
-        self,
-        pattern: &str,
-        timezone: Option<&Timezone>,
-    ) -> Result<Option<String>> {
-        if let Some(v) = self.to_chrono_datetime() {
-            let mut formatted = String::new();
-
-            match get_timezone(timezone) {
-                Timezone::Offset(offset) => {
-                    write!(
-                        formatted,
-                        "{}",
-                        offset.from_utc_datetime(&v).format(pattern)
-                    )
-                    .context(crate::error::FormatSnafu { pattern })?;
-                }
-                Timezone::Named(tz) => {
-                    write!(formatted, "{}", tz.from_utc_datetime(&v).format(pattern))
-                        .context(crate::error::FormatSnafu { pattern })?;
-                }
-            }
-
-            return Ok(Some(formatted));
-        }
-
-        Ok(None)
-    }
-
-    pub fn to_chrono_datetime_with_timezone(&self, tz: Option<&Timezone>) -> Option<NaiveDateTime> {
-        let datetime = self.to_chrono_datetime();
-        datetime.map(|v| match tz {
-            Some(Timezone::Offset(offset)) => offset.from_utc_datetime(&v).naive_local(),
-            Some(Timezone::Named(tz)) => tz.from_utc_datetime(&v).naive_local(),
-            None => Utc.from_utc_datetime(&v).naive_local(),
-        })
-    }
-
-    // FIXME(yingwen): remove add/sub intervals later
-    /// Adds given [IntervalYearMonth] to the current datetime.
-    pub fn add_year_month(&self, interval: IntervalYearMonth) -> Option<Self> {
-        let naive_datetime = self.to_chrono_datetime()?;
-
-        naive_datetime
-            .checked_add_months(Months::new(interval.months as u32))
-            .map(Into::into)
-    }
-
-    /// Adds given [IntervalDayTime] to the current datetime.
-    pub fn add_day_time(&self, interval: IntervalDayTime) -> Option<Self> {
-        let naive_datetime = self.to_chrono_datetime()?;
-
-        naive_datetime
-            .checked_add_days(Days::new(interval.days as u64))?
-            .checked_add_signed(TimeDelta::milliseconds(interval.milliseconds as i64))
-            .map(Into::into)
-    }
-
-    /// Adds given [IntervalMonthDayNano] to the current datetime.
-    pub fn add_month_day_nano(&self, interval: IntervalMonthDayNano) -> Option<Self> {
-        let naive_datetime = self.to_chrono_datetime()?;
-
-        naive_datetime
-            .checked_add_months(Months::new(interval.months as u32))?
-            .checked_add_days(Days::new(interval.days as u64))?
-            .checked_add_signed(TimeDelta::nanoseconds(interval.nanoseconds))
-            .map(Into::into)
-    }
-
-    /// Subtracts given [IntervalYearMonth] to the current datetime.
-    pub fn sub_year_month(&self, interval: IntervalYearMonth) -> Option<Self> {
-        let naive_datetime = self.to_chrono_datetime()?;
-
-        naive_datetime
-            .checked_sub_months(Months::new(interval.months as u32))
-            .map(Into::into)
-    }
-
-    /// Subtracts given [IntervalDayTime] to the current datetime.
-    pub fn sub_day_time(&self, interval: IntervalDayTime) -> Option<Self> {
-        let naive_datetime = self.to_chrono_datetime()?;
-
-        naive_datetime
-            .checked_sub_days(Days::new(interval.days as u64))?
-            .checked_sub_signed(TimeDelta::milliseconds(interval.milliseconds as i64))
-            .map(Into::into)
-    }
-
-    /// Subtracts given [IntervalMonthDayNano] to the current datetime.
-    pub fn sub_month_day_nano(&self, interval: IntervalMonthDayNano) -> Option<Self> {
-        let naive_datetime = self.to_chrono_datetime()?;
-
-        naive_datetime
-            .checked_sub_months(Months::new(interval.months as u32))?
-            .checked_sub_days(Days::new(interval.days as u64))?
-            .checked_sub_signed(TimeDelta::nanoseconds(interval.nanoseconds))
-            .map(Into::into)
-    }
-
-    /// Convert to [common_time::date].
-    pub fn to_date(&self) -> Option<Date> {
-        self.to_chrono_datetime().map(|d| Date::from(d.date()))
-    }
-
-    pub fn negative(&self) -> Self {
-        Self(-self.0)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::timezone::set_default_timezone;
-
-    #[test]
-    pub fn test_new_date_time() {
-        set_default_timezone(Some("Asia/Shanghai")).unwrap();
-        assert_eq!("1970-01-01 08:00:00+0800", DateTime::new(0).to_string());
-        assert_eq!("1970-01-01 08:00:01+0800", DateTime::new(1000).to_string());
-        assert_eq!("1970-01-01 07:59:59+0800", DateTime::new(-1000).to_string());
-    }
-
-    #[test]
-    pub fn test_parse_from_string() {
-        set_default_timezone(Some("Asia/Shanghai")).unwrap();
-        let time = "1970-01-01 00:00:00+0800";
-        let dt = DateTime::from_str(time, None).unwrap();
-        assert_eq!(time, &dt.to_string());
-        let dt = DateTime::from_str("      1970-01-01       00:00:00+0800       ", None).unwrap();
-        assert_eq!(time, &dt.to_string());
-    }
-
-    #[test]
-    pub fn test_from() {
-        let d: DateTime = 42.into();
-        assert_eq!(42, d.val());
-    }
-
-    #[test]
-    fn test_add_sub_interval() {
-        let datetime = DateTime::new(1000);
-
-        let interval = IntervalDayTime::new(1, 200);
-
-        let new_datetime = datetime.add_day_time(interval).unwrap();
-        assert_eq!(new_datetime.val(), 1000 + 3600 * 24 * 1000 + 200);
-
-        assert_eq!(datetime, new_datetime.sub_day_time(interval).unwrap());
-    }
-
-    #[test]
-    fn test_parse_local_date_time() {
-        set_default_timezone(Some("Asia/Shanghai")).unwrap();
-        assert_eq!(
-            -28800000,
-            DateTime::from_str("1970-01-01 00:00:00", None)
-                .unwrap()
-                .val()
-        );
-        assert_eq!(
-            0,
-            DateTime::from_str("1970-01-01 08:00:00", None)
-                .unwrap()
-                .val()
-        );
-        assert_eq!(
-            42,
-            DateTime::from_str("1970-01-01 08:00:00.042", None)
-                .unwrap()
-                .val()
-        );
-        assert_eq!(
-            42,
-            DateTime::from_str("1970-01-01 08:00:00.042424", None)
-                .unwrap()
-                .val()
-        );
-
-        assert_eq!(
-            0,
-            DateTime::from_str(
-                "1970-01-01 08:00:00",
-                Some(&Timezone::from_tz_string("Asia/Shanghai").unwrap())
-            )
-            .unwrap()
-            .val()
-        );
-
-        assert_eq!(
-            -28800000,
-            DateTime::from_str(
-                "1970-01-01 00:00:00",
-                Some(&Timezone::from_tz_string("Asia/Shanghai").unwrap())
-            )
-            .unwrap()
-            .val()
-        );
-
-        assert_eq!(
-            28800000,
-            DateTime::from_str(
-                "1970-01-01 00:00:00",
-                Some(&Timezone::from_tz_string("-8:00").unwrap())
-            )
-            .unwrap()
-            .val()
-        );
-    }
-
-    #[test]
-    fn test_parse_local_date_time_with_tz() {
-        let ts = DateTime::from_str("1970-01-01 08:00:00+0000", None)
-            .unwrap()
-            .val();
-        assert_eq!(28800000, ts);
-        let ts = DateTime::from_str("1970-01-01 00:00:00.042+0000", None)
-            .unwrap()
-            .val();
-        assert_eq!(42, ts);
-
-        // the string has the time zone info, the argument doesn't change the result
-        let ts = DateTime::from_str(
-            "1970-01-01 08:00:00+0000",
-            Some(&Timezone::from_tz_string("-8:00").unwrap()),
-        )
-        .unwrap()
-        .val();
-        assert_eq!(28800000, ts);
-    }
-
-    #[test]
-    fn test_as_formatted_string() {
-        let d: DateTime = DateTime::new(1000);
-
-        assert_eq!(
-            "1970-01-01",
-            d.as_formatted_string("%Y-%m-%d", None).unwrap().unwrap()
-        );
-        assert_eq!(
-            "1970-01-01 00:00:01",
-            d.as_formatted_string("%Y-%m-%d %H:%M:%S", None)
-                .unwrap()
-                .unwrap()
-        );
-        assert_eq!(
-            "1970-01-01T00:00:01:000",
-            d.as_formatted_string("%Y-%m-%dT%H:%M:%S:%3f", None)
-                .unwrap()
-                .unwrap()
-        );
-
-        assert_eq!(
-            "1970-01-01T08:00:01:000",
-            d.as_formatted_string(
-                "%Y-%m-%dT%H:%M:%S:%3f",
-                Some(&Timezone::from_tz_string("Asia/Shanghai").unwrap())
-            )
-            .unwrap()
-            .unwrap()
-        );
-    }
-
-    #[test]
-    fn test_from_max_date() {
-        let date = Date::new(i32::MAX);
-        let datetime = DateTime::from(date);
-        assert_eq!(datetime.val(), 185542587100800000);
-    }
-
-    #[test]
-    fn test_conversion_between_datetime_and_chrono_datetime() {
-        let cases = [1, 10, 100, 1000, 100000];
-        for case in cases {
-            let dt = DateTime::new(case);
-            let ndt = dt.to_chrono_datetime().unwrap();
-            let dt2 = DateTime::from(ndt);
-            assert_eq!(dt, dt2);
-        }
-    }
-}
--- a/src/common/time/src/lib.rs
+++ b/src/common/time/src/lib.rs
@@ -13,7 +13,6 @@
 // limitations under the License.

 pub mod date;
-pub mod datetime;
 pub mod duration;
 pub mod error;
 pub mod interval;
@@ -26,7 +25,6 @@ pub mod ttl;
 pub mod util;

 pub use date::Date;
-pub use datetime::DateTime;
 pub use duration::Duration;
 pub use interval::{IntervalDayTime, IntervalMonthDayNano, IntervalYearMonth};
 pub use range::RangeMillis;
--- a/src/datanode/src/alive_keeper.rs
+++ b/src/datanode/src/alive_keeper.rs
@@ -468,6 +468,7 @@ mod test {
                &[GrantedRegion {
                    region_id: region_id.as_u64(),
                    role: api::v1::meta::RegionRole::Leader.into(),
+                    extensions: HashMap::new(),
                }],
                Instant::now() + Duration::from_millis(200),
            )
--- a/src/datanode/src/config.rs
+++ b/src/datanode/src/config.rs
@@ -171,6 +171,10 @@ pub struct S3Config {
    pub secret_access_key: SecretString,
    pub endpoint: Option<String>,
    pub region: Option<String>,
+    /// Enable virtual host style so that opendal will send API requests in virtual host style instead of path style.
+    /// By default, opendal will send API to https://s3.us-east-1.amazonaws.com/bucket_name
+    /// Enabled, opendal will send API to https://bucket_name.s3.us-east-1.amazonaws.com
+    pub enable_virtual_host_style: bool,
    #[serde(flatten)]
    pub cache: ObjectStorageCacheConfig,
    pub http_client: HttpClientConfig,
@@ -185,6 +189,7 @@ impl PartialEq for S3Config {
            && self.secret_access_key.expose_secret() == other.secret_access_key.expose_secret()
            && self.endpoint == other.endpoint
            && self.region == other.region
+            && self.enable_virtual_host_style == other.enable_virtual_host_style
            && self.cache == other.cache
            && self.http_client == other.http_client
    }
@@ -289,6 +294,7 @@ impl Default for S3Config {
            root: String::default(),
            access_key_id: SecretString::from(String::default()),
            secret_access_key: SecretString::from(String::default()),
+            enable_virtual_host_style: false,
            endpoint: Option::default(),
            region: Option::default(),
            cache: ObjectStorageCacheConfig::default(),
--- a/src/datanode/src/store/s3.rs
+++ b/src/datanode/src/store/s3.rs
@@ -41,10 +41,13 @@ pub(crate) async fn new_s3_object_store(s3_config: &S3Config) -> Result<ObjectSt

    if s3_config.endpoint.is_some() {
        builder = builder.endpoint(s3_config.endpoint.as_ref().unwrap());
-    };
+    }
    if s3_config.region.is_some() {
        builder = builder.region(s3_config.region.as_ref().unwrap());
-    };
+    }
+    if s3_config.enable_virtual_host_style {
+        builder = builder.enable_virtual_host_style();
+    }

    Ok(ObjectStore::new(builder)
        .context(error::InitBackendSnafu)?
--- a/src/datatypes/src/data_type.rs
+++ b/src/datatypes/src/data_type.rs
@@ -30,13 +30,13 @@ use serde::{Deserialize, Serialize};
 use crate::error::{self, Error, Result};
 use crate::type_id::LogicalTypeId;
 use crate::types::{
-    BinaryType, BooleanType, DateTimeType, DateType, Decimal128Type, DictionaryType,
-    DurationMicrosecondType, DurationMillisecondType, DurationNanosecondType, DurationSecondType,
-    DurationType, Float32Type, Float64Type, Int16Type, Int32Type, Int64Type, Int8Type,
-    IntervalDayTimeType, IntervalMonthDayNanoType, IntervalType, IntervalYearMonthType, JsonType,
-    ListType, NullType, StringType, TimeMillisecondType, TimeType, TimestampMicrosecondType,
-    TimestampMillisecondType, TimestampNanosecondType, TimestampSecondType, TimestampType,
-    UInt16Type, UInt32Type, UInt64Type, UInt8Type, VectorType,
+    BinaryType, BooleanType, DateType, Decimal128Type, DictionaryType, DurationMicrosecondType,
+    DurationMillisecondType, DurationNanosecondType, DurationSecondType, DurationType, Float32Type,
+    Float64Type, Int16Type, Int32Type, Int64Type, Int8Type, IntervalDayTimeType,
+    IntervalMonthDayNanoType, IntervalType, IntervalYearMonthType, JsonType, ListType, NullType,
+    StringType, TimeMillisecondType, TimeType, TimestampMicrosecondType, TimestampMillisecondType,
+    TimestampNanosecondType, TimestampSecondType, TimestampType, UInt16Type, UInt32Type,
+    UInt64Type, UInt8Type, VectorType,
 };
 use crate::value::Value;
 use crate::vectors::MutableVector;
@@ -68,7 +68,6 @@ pub enum ConcreteDataType {

    // Date and time types:
    Date(DateType),
-    DateTime(DateTimeType),
    Timestamp(TimestampType),
    Time(TimeType),

@@ -107,7 +106,6 @@ impl fmt::Display for ConcreteDataType {
            ConcreteDataType::Binary(v) => write!(f, "{}", v.name()),
            ConcreteDataType::String(v) => write!(f, "{}", v.name()),
            ConcreteDataType::Date(v) => write!(f, "{}", v.name()),
-            ConcreteDataType::DateTime(v) => write!(f, "{}", v.name()),
            ConcreteDataType::Timestamp(t) => match t {
                TimestampType::Second(v) => write!(f, "{}", v.name()),
                TimestampType::Millisecond(v) => write!(f, "{}", v.name()),
@@ -163,7 +161,6 @@ impl ConcreteDataType {
            self,
            ConcreteDataType::String(_)
                | ConcreteDataType::Date(_)
-                | ConcreteDataType::DateTime(_)
                | ConcreteDataType::Timestamp(_)
                | ConcreteDataType::Time(_)
                | ConcreteDataType::Interval(_)
@@ -183,7 +180,6 @@ impl ConcreteDataType {
                | ConcreteDataType::Int32(_)
                | ConcreteDataType::Int64(_)
                | ConcreteDataType::Date(_)
-                | ConcreteDataType::DateTime(_)
                | ConcreteDataType::Timestamp(_)
                | ConcreteDataType::Time(_)
                | ConcreteDataType::Interval(_)
@@ -385,7 +381,7 @@ impl ConcreteDataType {
            &ConcreteDataType::Binary(_) | &ConcreteDataType::Vector(_) => "BYTEA",
            &ConcreteDataType::String(_) => "VARCHAR",
            &ConcreteDataType::Date(_) => "DATE",
-            &ConcreteDataType::DateTime(_) | &ConcreteDataType::Timestamp(_) => "TIMESTAMP",
+            &ConcreteDataType::Timestamp(_) => "TIMESTAMP",
            &ConcreteDataType::Time(_) => "TIME",
            &ConcreteDataType::Interval(_) => "INTERVAL",
            &ConcreteDataType::Decimal128(_) => "NUMERIC",
@@ -402,7 +398,7 @@ impl ConcreteDataType {
                &ConcreteDataType::Binary(_) => "_BYTEA",
                &ConcreteDataType::String(_) => "_VARCHAR",
                &ConcreteDataType::Date(_) => "_DATE",
-                &ConcreteDataType::DateTime(_) | &ConcreteDataType::Timestamp(_) => "_TIMESTAMP",
+                &ConcreteDataType::Timestamp(_) => "_TIMESTAMP",
                &ConcreteDataType::Time(_) => "_TIME",
                &ConcreteDataType::Interval(_) => "_INTERVAL",
                &ConcreteDataType::Decimal128(_) => "_NUMERIC",
@@ -441,7 +437,6 @@ impl TryFrom<&ArrowDataType> for ConcreteDataType {
            ArrowDataType::Float32 => Self::float32_datatype(),
            ArrowDataType::Float64 => Self::float64_datatype(),
            ArrowDataType::Date32 => Self::date_datatype(),
-            ArrowDataType::Date64 => Self::datetime_datatype(),
            ArrowDataType::Timestamp(u, _) => ConcreteDataType::from_arrow_time_unit(u),
            ArrowDataType::Interval(u) => ConcreteDataType::from_arrow_interval_unit(u),
            ArrowDataType::Binary | ArrowDataType::LargeBinary => Self::binary_datatype(),
@@ -490,7 +485,7 @@ macro_rules! impl_new_concrete_type_functions {

 impl_new_concrete_type_functions!(
    Null, Boolean, UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64,
-    Binary, Date, DateTime, String, Json
+    Binary, Date, String, Json
 );

 impl ConcreteDataType {
@@ -814,7 +809,6 @@ mod tests {
        assert!(ConcreteDataType::string_datatype().is_stringifiable());
        assert!(ConcreteDataType::binary_datatype().is_stringifiable());
        assert!(ConcreteDataType::date_datatype().is_stringifiable());
-        assert!(ConcreteDataType::datetime_datatype().is_stringifiable());
        assert!(ConcreteDataType::timestamp_second_datatype().is_stringifiable());
        assert!(ConcreteDataType::timestamp_millisecond_datatype().is_stringifiable());
        assert!(ConcreteDataType::timestamp_microsecond_datatype().is_stringifiable());
@@ -843,7 +837,6 @@ mod tests {
        assert!(ConcreteDataType::int32_datatype().is_signed());
        assert!(ConcreteDataType::int64_datatype().is_signed());
        assert!(ConcreteDataType::date_datatype().is_signed());
-        assert!(ConcreteDataType::datetime_datatype().is_signed());
        assert!(ConcreteDataType::timestamp_second_datatype().is_signed());
        assert!(ConcreteDataType::timestamp_millisecond_datatype().is_signed());
        assert!(ConcreteDataType::timestamp_microsecond_datatype().is_signed());
@@ -878,7 +871,6 @@ mod tests {
        assert!(!ConcreteDataType::int32_datatype().is_unsigned());
        assert!(!ConcreteDataType::int64_datatype().is_unsigned());
        assert!(!ConcreteDataType::date_datatype().is_unsigned());
-        assert!(!ConcreteDataType::datetime_datatype().is_unsigned());
        assert!(!ConcreteDataType::timestamp_second_datatype().is_unsigned());
        assert!(!ConcreteDataType::timestamp_millisecond_datatype().is_unsigned());
        assert!(!ConcreteDataType::timestamp_microsecond_datatype().is_unsigned());
--- a/src/datatypes/src/scalars.rs
+++ b/src/datatypes/src/scalars.rs
@@ -15,7 +15,7 @@
 use std::any::Any;

 use common_decimal::Decimal128;
-use common_time::{Date, DateTime};
+use common_time::Date;

 use crate::types::{
    Float32Type, Float64Type, Int16Type, Int32Type, Int64Type, Int8Type, UInt16Type, UInt32Type,
@@ -23,8 +23,8 @@ use crate::types::{
 };
 use crate::value::{ListValue, ListValueRef, Value};
 use crate::vectors::{
-    BinaryVector, BooleanVector, DateTimeVector, DateVector, Decimal128Vector, ListVector,
-    MutableVector, PrimitiveVector, StringVector, Vector,
+    BinaryVector, BooleanVector, DateVector, Decimal128Vector, ListVector, MutableVector,
+    PrimitiveVector, StringVector, Vector,
 };

 fn get_iter_capacity<T, I: Iterator<Item = T>>(iter: &I) -> usize {
@@ -302,27 +302,6 @@ impl ScalarRef<'_> for Decimal128 {
    }
 }

-impl Scalar for DateTime {
-    type VectorType = DateTimeVector;
-    type RefType<'a> = DateTime;
-
-    fn as_scalar_ref(&self) -> Self::RefType<'_> {
-        *self
-    }
-
-    fn upcast_gat<'short, 'long: 'short>(long: Self::RefType<'long>) -> Self::RefType<'short> {
-        long
-    }
-}
-
-impl ScalarRef<'_> for DateTime {
-    type ScalarType = DateTime;
-
-    fn to_owned_scalar(&self) -> Self::ScalarType {
-        *self
-    }
-}
-
 // Timestamp types implement Scalar and ScalarRef in `src/timestamp.rs`.

 impl Scalar for ListValue {
@@ -428,13 +407,6 @@ mod tests {
        assert_eq!(decimal, decimal.to_owned_scalar());
    }

-    #[test]
-    fn test_datetime_scalar() {
-        let dt = DateTime::new(123);
-        assert_eq!(dt, dt.as_scalar_ref());
-        assert_eq!(dt, dt.to_owned_scalar());
-    }
-
    #[test]
    fn test_list_value_scalar() {
        let list_value =
--- a/src/datatypes/src/type_id.rs
+++ b/src/datatypes/src/type_id.rs
@@ -40,9 +40,6 @@ pub enum LogicalTypeId {
    /// Date representing the elapsed time since UNIX epoch (1970-01-01)
    /// in days (32 bits).
    Date,
-    /// Datetime representing the elapsed time since UNIX epoch (1970-01-01) in
-    /// seconds/milliseconds/microseconds/nanoseconds, determined by precision.
-    DateTime,

    TimestampSecond,
    TimestampMillisecond,
@@ -100,7 +97,6 @@ impl LogicalTypeId {
            LogicalTypeId::String => ConcreteDataType::string_datatype(),
            LogicalTypeId::Binary => ConcreteDataType::binary_datatype(),
            LogicalTypeId::Date => ConcreteDataType::date_datatype(),
-            LogicalTypeId::DateTime => ConcreteDataType::datetime_datatype(),
            LogicalTypeId::TimestampSecond => ConcreteDataType::timestamp_second_datatype(),
            LogicalTypeId::TimestampMillisecond => {
                ConcreteDataType::timestamp_millisecond_datatype()
--- a/src/datatypes/src/types.rs
+++ b/src/datatypes/src/types.rs
@@ -16,7 +16,6 @@ mod binary_type;
 mod boolean_type;
 pub mod cast;
 mod date_type;
-mod datetime_type;
 mod decimal_type;
 mod dictionary_type;
 mod duration_type;
@@ -34,7 +33,6 @@ pub use binary_type::BinaryType;
 pub use boolean_type::BooleanType;
 pub use cast::{cast, cast_with_opt};
 pub use date_type::DateType;
-pub use datetime_type::DateTimeType;
 pub use decimal_type::Decimal128Type;
 pub use dictionary_type::DictionaryType;
 pub use duration_type::{
--- a/src/datatypes/src/types/cast.rs
+++ b/src/datatypes/src/types/cast.rs
@@ -119,10 +119,6 @@ pub fn can_cast_type(src_value: &Value, dest_type: &ConcreteDataType) -> bool {
        (Date(_), Int32(_) | Timestamp(_) | String(_)) => true,
        (Int32(_) | String(_) | Timestamp(_), Date(_)) => true,
        (Date(_), Date(_)) => true,
-        // DateTime type
-        (DateTime(_), Int64(_) | Timestamp(_) | String(_)) => true,
-        (Int64(_) | Timestamp(_) | String(_), DateTime(_)) => true,
-        (DateTime(_), DateTime(_)) => true,
        // Timestamp type
        (Timestamp(_), Int64(_) | String(_)) => true,
        (Int64(_) | String(_), Timestamp(_)) => true,
@@ -175,7 +171,7 @@ mod tests {
    use common_base::bytes::StringBytes;
    use common_time::time::Time;
    use common_time::timezone::set_default_timezone;
-    use common_time::{Date, DateTime, Timestamp};
+    use common_time::{Date, Timestamp};
    use ordered_float::OrderedFloat;

    use super::*;
@@ -274,7 +270,6 @@ mod tests {
            null_datatype,
            boolean_datatype,
            date_datatype,
-            datetime_datatype,
            timestamp_second_datatype,
            binary_datatype
        );
@@ -287,23 +282,12 @@ mod tests {
            timestamp_second_datatype,
            string_datatype
        );
-
-        // datetime -> other types
-        test_can_cast!(
-            Value::DateTime(DateTime::from_str_system("2021-01-01 00:00:00").unwrap()),
-            null_datatype,
-            int64_datatype,
-            timestamp_second_datatype,
-            string_datatype
-        );
-
        // timestamp -> other types
        test_can_cast!(
            Value::Timestamp(Timestamp::from_str_utc("2021-01-01 00:00:00").unwrap()),
            null_datatype,
            int64_datatype,
            date_datatype,
-            datetime_datatype,
            string_datatype
        );

--- a/src/datatypes/src/types/date_type.rs
+++ b/src/datatypes/src/types/date_type.rs
@@ -55,7 +55,6 @@ impl DataType for DateType {
            Value::Int32(v) => Some(Value::Date(Date::from(v))),
            Value::String(v) => Date::from_str_utc(v.as_utf8()).map(Value::Date).ok(),
            Value::Timestamp(v) => v.to_chrono_date().map(|date| Value::Date(date.into())),
-            Value::DateTime(v) => Some(Value::DateTime(v)),
            _ => None,
        }
    }
--- a/src/datatypes/src/types/datetime_type.rs
+++ b/src/datatypes/src/types/datetime_type.rs
@@ -1,140 +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 arrow::datatypes::{DataType as ArrowDataType, Date64Type};
-use common_time::DateTime;
-use serde::{Deserialize, Serialize};
-use snafu::OptionExt;
-
-use crate::data_type::{ConcreteDataType, DataType};
-use crate::error::{self, Result};
-use crate::prelude::{LogicalTypeId, MutableVector, ScalarVectorBuilder, Value, ValueRef, Vector};
-use crate::types::LogicalPrimitiveType;
-use crate::vectors::{DateTimeVector, DateTimeVectorBuilder, PrimitiveVector};
-
-const MILLISECOND_VARIATION: u64 = 3;
-/// Data type for [`DateTime`].
-#[derive(Debug, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
-pub struct DateTimeType;
-
-impl DateTimeType {
-    pub fn precision(&self) -> u64 {
-        MILLISECOND_VARIATION
-    }
-}
-
-impl DataType for DateTimeType {
-    fn name(&self) -> String {
-        "DateTime".to_string()
-    }
-
-    fn logical_type_id(&self) -> LogicalTypeId {
-        LogicalTypeId::DateTime
-    }
-
-    fn default_value(&self) -> Value {
-        Value::DateTime(DateTime::default())
-    }
-
-    fn as_arrow_type(&self) -> ArrowDataType {
-        ArrowDataType::Date64
-    }
-
-    fn create_mutable_vector(&self, capacity: usize) -> Box<dyn MutableVector> {
-        Box::new(DateTimeVectorBuilder::with_capacity(capacity))
-    }
-
-    fn try_cast(&self, from: Value) -> Option<Value> {
-        match from {
-            Value::Int64(v) => Some(Value::DateTime(DateTime::from(v))),
-            Value::Timestamp(v) => v.to_chrono_datetime().map(|d| Value::DateTime(d.into())),
-            Value::String(v) => DateTime::from_str_system(v.as_utf8())
-                .map(Value::DateTime)
-                .ok(),
-            _ => None,
-        }
-    }
-}
-
-impl LogicalPrimitiveType for DateTimeType {
-    type ArrowPrimitive = Date64Type;
-    type Native = i64;
-    type Wrapper = DateTime;
-    type LargestType = Self;
-
-    fn build_data_type() -> ConcreteDataType {
-        ConcreteDataType::datetime_datatype()
-    }
-
-    fn type_name() -> &'static str {
-        "DateTime"
-    }
-
-    fn cast_vector(vector: &dyn Vector) -> Result<&PrimitiveVector<Self>> {
-        vector
-            .as_any()
-            .downcast_ref::<DateTimeVector>()
-            .with_context(|| error::CastTypeSnafu {
-                msg: format!(
-                    "Failed to cast {} to DateTimeVector",
-                    vector.vector_type_name()
-                ),
-            })
-    }
-
-    fn cast_value_ref(value: ValueRef) -> Result<Option<Self::Wrapper>> {
-        match value {
-            ValueRef::Null => Ok(None),
-            ValueRef::DateTime(v) => Ok(Some(v)),
-            other => error::CastTypeSnafu {
-                msg: format!("Failed to cast value {other:?} to DateTime"),
-            }
-            .fail(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use common_time::timezone::set_default_timezone;
-    use common_time::Timestamp;
-
-    use super::*;
-
-    #[test]
-    fn test_datetime_cast() {
-        // cast from Int64
-        let val = Value::Int64(1000);
-        let dt = ConcreteDataType::datetime_datatype().try_cast(val).unwrap();
-        assert_eq!(dt, Value::DateTime(DateTime::from(1000)));
-
-        // cast from String
-        set_default_timezone(Some("Asia/Shanghai")).unwrap();
-        let val = Value::String("1970-01-01 00:00:00+0800".into());
-        let dt = ConcreteDataType::datetime_datatype().try_cast(val).unwrap();
-        assert_eq!(
-            dt,
-            Value::DateTime(DateTime::from_str_system("1970-01-01 00:00:00+0800").unwrap())
-        );
-
-        // cast from Timestamp
-        let val = Value::Timestamp(Timestamp::from_str_utc("2020-09-08 21:42:29+0800").unwrap());
-        let dt = ConcreteDataType::datetime_datatype().try_cast(val).unwrap();
-        assert_eq!(
-            dt,
-            Value::DateTime(DateTime::from_str_system("2020-09-08 21:42:29+0800").unwrap())
-        );
-    }
-}
--- a/src/datatypes/src/types/primitive_type.rs
+++ b/src/datatypes/src/types/primitive_type.rs
@@ -16,7 +16,7 @@ use std::cmp::Ordering;
 use std::fmt;

 use arrow::datatypes::{ArrowNativeType, ArrowPrimitiveType, DataType as ArrowDataType};
-use common_time::{Date, DateTime};
+use common_time::Date;
 use serde::{Deserialize, Serialize};
 use snafu::OptionExt;

@@ -25,7 +25,7 @@ use crate::error::{self, Result};
 use crate::scalars::{Scalar, ScalarRef, ScalarVectorBuilder};
 use crate::type_id::LogicalTypeId;
 use crate::types::boolean_type::bool_to_numeric;
-use crate::types::{DateTimeType, DateType};
+use crate::types::DateType;
 use crate::value::{Value, ValueRef};
 use crate::vectors::{MutableVector, PrimitiveVector, PrimitiveVectorBuilder, Vector};

@@ -157,19 +157,6 @@ impl WrapperType for Date {
    }
 }

-impl WrapperType for DateTime {
-    type LogicalType = DateTimeType;
-    type Native = i64;
-
-    fn from_native(value: Self::Native) -> Self {
-        DateTime::new(value)
-    }
-
-    fn into_native(self) -> Self::Native {
-        self.val()
-    }
-}
-
 macro_rules! define_logical_primitive_type {
    ($Native: ident, $TypeId: ident, $DataType: ident, $Largest: ident) => {
        // We need to define it as an empty struct `struct DataType {}` instead of a struct-unit
@@ -362,7 +349,6 @@ impl DataType for Int64Type {
            Value::Float32(v) => num::cast::cast(v).map(Value::Int64),
            Value::Float64(v) => num::cast::cast(v).map(Value::Int64),
            Value::String(v) => v.as_utf8().parse::<i64>().map(Value::Int64).ok(),
-            Value::DateTime(v) => Some(Value::Int64(v.val())),
            Value::Timestamp(v) => Some(Value::Int64(v.value())),
            Value::Time(v) => Some(Value::Int64(v.value())),
            // We don't allow casting interval type to int.
--- a/src/datatypes/src/types/string_type.rs
+++ b/src/datatypes/src/types/string_type.rs
@@ -75,7 +75,6 @@ impl DataType for StringType {
            Value::Float64(v) => Some(Value::String(StringBytes::from(v.to_string()))),
            Value::String(v) => Some(Value::String(v)),
            Value::Date(v) => Some(Value::String(StringBytes::from(v.to_string()))),
-            Value::DateTime(v) => Some(Value::String(StringBytes::from(v.to_string()))),
            Value::Timestamp(v) => Some(Value::String(StringBytes::from(v.to_iso8601_string()))),
            Value::Time(v) => Some(Value::String(StringBytes::from(v.to_iso8601_string()))),
            Value::IntervalYearMonth(v) => {
--- a/src/datatypes/src/types/timestamp_type.rs
+++ b/src/datatypes/src/types/timestamp_type.rs
@@ -132,7 +132,6 @@ macro_rules! impl_data_type_for_timestamp {
                        Value::Timestamp(v) => v.convert_to(TimeUnit::$unit).map(Value::Timestamp),
                        Value::String(v) => Timestamp::from_str_utc(v.as_utf8()).map(Value::Timestamp).ok(),
                        Value::Int64(v) => Some(Value::Timestamp(Timestamp::new(v, TimeUnit::$unit))),
-                        Value::DateTime(v) => Timestamp::new_second(v.val()).convert_to(TimeUnit::$unit).map(Value::Timestamp),
                        Value::Date(v) => Timestamp::new_second(v.to_secs()).convert_to(TimeUnit::$unit).map(Value::Timestamp),
                        _ => None
                    }
@@ -202,7 +201,7 @@ impl_data_type_for_timestamp!(Microsecond);
 #[cfg(test)]
 mod tests {
    use common_time::timezone::set_default_timezone;
-    use common_time::{Date, DateTime};
+    use common_time::Date;

    use super::*;

@@ -249,13 +248,6 @@ mod tests {
            .unwrap();
        assert_eq!(ts, Value::Timestamp(Timestamp::new_second(1694589525)));

-        // Datetime -> TimestampSecond
-        let dt = Value::DateTime(DateTime::from(1234567));
-        let ts = ConcreteDataType::timestamp_second_datatype()
-            .try_cast(dt)
-            .unwrap();
-        assert_eq!(ts, Value::Timestamp(Timestamp::new_second(1234567)));
-
        // Date -> TimestampMillisecond
        let d = Value::Date(Date::from_str_utc("1970-01-01").unwrap());
        let ts = ConcreteDataType::timestamp_millisecond_datatype()
--- a/src/datatypes/src/value.rs
+++ b/src/datatypes/src/value.rs
@@ -24,7 +24,6 @@ use common_base::bytes::{Bytes, StringBytes};
 use common_decimal::Decimal128;
 use common_telemetry::error;
 use common_time::date::Date;
-use common_time::datetime::DateTime;
 use common_time::interval::IntervalUnit;
 use common_time::time::Time;
 use common_time::timestamp::{TimeUnit, Timestamp};
@@ -75,7 +74,6 @@ pub enum Value {

    // Date & Time types:
    Date(Date),
-    DateTime(DateTime),
    Timestamp(Timestamp),
    Time(Time),
    Duration(Duration),
@@ -112,7 +110,6 @@ impl Display for Value {
                write!(f, "{hex}")
            }
            Value::Date(v) => write!(f, "{v}"),
-            Value::DateTime(v) => write!(f, "{v}"),
            Value::Timestamp(v) => write!(f, "{}", v.to_iso8601_string()),
            Value::Time(t) => write!(f, "{}", t.to_iso8601_string()),
            Value::IntervalYearMonth(v) => {
@@ -162,7 +159,6 @@ macro_rules! define_data_type_func {
                $struct::String(_) => ConcreteDataType::string_datatype(),
                $struct::Binary(_) => ConcreteDataType::binary_datatype(),
                $struct::Date(_) => ConcreteDataType::date_datatype(),
-                $struct::DateTime(_) => ConcreteDataType::datetime_datatype(),
                $struct::Time(t) => ConcreteDataType::time_datatype(*t.unit()),
                $struct::Timestamp(v) => ConcreteDataType::timestamp_datatype(v.unit()),
                $struct::IntervalYearMonth(_) => {
@@ -222,7 +218,6 @@ impl Value {
            Value::String(v) => ValueRef::String(v.as_utf8()),
            Value::Binary(v) => ValueRef::Binary(v),
            Value::Date(v) => ValueRef::Date(*v),
-            Value::DateTime(v) => ValueRef::DateTime(*v),
            Value::List(v) => ValueRef::List(ListValueRef::Ref { val: v }),
            Value::Timestamp(v) => ValueRef::Timestamp(*v),
            Value::Time(v) => ValueRef::Time(*v),
@@ -258,14 +253,6 @@ impl Value {
        }
    }

-    /// Cast Value to DateTime. Return None if value is not a valid datetime data type.
-    pub fn as_datetime(&self) -> Option<DateTime> {
-        match self {
-            Value::DateTime(t) => Some(*t),
-            _ => None,
-        }
-    }
-
    /// Cast Value to [Time]. Return None if value is not a valid time data type.
    pub fn as_time(&self) -> Option<Time> {
        match self {
@@ -345,7 +332,6 @@ impl Value {
            Value::Binary(_) => LogicalTypeId::Binary,
            Value::List(_) => LogicalTypeId::List,
            Value::Date(_) => LogicalTypeId::Date,
-            Value::DateTime(_) => LogicalTypeId::DateTime,
            Value::Timestamp(t) => match t.unit() {
                TimeUnit::Second => LogicalTypeId::TimestampSecond,
                TimeUnit::Millisecond => LogicalTypeId::TimestampMillisecond,
@@ -401,7 +387,6 @@ impl Value {
            Value::String(v) => ScalarValue::Utf8(Some(v.as_utf8().to_string())),
            Value::Binary(v) => ScalarValue::Binary(Some(v.to_vec())),
            Value::Date(v) => ScalarValue::Date32(Some(v.val())),
-            Value::DateTime(v) => ScalarValue::Date64(Some(v.val())),
            Value::Null => to_null_scalar_value(output_type)?,
            Value::List(list) => {
                // Safety: The logical type of the value and output_type are the same.
@@ -463,7 +448,6 @@ impl Value {
            Value::Float64(x) => Some(Value::Float64(-*x)),
            Value::Decimal128(x) => Some(Value::Decimal128(x.negative())),
            Value::Date(x) => Some(Value::Date(x.negative())),
-            Value::DateTime(x) => Some(Value::DateTime(x.negative())),
            Value::Timestamp(x) => Some(Value::Timestamp(x.negative())),
            Value::Time(x) => Some(Value::Time(x.negative())),
            Value::Duration(x) => Some(Value::Duration(x.negative())),
@@ -525,7 +509,6 @@ pub fn to_null_scalar_value(output_type: &ConcreteDataType) -> Result<ScalarValu
        }
        ConcreteDataType::String(_) => ScalarValue::Utf8(None),
        ConcreteDataType::Date(_) => ScalarValue::Date32(None),
-        ConcreteDataType::DateTime(_) => ScalarValue::Date64(None),
        ConcreteDataType::Timestamp(t) => timestamp_to_scalar_value(t.unit(), None),
        ConcreteDataType::Interval(v) => match v {
            IntervalType::YearMonth(_) => ScalarValue::IntervalYearMonth(None),
@@ -631,7 +614,6 @@ macro_rules! impl_ord_for_value_like {
                ($Type::String(v1), $Type::String(v2)) => v1.cmp(v2),
                ($Type::Binary(v1), $Type::Binary(v2)) => v1.cmp(v2),
                ($Type::Date(v1), $Type::Date(v2)) => v1.cmp(v2),
-                ($Type::DateTime(v1), $Type::DateTime(v2)) => v1.cmp(v2),
                ($Type::Timestamp(v1), $Type::Timestamp(v2)) => v1.cmp(v2),
                ($Type::Time(v1), $Type::Time(v2)) => v1.cmp(v2),
                ($Type::IntervalYearMonth(v1), $Type::IntervalYearMonth(v2)) => v1.cmp(v2),
@@ -712,7 +694,6 @@ impl_try_from_value!(String, StringBytes);
 impl_try_from_value!(Binary, Bytes);
 impl_try_from_value!(Date, Date);
 impl_try_from_value!(Time, Time);
-impl_try_from_value!(DateTime, DateTime);
 impl_try_from_value!(Timestamp, Timestamp);
 impl_try_from_value!(IntervalYearMonth, IntervalYearMonth);
 impl_try_from_value!(IntervalDayTime, IntervalDayTime);
@@ -756,7 +737,6 @@ impl_value_from!(String, StringBytes);
 impl_value_from!(Binary, Bytes);
 impl_value_from!(Date, Date);
 impl_value_from!(Time, Time);
-impl_value_from!(DateTime, DateTime);
 impl_value_from!(Timestamp, Timestamp);
 impl_value_from!(IntervalYearMonth, IntervalYearMonth);
 impl_value_from!(IntervalDayTime, IntervalDayTime);
@@ -803,7 +783,6 @@ impl TryFrom<Value> for serde_json::Value {
            Value::String(bytes) => serde_json::Value::String(bytes.into_string()),
            Value::Binary(bytes) => serde_json::to_value(bytes)?,
            Value::Date(v) => serde_json::Value::Number(v.val().into()),
-            Value::DateTime(v) => serde_json::Value::Number(v.val().into()),
            Value::List(v) => serde_json::to_value(v)?,
            Value::Timestamp(v) => serde_json::to_value(v.value())?,
            Value::Time(v) => serde_json::to_value(v.value())?,
@@ -933,9 +912,6 @@ impl TryFrom<ScalarValue> for Value {
                Value::List(ListValue::new(items, datatype))
            }
            ScalarValue::Date32(d) => d.map(|x| Value::Date(Date::new(x))).unwrap_or(Value::Null),
-            ScalarValue::Date64(d) => d
-                .map(|x| Value::DateTime(DateTime::new(x)))
-                .unwrap_or(Value::Null),
            ScalarValue::TimestampSecond(t, _) => t
                .map(|x| Value::Timestamp(Timestamp::new(x, TimeUnit::Second)))
                .unwrap_or(Value::Null),
@@ -994,7 +970,8 @@ impl TryFrom<ScalarValue> for Value {
            | ScalarValue::Float16(_)
            | ScalarValue::Utf8View(_)
            | ScalarValue::BinaryView(_)
-            | ScalarValue::Map(_) => {
+            | ScalarValue::Map(_)
+            | ScalarValue::Date64(_) => {
                return error::UnsupportedArrowTypeSnafu {
                    arrow_type: v.data_type(),
                }
@@ -1023,7 +1000,6 @@ impl From<ValueRef<'_>> for Value {
            ValueRef::String(v) => Value::String(v.into()),
            ValueRef::Binary(v) => Value::Binary(v.into()),
            ValueRef::Date(v) => Value::Date(v),
-            ValueRef::DateTime(v) => Value::DateTime(v),
            ValueRef::Timestamp(v) => Value::Timestamp(v),
            ValueRef::Time(v) => Value::Time(v),
            ValueRef::IntervalYearMonth(v) => Value::IntervalYearMonth(v),
@@ -1063,7 +1039,6 @@ pub enum ValueRef<'a> {

    // Date & Time types:
    Date(Date),
-    DateTime(DateTime),
    Timestamp(Timestamp),
    Time(Time),
    Duration(Duration),
@@ -1175,11 +1150,6 @@ impl<'a> ValueRef<'a> {
        impl_as_for_value_ref!(self, Date)
    }

-    /// Cast itself to [DateTime].
-    pub fn as_datetime(&self) -> Result<Option<DateTime>> {
-        impl_as_for_value_ref!(self, DateTime)
-    }
-
    /// Cast itself to [Timestamp].
    pub fn as_timestamp(&self) -> Result<Option<Timestamp>> {
        impl_as_for_value_ref!(self, Timestamp)
@@ -1263,7 +1233,6 @@ impl_value_ref_from!(Int64, i64);
 impl_value_ref_from!(Float32, f32);
 impl_value_ref_from!(Float64, f64);
 impl_value_ref_from!(Date, Date);
-impl_value_ref_from!(DateTime, DateTime);
 impl_value_ref_from!(Timestamp, Timestamp);
 impl_value_ref_from!(Time, Time);
 impl_value_ref_from!(IntervalYearMonth, IntervalYearMonth);
@@ -1327,7 +1296,6 @@ pub fn transform_value_ref_to_json_value<'a>(
            }
        }
        ValueRef::Date(v) => serde_json::Value::Number(v.val().into()),
-        ValueRef::DateTime(v) => serde_json::Value::Number(v.val().into()),
        ValueRef::List(v) => serde_json::to_value(v)?,
        ValueRef::Timestamp(v) => serde_json::to_value(v.value())?,
        ValueRef::Time(v) => serde_json::to_value(v.value())?,
@@ -1426,7 +1394,6 @@ impl ValueRef<'_> {
            ValueRef::String(v) => std::mem::size_of_val(v),
            ValueRef::Binary(v) => std::mem::size_of_val(v),
            ValueRef::Date(_) => 4,
-            ValueRef::DateTime(_) => 8,
            ValueRef::Timestamp(_) => 16,
            ValueRef::Time(_) => 16,
            ValueRef::Duration(_) => 16,
@@ -1462,7 +1429,9 @@ pub fn column_data_to_json(data: ValueData) -> JsonValue {
            .unwrap_or(JsonValue::Null),
        ValueData::StringValue(s) => JsonValue::String(s),
        ValueData::DateValue(d) => JsonValue::String(Date::from(d).to_string()),
-        ValueData::DatetimeValue(d) => JsonValue::String(DateTime::from(d).to_string()),
+        ValueData::DatetimeValue(d) => {
+            JsonValue::String(Timestamp::new_microsecond(d).to_iso8601_string())
+        }
        ValueData::TimeSecondValue(d) => JsonValue::String(Time::new_second(d).to_iso8601_string()),
        ValueData::TimeMillisecondValue(d) => {
            JsonValue::String(Time::new_millisecond(d).to_iso8601_string())
@@ -1511,6 +1480,7 @@ mod tests {

    #[test]
    fn test_column_data_to_json() {
+        set_default_timezone(Some("Asia/Shanghai")).unwrap();
        assert_eq!(
            column_data_to_json(ValueData::BinaryValue(b"hello".to_vec())),
            JsonValue::String("aGVsbG8=".to_string())
@@ -1569,31 +1539,31 @@ mod tests {
        );
        assert_eq!(
            column_data_to_json(ValueData::DatetimeValue(456)),
-            JsonValue::String("1970-01-01 00:00:00.456+0000".to_string())
+            JsonValue::String("1970-01-01 08:00:00.000456+0800".to_string())
        );
        assert_eq!(
            column_data_to_json(ValueData::TimeSecondValue(789)),
-            JsonValue::String("00:13:09+0000".to_string())
+            JsonValue::String("08:13:09+0800".to_string())
        );
        assert_eq!(
            column_data_to_json(ValueData::TimeMillisecondValue(789)),
-            JsonValue::String("00:00:00.789+0000".to_string())
+            JsonValue::String("08:00:00.789+0800".to_string())
        );
        assert_eq!(
            column_data_to_json(ValueData::TimeMicrosecondValue(789)),
-            JsonValue::String("00:00:00.000789+0000".to_string())
+            JsonValue::String("08:00:00.000789+0800".to_string())
        );
        assert_eq!(
            column_data_to_json(ValueData::TimestampMillisecondValue(1234567890)),
-            JsonValue::String("1970-01-15 06:56:07.890+0000".to_string())
+            JsonValue::String("1970-01-15 14:56:07.890+0800".to_string())
        );
        assert_eq!(
            column_data_to_json(ValueData::TimestampNanosecondValue(1234567890123456789)),
-            JsonValue::String("2009-02-13 23:31:30.123456789+0000".to_string())
+            JsonValue::String("2009-02-14 07:31:30.123456789+0800".to_string())
        );
        assert_eq!(
            column_data_to_json(ValueData::TimestampSecondValue(1234567890)),
-            JsonValue::String("2009-02-13 23:31:30+0000".to_string())
+            JsonValue::String("2009-02-14 07:31:30+0800".to_string())
        );
        assert_eq!(
            column_data_to_json(ValueData::IntervalYearMonthValue(12)),
@@ -1758,12 +1728,6 @@ mod tests {
        );
        assert_eq!(Value::Null, ScalarValue::Date32(None).try_into().unwrap());

-        assert_eq!(
-            Value::DateTime(DateTime::new(456)),
-            ScalarValue::Date64(Some(456)).try_into().unwrap()
-        );
-        assert_eq!(Value::Null, ScalarValue::Date64(None).try_into().unwrap());
-
        assert_eq!(
            Value::Timestamp(Timestamp::new(1, TimeUnit::Second)),
            ScalarValue::TimestampSecond(Some(1), None)
@@ -2027,10 +1991,6 @@ mod tests {
            &ConcreteDataType::date_datatype(),
            &Value::Date(Date::new(1)),
        );
-        check_type_and_value(
-            &ConcreteDataType::datetime_datatype(),
-            &Value::DateTime(DateTime::new(1)),
-        );
        check_type_and_value(
            &ConcreteDataType::timestamp_millisecond_datatype(),
            &Value::Timestamp(Timestamp::new_millisecond(1)),
@@ -2169,11 +2129,6 @@ mod tests {
            serde_json::Value::Number(5000i32.into()),
            to_json(Value::Date(Date::new(5000)))
        );
-        assert_eq!(
-            serde_json::Value::Number(5000i64.into()),
-            to_json(Value::DateTime(DateTime::new(5000)))
-        );
-
        assert_eq!(
            serde_json::Value::Number(1.into()),
            to_json(Value::Timestamp(Timestamp::new_millisecond(1)))
@@ -2259,7 +2214,6 @@ mod tests {
        );

        check_as_value_ref!(Date, Date::new(103));
-        check_as_value_ref!(DateTime, DateTime::new(1034));

        let list = ListValue {
            items: vec![],
@@ -2291,7 +2245,6 @@ mod tests {
        check_as_null!(as_string);
        check_as_null!(as_boolean);
        check_as_null!(as_date);
-        check_as_null!(as_datetime);
        check_as_null!(as_list);

        macro_rules! check_as_correct {
@@ -2304,7 +2257,6 @@ mod tests {
        check_as_correct!("hello".as_bytes(), Binary, as_binary);
        check_as_correct!(true, Boolean, as_boolean);
        check_as_correct!(Date::new(123), Date, as_date);
-        check_as_correct!(DateTime::new(12), DateTime, as_datetime);
        check_as_correct!(Time::new_second(12), Time, as_time);
        check_as_correct!(Duration::new_second(12), Duration, as_duration);
        let list = ListValue {
@@ -2318,7 +2270,6 @@ mod tests {
        assert!(wrong_value.as_string().is_err());
        assert!(wrong_value.as_boolean().is_err());
        assert!(wrong_value.as_date().is_err());
-        assert!(wrong_value.as_datetime().is_err());
        assert!(wrong_value.as_list().is_err());
        assert!(wrong_value.as_time().is_err());
        assert!(wrong_value.as_timestamp().is_err());
@@ -2346,10 +2297,6 @@ mod tests {
            "010203"
        );
        assert_eq!(Value::Date(Date::new(0)).to_string(), "1970-01-01");
-        assert_eq!(
-            Value::DateTime(DateTime::new(0)).to_string(),
-            "1970-01-01 08:00:00+0800"
-        );
        assert_eq!(
            Value::Timestamp(Timestamp::new(1000, TimeUnit::Millisecond)).to_string(),
            "1970-01-01 08:00:01+0800"
@@ -2755,7 +2702,6 @@ mod tests {
        check_value_ref_size_eq(&ValueRef::String("greptimedb"), 10);
        check_value_ref_size_eq(&ValueRef::Binary(b"greptimedb"), 10);
        check_value_ref_size_eq(&ValueRef::Date(Date::new(1)), 4);
-        check_value_ref_size_eq(&ValueRef::DateTime(DateTime::new(1)), 8);
        check_value_ref_size_eq(&ValueRef::Timestamp(Timestamp::new_millisecond(1)), 16);
        check_value_ref_size_eq(&ValueRef::Time(Time::new_millisecond(1)), 16);
        check_value_ref_size_eq(&ValueRef::IntervalYearMonth(IntervalYearMonth::new(1)), 4);
--- a/src/datatypes/src/vectors.rs
+++ b/src/datatypes/src/vectors.rs
@@ -29,7 +29,6 @@ mod binary;
 mod boolean;
 mod constant;
 mod date;
-mod datetime;
 mod decimal;
 mod duration;
 mod eq;
@@ -48,7 +47,6 @@ pub use binary::{BinaryVector, BinaryVectorBuilder};
 pub use boolean::{BooleanVector, BooleanVectorBuilder};
 pub use constant::ConstantVector;
 pub use date::{DateVector, DateVectorBuilder};
-pub use datetime::{DateTimeVector, DateTimeVectorBuilder};
 pub use decimal::{Decimal128Vector, Decimal128VectorBuilder};
 pub use duration::{
    DurationMicrosecondVector, DurationMicrosecondVectorBuilder, DurationMillisecondVector,
@@ -377,7 +375,7 @@ pub mod tests {
        // Test Primitive types
        mutable_primitive_data_type_eq_with_lower!(
            Boolean, Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64, Float32, Float64,
-            Date, DateTime, Binary, String
+            Date, Binary, String
        );

        // Test types about time
--- a/src/datatypes/src/vectors/datetime.rs
+++ b/src/datatypes/src/vectors/datetime.rs
@@ -1,116 +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 crate::types::DateTimeType;
-use crate::vectors::{PrimitiveVector, PrimitiveVectorBuilder};
-
-/// Vector of [`DateTime`](common_time::Date)
-pub type DateTimeVector = PrimitiveVector<DateTimeType>;
-/// Builder for [`DateTimeVector`].
-pub type DateTimeVectorBuilder = PrimitiveVectorBuilder<DateTimeType>;
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use arrow::array::{Array, PrimitiveArray};
-    use arrow_array::ArrayRef;
-    use common_time::timezone::set_default_timezone;
-    use common_time::DateTime;
-
-    use super::*;
-    use crate::data_type::DataType;
-    use crate::prelude::{
-        ConcreteDataType, ScalarVector, ScalarVectorBuilder, Value, ValueRef, Vector, VectorRef,
-    };
-    use crate::serialize::Serializable;
-
-    #[test]
-    fn test_datetime_vector() {
-        set_default_timezone(Some("Asia/Shanghai")).unwrap();
-        let v = DateTimeVector::new(PrimitiveArray::from(vec![1000, 2000, 3000]));
-        assert_eq!(ConcreteDataType::datetime_datatype(), v.data_type());
-        assert_eq!(3, v.len());
-        assert_eq!("DateTimeVector", v.vector_type_name());
-        assert_eq!(
-            &arrow::datatypes::DataType::Date64,
-            v.to_arrow_array().data_type()
-        );
-
-        assert_eq!(Some(DateTime::new(1000)), v.get_data(0));
-        assert_eq!(Value::DateTime(DateTime::new(1000)), v.get(0));
-        assert_eq!(ValueRef::DateTime(DateTime::new(1000)), v.get_ref(0));
-
-        let mut iter = v.iter_data();
-        assert_eq!(Some(DateTime::new(1000)), iter.next().unwrap());
-        assert_eq!(Some(DateTime::new(2000)), iter.next().unwrap());
-        assert_eq!(Some(DateTime::new(3000)), iter.next().unwrap());
-        assert!(!v.is_null(0));
-        assert_eq!(24, v.memory_size());
-
-        if let Value::DateTime(d) = v.get(0) {
-            assert_eq!(1000, d.val());
-        } else {
-            unreachable!()
-        }
-        assert_eq!(
-            "[\"1970-01-01 08:00:01+0800\",\"1970-01-01 08:00:02+0800\",\"1970-01-01 08:00:03+0800\"]",
-            serde_json::to_string(&v.serialize_to_json().unwrap()).unwrap()
-        );
-    }
-
-    #[test]
-    fn test_datetime_vector_builder() {
-        let mut builder = DateTimeVectorBuilder::with_capacity(3);
-        builder.push(Some(DateTime::new(1)));
-        builder.push(None);
-        builder.push(Some(DateTime::new(-1)));
-
-        let v = builder.finish();
-        assert_eq!(ConcreteDataType::datetime_datatype(), v.data_type());
-        assert_eq!(Value::DateTime(DateTime::new(1)), v.get(0));
-        assert_eq!(Value::Null, v.get(1));
-        assert_eq!(Value::DateTime(DateTime::new(-1)), v.get(2));
-
-        let input = DateTimeVector::from_wrapper_slice([
-            DateTime::new(1),
-            DateTime::new(2),
-            DateTime::new(3),
-        ]);
-
-        let mut builder = DateTimeType.create_mutable_vector(3);
-        builder.push_value_ref(ValueRef::DateTime(DateTime::new(5)));
-        assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
-        builder.extend_slice_of(&input, 1, 2).unwrap();
-        assert!(builder
-            .extend_slice_of(&crate::vectors::Int32Vector::from_slice([13]), 0, 1)
-            .is_err());
-        let vector = builder.to_vector();
-
-        let expect: VectorRef = Arc::new(DateTimeVector::from_wrapper_slice([
-            DateTime::new(5),
-            DateTime::new(2),
-            DateTime::new(3),
-        ]));
-        assert_eq!(expect, vector);
-    }
-
-    #[test]
-    fn test_datetime_from_arrow() {
-        let vector = DateTimeVector::from_wrapper_slice([DateTime::new(1), DateTime::new(2)]);
-        let arrow: ArrayRef = Arc::new(vector.as_arrow().slice(0, vector.len())) as _;
-        let vector2 = DateTimeVector::try_from_arrow_array(arrow).unwrap();
-        assert_eq!(vector, vector2);
-    }
-}
--- a/src/datatypes/src/vectors/eq.rs
+++ b/src/datatypes/src/vectors/eq.rs
@@ -20,12 +20,12 @@ use crate::data_type::DataType;
 use crate::types::{DurationType, TimeType, TimestampType};
 use crate::vectors::constant::ConstantVector;
 use crate::vectors::{
-    BinaryVector, BooleanVector, DateTimeVector, DateVector, Decimal128Vector,
-    DurationMicrosecondVector, DurationMillisecondVector, DurationNanosecondVector,
-    DurationSecondVector, IntervalDayTimeVector, IntervalMonthDayNanoVector,
-    IntervalYearMonthVector, ListVector, PrimitiveVector, StringVector, TimeMicrosecondVector,
-    TimeMillisecondVector, TimeNanosecondVector, TimeSecondVector, TimestampMicrosecondVector,
-    TimestampMillisecondVector, TimestampNanosecondVector, TimestampSecondVector, Vector,
+    BinaryVector, BooleanVector, DateVector, Decimal128Vector, DurationMicrosecondVector,
+    DurationMillisecondVector, DurationNanosecondVector, DurationSecondVector,
+    IntervalDayTimeVector, IntervalMonthDayNanoVector, IntervalYearMonthVector, ListVector,
+    PrimitiveVector, StringVector, TimeMicrosecondVector, TimeMillisecondVector,
+    TimeNanosecondVector, TimeSecondVector, TimestampMicrosecondVector, TimestampMillisecondVector,
+    TimestampNanosecondVector, TimestampSecondVector, Vector,
 };
 use crate::with_match_primitive_type_id;

@@ -83,7 +83,6 @@ fn equal(lhs: &dyn Vector, rhs: &dyn Vector) -> bool {
        Binary(_) | Json(_) | Vector(_) => is_vector_eq!(BinaryVector, lhs, rhs),
        String(_) => is_vector_eq!(StringVector, lhs, rhs),
        Date(_) => is_vector_eq!(DateVector, lhs, rhs),
-        DateTime(_) => is_vector_eq!(DateTimeVector, lhs, rhs),
        Timestamp(t) => match t {
            TimestampType::Second(_) => {
                is_vector_eq!(TimestampSecondVector, lhs, rhs)
@@ -195,7 +194,6 @@ mod tests {
        )));
        assert_vector_ref_eq(Arc::new(BooleanVector::from(vec![true, false])));
        assert_vector_ref_eq(Arc::new(DateVector::from(vec![Some(100), Some(120)])));
-        assert_vector_ref_eq(Arc::new(DateTimeVector::from(vec![Some(100), Some(120)])));
        assert_vector_ref_eq(Arc::new(TimestampSecondVector::from_values([100, 120])));
        assert_vector_ref_eq(Arc::new(TimestampMillisecondVector::from_values([
            100, 120,
--- a/src/datatypes/src/vectors/helper.rs
+++ b/src/datatypes/src/vectors/helper.rs
@@ -31,7 +31,7 @@ use crate::prelude::DataType;
 use crate::scalars::{Scalar, ScalarVectorBuilder};
 use crate::value::{ListValue, ListValueRef, Value};
 use crate::vectors::{
-    BinaryVector, BooleanVector, ConstantVector, DateTimeVector, DateVector, Decimal128Vector,
+    BinaryVector, BooleanVector, ConstantVector, DateVector, Decimal128Vector,
    DurationMicrosecondVector, DurationMillisecondVector, DurationNanosecondVector,
    DurationSecondVector, Float32Vector, Float64Vector, Int16Vector, Int32Vector, Int64Vector,
    Int8Vector, IntervalDayTimeVector, IntervalMonthDayNanoVector, IntervalYearMonthVector,
@@ -179,9 +179,6 @@ impl Helper {
            ScalarValue::Date32(v) => {
                ConstantVector::new(Arc::new(DateVector::from(vec![v])), length)
            }
-            ScalarValue::Date64(v) => {
-                ConstantVector::new(Arc::new(DateTimeVector::from(vec![v])), length)
-            }
            ScalarValue::TimestampSecond(v, _) => {
                // Timezone is unimplemented now.
                ConstantVector::new(Arc::new(TimestampSecondVector::from(vec![v])), length)
@@ -244,7 +241,8 @@ impl Helper {
            | ScalarValue::Float16(_)
            | ScalarValue::Utf8View(_)
            | ScalarValue::BinaryView(_)
-            | ScalarValue::Map(_) => {
+            | ScalarValue::Map(_)
+            | ScalarValue::Date64(_) => {
                return error::ConversionSnafu {
                    from: format!("Unsupported scalar value: {value}"),
                }
@@ -286,7 +284,6 @@ impl Helper {
                Arc::new(StringVector::try_from_arrow_array(array)?)
            }
            ArrowDataType::Date32 => Arc::new(DateVector::try_from_arrow_array(array)?),
-            ArrowDataType::Date64 => Arc::new(DateTimeVector::try_from_arrow_array(array)?),
            ArrowDataType::List(_) => Arc::new(ListVector::try_from_arrow_array(array)?),
            ArrowDataType::Timestamp(unit, _) => match unit {
                TimeUnit::Second => Arc::new(TimestampSecondVector::try_from_arrow_array(array)?),
@@ -362,7 +359,8 @@ impl Helper {
            | ArrowDataType::BinaryView
            | ArrowDataType::Utf8View
            | ArrowDataType::ListView(_)
-            | ArrowDataType::LargeListView(_) => {
+            | ArrowDataType::LargeListView(_)
+            | ArrowDataType::Date64 => {
                return error::UnsupportedArrowTypeSnafu {
                    arrow_type: array.as_ref().data_type().clone(),
                }
@@ -411,9 +409,9 @@ impl Helper {
 #[cfg(test)]
 mod tests {
    use arrow::array::{
-        ArrayRef, BooleanArray, Date32Array, Date64Array, Float32Array, Float64Array, Int16Array,
-        Int32Array, Int64Array, Int8Array, LargeBinaryArray, ListArray, NullArray,
-        Time32MillisecondArray, Time32SecondArray, Time64MicrosecondArray, Time64NanosecondArray,
+        ArrayRef, BooleanArray, Date32Array, Float32Array, Float64Array, Int16Array, Int32Array,
+        Int64Array, Int8Array, LargeBinaryArray, ListArray, NullArray, Time32MillisecondArray,
+        Time32SecondArray, Time64MicrosecondArray, Time64NanosecondArray,
        TimestampMicrosecondArray, TimestampMillisecondArray, TimestampNanosecondArray,
        TimestampSecondArray, UInt16Array, UInt32Array, UInt64Array, UInt8Array,
    };
@@ -424,7 +422,7 @@ mod tests {
    use common_decimal::Decimal128;
    use common_time::time::Time;
    use common_time::timestamp::TimeUnit;
-    use common_time::{Date, DateTime, Duration};
+    use common_time::{Date, Duration};

    use super::*;
    use crate::value::Value;
@@ -466,16 +464,6 @@ mod tests {
        }
    }

-    #[test]
-    fn test_try_from_scalar_datetime_value() {
-        let vector = Helper::try_from_scalar_value(ScalarValue::Date64(Some(42)), 3).unwrap();
-        assert_eq!(ConcreteDataType::datetime_datatype(), vector.data_type());
-        assert_eq!(3, vector.len());
-        for i in 0..vector.len() {
-            assert_eq!(Value::DateTime(DateTime::new(42)), vector.get(i));
-        }
-    }
-
    #[test]
    fn test_try_from_scalar_duration_value() {
        let vector =
@@ -606,7 +594,6 @@ mod tests {
        check_try_into_vector(Float64Array::from(vec![1.0, 2.0, 3.0]));
        check_try_into_vector(StringArray::from(vec!["hello", "world"]));
        check_try_into_vector(Date32Array::from(vec![1, 2, 3]));
-        check_try_into_vector(Date64Array::from(vec![1, 2, 3]));
        let data = vec![None, Some(vec![Some(6), Some(7)])];
        let list_array = ListArray::from_iter_primitive::<Int32Type, _, _>(data);
        check_try_into_vector(list_array);
@@ -734,7 +721,6 @@ mod tests {
        check_into_and_from(Float64Array::from(vec![1.0, 2.0, 3.0]));
        check_into_and_from(StringArray::from(vec!["hello", "world"]));
        check_into_and_from(Date32Array::from(vec![1, 2, 3]));
-        check_into_and_from(Date64Array::from(vec![1, 2, 3]));

        check_into_and_from(TimestampSecondArray::from(vec![1, 2, 3]));
        check_into_and_from(TimestampMillisecondArray::from(vec![1, 2, 3]));
--- a/src/datatypes/src/vectors/operations/filter.rs
+++ b/src/datatypes/src/vectors/operations/filter.rs
@@ -32,7 +32,7 @@ pub(crate) use filter_non_constant;
 mod tests {
    use std::sync::Arc;

-    use common_time::{Date, DateTime};
+    use common_time::Date;

    use crate::scalars::ScalarVector;
    use crate::timestamp::{
@@ -127,8 +127,6 @@ mod tests {
    #[test]
    fn test_filter_date_like() {
        impl_filter_date_like_test!(DateVector, Date, new);
-        impl_filter_date_like_test!(DateTimeVector, DateTime, new);
-
        impl_filter_date_like_test!(TimestampSecondVector, TimestampSecond, from_native);
        impl_filter_date_like_test!(
            TimestampMillisecondVector,
--- a/src/datatypes/src/vectors/operations/find_unique.rs
+++ b/src/datatypes/src/vectors/operations/find_unique.rs
@@ -105,7 +105,7 @@ pub(crate) fn find_unique_constant(
 mod tests {
    use std::sync::Arc;

-    use common_time::{Date, DateTime};
+    use common_time::Date;

    use super::*;
    use crate::timestamp::*;
@@ -358,7 +358,6 @@ mod tests {
    #[test]
    fn test_find_unique_date_like() {
        impl_find_unique_date_like_test!(DateVector, Date, new);
-        impl_find_unique_date_like_test!(DateTimeVector, DateTime, new);
        impl_find_unique_date_like_test!(TimestampSecondVector, TimestampSecond, from);
        impl_find_unique_date_like_test!(TimestampMillisecondVector, TimestampMillisecond, from);
        impl_find_unique_date_like_test!(TimestampMicrosecondVector, TimestampMicrosecond, from);
--- a/src/datatypes/src/vectors/operations/replicate.rs
+++ b/src/datatypes/src/vectors/operations/replicate.rs
@@ -41,7 +41,7 @@ mod tests {
    use std::sync::Arc;

    use common_time::timestamp::TimeUnit;
-    use common_time::{Date, DateTime, Timestamp};
+    use common_time::{Date, Timestamp};
    use paste::paste;

    use super::*;
@@ -161,8 +161,6 @@ mod tests {
    #[test]
    fn test_replicate_date_like() {
        impl_replicate_date_like_test!(DateVector, Date, new);
-        impl_replicate_date_like_test!(DateTimeVector, DateTime, new);
-
        impl_replicate_timestamp_test!(Second);
        impl_replicate_timestamp_test!(Millisecond);
        impl_replicate_timestamp_test!(Microsecond);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Weny Xu	60852af5f8	chore: bump version to 0.13.2 (#5837 ) * fix: mysql prepare bool value (#5732) * fix: mysql prepare limit&offset param (#5734) * fix: prepare limit&offset param * test: sqlness * chore: per review * chore: per review * fix: wrap table name with `` (#5748) * fix: wrap table name with quotes * fix: minor fix * fix: handle nullable default value (#5747) * fix: handle nullable default value * chore: update sqlness * fix: properly give placeholder types (#5760) * fix: properly give placeholder types * chore: update sqlness * fix: support __name__ matcher in label values (#5773) * fix: typo variadic (#5800) Signed-off-by: Ruihang Xia <waynestxia@gmail.com> * fix: close issue #3902 since upstream fixed (#5801) Signed-off-by: yihong0618 <zouzou0208@gmail.com> * fix: correct error status code (#5802) * fix: interval cast expression can't work in range query, #5805 (#5813) * fix: interval cast expression can't work in range query, #5805 * fix: nested cast * test: make vector test stable * feat: introduce poison mechanism for procedure (#5822) * feat: introduce poison for procedure * tests: add unit tests * refactor: minor refactor * fix: unit tests * chore: fix unit tests * chore: apply suggestions from CR * chore: apply suggestions from CR * chore: update comments * chore: introduce `ProcedureStatus::Poisoned` * chore: upgrade greptime-proto to `2be0f` * chore: apply suggestions from CR * fix: throw errors instead of ignoring (#5792) * fix: throw errors instead of ignoring * fix: fix unit tests * refactor: remove schema version check * fix: fix clippy * chore: remove unused error * refactor: remove schema version check * feat: handle mutliple results * feat: introduce consistency guard * fix: release consistency guard on datanode operation completion * test: add tests * chore: remove schema version * refactor: rename * test: add more tests * chore: print all error * tests: query table after alteration * log ignored request * refine fuzz test * chore: fix clippy and log mailbox message * chore: close prepared statement after execution * chore: add comment * chore: remove log * chore: rename to `ConsistencyPoison` * chore: remove unused error * fix: fix unit tests * chore: apply suggestions from CR --------- Signed-off-by: Ruihang Xia <waynestxia@gmail.com> Signed-off-by: yihong0618 <zouzou0208@gmail.com> Co-authored-by: discord9 <55937128+discord9@users.noreply.github.com> Co-authored-by: Yohan Wal <profsyb@gmail.com> Co-authored-by: Yingwen <realevenyag@gmail.com> Co-authored-by: Ruihang Xia <waynestxia@gmail.com> Co-authored-by: yihong <zouzou0208@gmail.com> Co-authored-by: dennis zhuang <killme2008@gmail.com>	2025-04-08 14:16:40 +08:00
shuiyisong	557e850d87	chore: use `Bytes` instead of string in bulk ingestion (#5717 ) chore: use bytes instead of string in bulk log ingestion	2025-03-18 04:59:02 +08:00
Ruihang Xia	32fd850c20	perf: support in list in simple filter (#5709 ) * feat: support in list in simple filter Signed-off-by: Ruihang Xia <waynestxia@gmail.com> * fix clippy Signed-off-by: Ruihang Xia <waynestxia@gmail.com> --------- Signed-off-by: Ruihang Xia <waynestxia@gmail.com>	2025-03-14 01:08:29 +00:00
shuiyisong	2bfdae4f8f	feat: add simple extract processor (#5688 ) * feat: add simple extract processor * chore: add test * chore: add license header * chore: minor update	2025-03-13 09:19:58 +00:00
shuiyisong	fcb898e9a4	chore: support `inverted` index in pipeline (#5700 ) chore: rebase main	2025-03-13 08:30:29 +00:00
Ning Sun	8fa2fdfc42	feat: make empty parent_span_id null for v1 (#5690 )	2025-03-13 07:48:15 +00:00
shuiyisong	4dc1a1d60f	chore: support `tag` in transform (#5701 ) chore: support tag in transform to specify tag	2025-03-13 07:27:12 +00:00
Lei, HUANG	e375a18011	fix: conversion from TableMeta to TableMetaBuilder (#5693 ) * refactor: use proc macro to generate conversion between TableMeta and TableMetaBuilder * chore: format * fix/partition-key-index: ### Update `TableMeta` and Add Partition and Alter Table Tests - `metadata.rs`: Modified `new_meta_builder` method in `TableMeta` to manually remove `value_indices` by setting it to `None` in the `TableMetaBuilder`. - `partition_and_alter.result` & `partition_and_alter.sql`: Added new test cases for creating, inserting, selecting, altering, and dropping a partitioned table `molestiAe`. These tests verify partitioning on the `sImiLiQUE` column and altering the table with a TTL setting. fix/partition-key-index: ### Remove Obsolete TODO Comment in `metadata.rs` - Removed an outdated TODO comment regarding the `new_meta_builder` function in `src/table/src/metadata.rs`. chore: check struct name in derive_meta_builder refactor: Simplify TableMeta struct name check in macro refactor: Improve ToMetaBuilder derive macro validation and error handling refactor: Enforce ToMetaBuilder macro for table::metadata::TableMeta struct * fix/partition-key-index: Update `partition_and_alter.sql` to modify TTL setting - Modified the TTL setting for the `molestiAe` table to '1d' in `partition_and_alter.sql`. * fix: sqlness * fix/partition-key-index: ### Update `TableMeta` and Test File Structure - Enhancement: Added a note in `metadata.rs` to always use `new_meta_builder` for creating `TableMetaBuilder`. - Refactor: Renamed test result and SQL files for better organization: - `partition_and_alter.result` to `alter/partition_and_alter.result` - `partition_and_alter.sql` to `alter/partition_and_alter.sql` * refactor: Simplify `derive_meta_builder` by initializing fields with `Default::default()` * fix/partition-key-index: ### Commit Summary - Refactor `TableMetaBuilder` Initialization: - Replaced `TableMetaBuilder::default()` with `TableMetaBuilder::empty()` across multiple files for initializing `TableMetaBuilder` instances. - Affected files include: - `src/catalog/src/system_schema.rs` - `src/common/meta/src/key/test_utils.rs` - `src/operator/src/req_convert/insert/fill_impure_default.rs` - `src/query/src/log_query/planner.rs` - `src/query/src/promql/planner.rs` - `src/query/src/range_select/plan_rewrite.rs` - `src/query/src/sql/show_create_table.rs` - `src/table/src/test_util/memtable.rs` - `src/table/src/test_util/table_info.rs` - Enhance `TableMetaBuilder`: - Added `custom_constructor` to `TableMeta` and implemented an `empty` method for `TableMetaBuilder`. - Modified `TableMetaBuilder` to include a `new_external_table` method with default values. - Updated `src/table/src/metadata.rs` to reflect these changes. - Add Testing Feature: - Introduced a conditional compilation for `test_util` in `src/table/src/lib.rs` to include testing utilities when the `testing` feature is enabled. - Update `Cargo.toml`: - Enabled the `testing` feature for the `table` module in `src/common/meta/Cargo.toml`. - Modify `NumbersTable` Initialization: - Replaced `TableMetaBuilder` with direct `TableMeta` struct initialization in `src/table/src/table/numbers.rs`. - Test Result Update: - Updated test results in `tests/cases/standalone/common/alter/partition_and_alter.result` to reflect changes in table meta handling. * fix: rename default to empty * docs: add doc for TableMetaBuilder::empty * chore: Update src/table/src/metadata.rs --------- Co-authored-by: Yingwen <realevenyag@gmail.com>	2025-03-13 06:30:16 +00:00
shuiyisong	e0ff701e51	chore: support `application/x-ndjson` for log ingest (#5697 ) chore: support ndjson content type	2025-03-13 04:29:22 +00:00
Yingwen	25645a3303	feat: expose virtual_host_style config for s3 storage (#5696 ) * feat: expose enable_virtual_host_style for s3 storage * docs: update examples * test: fix config test	2025-03-12 13:46:56 +00:00
Ruihang Xia	b32ea7d84c	feat: add Docker image tag information to step summary in dev-build workflow (#5692 ) Signed-off-by: Ruihang Xia <waynestxia@gmail.com>	2025-03-12 13:45:19 +00:00
discord9	f164f6eaf3	fix: FlowInfoValue's compatibility (#5695 )	2025-03-12 09:02:48 +00:00
Yohan Wal	af1920defc	feat: add mysql kvbackend (#5528 ) * feat: add mysql kvbackend txn support * chore: error handling * chore: follow review comments * chore: follow review comments * chore: follow review comments * revert: mysql QAQ * revert: revert changes to sqls This reverts commit `cf98c50dd9`. * chore: add comments	2025-03-12 06:52:56 +00:00
Lei, HUANG	7c97fae522	chore: check region wal provider on startup to avoid inconsistence (#5687 )	2025-03-11 17:51:18 +00:00
AntiTopQuark	b8070adc3a	feat: enhancement information_schema.flows (#5623 ) * feat: enhancement information_schema.flows * feat: enhancement information_schema.flows * u * u * u * u * u * u * u * u * u * update * update * update * delete unused code * u * u * Update src/flow/src/adapter/worker.rs Co-authored-by: dennis zhuang <killme2008@gmail.com> * Update src/common/meta/src/key/flow/flow_state.rs Co-authored-by: dennis zhuang <killme2008@gmail.com> * Update src/common/meta/src/key/flow/flow_info.rs Co-authored-by: dennis zhuang <killme2008@gmail.com> * Update src/common/meta/src/key/flow/flow_state.rs Co-authored-by: dennis zhuang <killme2008@gmail.com> * Update src/common/meta/src/key/flow/flow_info.rs Co-authored-by: dennis zhuang <killme2008@gmail.com> * u * u * u * u * u * u * chore: fix sqlness * chore: update proto * fix: remove date time * fix: update result of information_schema test --------- Co-authored-by: dennis zhuang <killme2008@gmail.com> Co-authored-by: discord9 <discord9@163.com>	2025-03-11 15:08:10 +00:00
yihong	11bfb17328	feat: support export command export data to s3 (#5585 ) * feat: s3 first step Signed-off-by: yihong0618 <zouzou0208@gmail.com> * fix: finish s3 export Signed-off-by: yihong0618 <zouzou0208@gmail.com> * fix: drop useless comment Signed-off-by: yihong0618 <zouzou0208@gmail.com> * fix: forget to create_database and copy_from Signed-off-by: yihong0618 <zouzou0208@gmail.com> * fix: address comment use opendal Fs Signed-off-by: yihong0618 <zouzou0208@gmail.com> * refactor: make the export mess code clean Signed-off-by: yihong0618 <zouzou0208@gmail.com> --------- Signed-off-by: yihong0618 <zouzou0208@gmail.com>	2025-03-11 08:56:59 +00:00
jeremyhi	1d87bd2d43	feat: alter region follower (#5676 ) * feat: add region follower manager * feat: add region procudure * refactor: make add, remove follower procedure look nice * feat: add region follower procedure * chore: undo some chane, possibly made by AI * feat: on prepare cheking * feat: on update metadata * feat: on broadcast * chore: unit test * feat: add remove follower operation * feat: add or remove region follower procedure * chore: ut * chore: rename * chore: by comment * chore: by comment --------- Co-authored-by: jeremy <jeremy@greptime.local>	2025-03-11 08:44:50 +00:00
jeremyhi	ababeaf538	chore: make memorykv write happily (#5686 ) chore: make memorykv write happly	2025-03-11 07:37:14 +00:00
Lin Yihai	2cbf51d0be	refactor!: Remove `Value::DateTime` and `ValueRef::DateTime`. (#5616 ) * refactor: Remove Value::DateTime and ValueRef::DateTime * fix: don't panic if arrow cast field. * fix: map `ColumnDataType::Datetime` to `ConcreteDataType::timestamp_microsecond_datatype` * fix: Map `ValueData::DatetimeValue` correctly. * refactor: Replace `datetime` with `timestamp_micro_second`	2025-03-11 07:03:27 +00:00
Yingwen	3059b04b19	feat: add a gauge for download tasks (#5681 )	2025-03-11 06:55:13 +00:00
Yingwen	352b197be4	feat: add hint for logical region in RegionScanner (#5684 ) * feat: add a flag to check logical region * feat: sets logical region hint in metric engine * refactor: rename to logical_region	2025-03-11 06:34:39 +00:00
Ning Sun	d0254f9705	feat: update promql-parser to 0.5 for duration literal (#5682 )	2025-03-11 06:27:36 +00:00
Ning Sun	8a86903c73	feat: add description for each grafana panel (#5673 ) * feat: add description for each grafana panel * Apply suggestions from code review Co-authored-by: Yingwen <realevenyag@gmail.com> * fix: unit of write stall * feat: add jq script to summary the grafana dashboard * fix: update description * ci: add ci step to valid grafana and send summary as comment * ci: update check * ci: update ci --------- Co-authored-by: Yingwen <realevenyag@gmail.com>	2025-03-11 06:16:49 +00:00
Weny Xu	0bd322a078	perf(prom): optimize label values query (#5653 ) perf: optimize label values query	2025-03-10 13:20:47 +00:00
discord9	3811e3f632	feat: also get index file&expose mito in metrics (#5680 ) * feat: download index file too * feat: expose mito in metrics * chore: fmt	2025-03-10 13:07:08 +00:00
localhost	c14aa176b5	chore: impl ref and ref_mut for json like (#5679 ) * chore: impl ref and ref_mut for json like * chore: add code source	2025-03-10 10:43:15 +00:00
Lei, HUANG	a922dcd9df	refactor(mito): move wal sync task to background (#5677 ) chore/move-wal-sync-to-bg: ### Refactor Log Store Task Management - Error Handling Enhancements: Updated error handling for task management in `error.rs` by renaming `StartGcTask` and `StopGcTask` to `StartWalTask` and `StopWalTask`, respectively, and added a `name` field for more descriptive error messages. - Task Management Improvements: Introduced `SyncWalTaskFunction` in `log_store.rs` to handle periodic synchronization of WAL tasks, replacing the previous atomic-based sync logic. - Backend Adjustments: Modified `backend.rs` to use the new `StartWalTaskSnafu` for starting tasks, ensuring consistency with the updated error handling approach.	2025-03-10 08:22:35 +00:00
dennis zhuang	530ff53422	feat(promql): supports quantile and count_values (#5652 ) * feat(promql): supports quantile * fix: merge_batch * chore: sqlness test * test: unit tests * feat: implements count_values * fix: typo * refactor: planner * chore: apply review suggestions --------- Co-authored-by: Yingwen <realevenyag@gmail.com>	2025-03-10 06:41:40 +00:00
Ruihang Xia	73ca39f37e	feat: time series distribution in scanner (#5675 ) * define distribution Signed-off-by: Ruihang Xia <waynestxia@gmail.com> * feat: SeqScan support per series distribution * probe distribution Signed-off-by: Ruihang Xia <waynestxia@gmail.com> * reverse sort order Signed-off-by: Ruihang Xia <waynestxia@gmail.com> * more strict check Signed-off-by: Ruihang Xia <waynestxia@gmail.com> * fix clippy Signed-off-by: Ruihang Xia <waynestxia@gmail.com> * change null's ordering Signed-off-by: Ruihang Xia <waynestxia@gmail.com> --------- Signed-off-by: Ruihang Xia <waynestxia@gmail.com> Co-authored-by: evenyag <realevenyag@gmail.com>	2025-03-10 05:43:17 +00:00
Yingwen	0acc6b0354	fix: correct stalled count (#5678 )	2025-03-10 04:25:38 +00:00
Zhenchi	face361fcb	feat: introduce roaring bitmap to optimize sparse value scenarios (#5603 ) * feat: introduce roaring bitmap to optimize sparse value scenarios Signed-off-by: Zhenchi <zhongzc_arch@outlook.com> * fix taplo Signed-off-by: Zhenchi <zhongzc_arch@outlook.com> * address comments Signed-off-by: Zhenchi <zhongzc_arch@outlook.com> * polish Signed-off-by: Zhenchi <zhongzc_arch@outlook.com> * address comments Signed-off-by: Zhenchi <zhongzc_arch@outlook.com> --------- Signed-off-by: Zhenchi <zhongzc_arch@outlook.com>	2025-03-10 04:24:08 +00:00