diff --git a/.github/workflows/develop.yml b/.github/workflows/develop.yml
index 37edc39242..8dde424c8e 100644
--- a/.github/workflows/develop.yml
+++ b/.github/workflows/develop.yml
@@ -632,7 +632,7 @@ jobs:
       - name: Unzip binaries
         run: tar -xvf ./bins.tar.gz
       - name: Run sqlness
-        run: RUST_BACKTRACE=1 ./bins/sqlness-runner ${{ matrix.mode.opts }} -c ./tests/cases --bins-dir ./bins --preserve-state
+        run: RUST_BACKTRACE=1 ./bins/sqlness-runner bare ${{ matrix.mode.opts }} -c ./tests/cases --bins-dir ./bins --preserve-state
       - name: Upload sqlness logs
         if: failure()
         uses: actions/upload-artifact@v4
diff --git a/Cargo.lock b/Cargo.lock
index c0f9ade4c6..6e88493e92 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5325,7 +5325,7 @@ dependencies = [
 [[package]]
 name = "greptime-proto"
 version = "0.1.0"
-source = "git+https://github.com/GreptimeTeam/greptime-proto.git?rev=3e821d0d405e6733690a4e4352812ba2ff780a3e#3e821d0d405e6733690a4e4352812ba2ff780a3e"
+source = "git+https://github.com/GreptimeTeam/greptime-proto.git?rev=d75496d5d09dedcd0edcade57ccf0a522f4393ae#d75496d5d09dedcd0edcade57ccf0a522f4393ae"
 dependencies = [
  "prost 0.13.5",
  "prost-types 0.13.5",
@@ -5825,9 +5825,9 @@ dependencies = [
 
 [[package]]
 name = "hyper-util"
-version = "0.1.14"
+version = "0.1.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc2fdfdbff08affe55bb779f33b053aa1fe5dd5b54c257343c17edfa55711bdb"
+checksum = "3c6995591a8f1380fcb4ba966a252a4b29188d51d2b89e3a252f5305be65aea8"
 dependencies = [
  "base64 0.22.1",
  "bytes",
@@ -5841,7 +5841,7 @@ dependencies = [
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.5.10",
+ "socket2 0.6.0",
  "tokio",
  "tower-service",
  "tracing",
diff --git a/Cargo.toml b/Cargo.toml
index ea77ea92f5..1185c9b2d5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -147,7 +147,7 @@ etcd-client = { git = "https://github.com/GreptimeTeam/etcd-client", rev = "f62d
 fst = "0.4.7"
 futures = "0.3"
 futures-util = "0.3"
-greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "3e821d0d405e6733690a4e4352812ba2ff780a3e" }
+greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "d75496d5d09dedcd0edcade57ccf0a522f4393ae" }
 hex = "0.4"
 http = "1"
 humantime = "2.1"
diff --git a/Makefile b/Makefile
index 04e022d13e..d94426554e 100644
--- a/Makefile
+++ b/Makefile
@@ -169,7 +169,7 @@ nextest: ## Install nextest tools.
 
 .PHONY: sqlness-test
 sqlness-test: ## Run sqlness test.
-	cargo sqlness ${SQLNESS_OPTS}
+	cargo sqlness bare ${SQLNESS_OPTS}
 
 RUNS ?= 1
 FUZZ_TARGET ?= fuzz_alter_table
diff --git a/flake.lock b/flake.lock
index 43568eb7e5..e410fe9785 100644
--- a/flake.lock
+++ b/flake.lock
@@ -8,11 +8,11 @@
         "rust-analyzer-src": "rust-analyzer-src"
       },
       "locked": {
-        "lastModified": 1745735608,
-        "narHash": "sha256-L0jzm815XBFfF2wCFmR+M1CF+beIEFj6SxlqVKF59Ec=",
+        "lastModified": 1760078406,
+        "narHash": "sha256-JeJK0ZA845PtkCHkfo4KjeI1mYrsr2s3cxBYKhF4BoE=",
         "owner": "nix-community",
         "repo": "fenix",
-        "rev": "c39a78eba6ed2a022cc3218db90d485077101496",
+        "rev": "351277c60d104944122ee389cdf581c5ce2c6732",
         "type": "github"
       },
       "original": {
@@ -41,11 +41,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1748162331,
-        "narHash": "sha256-rqc2RKYTxP3tbjA+PB3VMRQNnjesrT0pEofXQTrMsS8=",
+        "lastModified": 1759994382,
+        "narHash": "sha256-wSK+3UkalDZRVHGCRikZ//CyZUJWDJkBDTQX1+G77Ow=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "7c43f080a7f28b2774f3b3f43234ca11661bf334",
+        "rev": "5da4a26309e796daa7ffca72df93dbe53b8164c7",
         "type": "github"
       },
       "original": {
@@ -65,11 +65,11 @@
     "rust-analyzer-src": {
       "flake": false,
       "locked": {
-        "lastModified": 1745694049,
-        "narHash": "sha256-fxvRYH/tS7hGQeg9zCVh5RBcSWT+JGJet7RA8Ss+rC0=",
+        "lastModified": 1760014945,
+        "narHash": "sha256-ySdl7F9+oeWNHVrg3QL/brazqmJvYFEdpGnF3pyoDH8=",
         "owner": "rust-lang",
         "repo": "rust-analyzer",
-        "rev": "d8887c0758bbd2d5f752d5bd405d4491e90e7ed6",
+        "rev": "90d2e1ce4dfe7dc49250a8b88a0f08ffdb9cb23f",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index ebbe011626..555e4c714e 100644
--- a/flake.nix
+++ b/flake.nix
@@ -19,7 +19,7 @@
         lib = nixpkgs.lib;
         rustToolchain = fenix.packages.${system}.fromToolchainName {
           name = (lib.importTOML ./rust-toolchain.toml).toolchain.channel;
-          sha256 = "sha256-tJJr8oqX3YD+ohhPK7jlt/7kvKBnBqJVjYtoFr520d4=";
+          sha256 = "sha256-GCGEXGZeJySLND0KU5TdtTrqFV76TF3UdvAHSUegSsk=";
         };
       in
       {
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index e34fe14525..58b88a3894 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,2 +1,2 @@
 [toolchain]
-channel = "nightly-2025-05-19"
+channel = "nightly-2025-10-01"
diff --git a/src/api/src/helper.rs b/src/api/src/helper.rs
index 88b34381f0..a091d99799 100644
--- a/src/api/src/helper.rs
+++ b/src/api/src/helper.rs
@@ -15,7 +15,6 @@
 use std::collections::HashSet;
 use std::sync::Arc;
 
-use common_base::BitVec;
 use common_decimal::Decimal128;
 use common_decimal::decimal128::{DECIMAL128_DEFAULT_SCALE, DECIMAL128_MAX_PRECISION};
 use common_time::time::Time;
@@ -24,9 +23,12 @@ use common_time::{Date, IntervalDayTime, IntervalMonthDayNano, IntervalYearMonth
 use datatypes::prelude::{ConcreteDataType, ValueRef};
 use datatypes::scalars::ScalarVector;
 use datatypes::types::{
-    Int8Type, Int16Type, IntervalType, TimeType, TimestampType, UInt8Type, UInt16Type,
+    Int8Type, Int16Type, IntervalType, StructField, StructType, TimeType, TimestampType, UInt8Type,
+    UInt16Type,
+};
+use datatypes::value::{
+    ListValue, ListValueRef, OrderedF32, OrderedF64, StructValue, StructValueRef, Value,
 };
-use datatypes::value::{OrderedF32, OrderedF64, Value};
 use datatypes::vectors::{
     BinaryVector, BooleanVector, DateVector, Decimal128Vector, Float32Vector, Float64Vector,
     Int32Vector, Int64Vector, IntervalDayTimeVector, IntervalMonthDayNanoVector,
@@ -42,14 +44,14 @@ use greptime_proto::v1::query_request::Query;
 use greptime_proto::v1::value::ValueData;
 use greptime_proto::v1::{
     self, ColumnDataTypeExtension, DdlRequest, DecimalTypeExtension, JsonTypeExtension,
-    QueryRequest, Row, SemanticType, VectorTypeExtension,
+    ListTypeExtension, QueryRequest, Row, SemanticType, StructTypeExtension, VectorTypeExtension,
 };
 use paste::paste;
 use snafu::prelude::*;
 
 use crate::error::{self, InconsistentTimeUnitSnafu, InvalidTimeUnitSnafu, Result};
 use crate::v1::column::Values;
-use crate::v1::{Column, ColumnDataType, Value as GrpcValue};
+use crate::v1::{ColumnDataType, Value as GrpcValue};
 
 /// ColumnDataTypeWrapper is a wrapper of ColumnDataType and ColumnDataTypeExtension.
 /// It could be used to convert with ConcreteDataType.
@@ -85,7 +87,7 @@ impl ColumnDataTypeWrapper {
 
     /// Get a tuple of ColumnDataType and ColumnDataTypeExtension.
     pub fn to_parts(&self) -> (ColumnDataType, Option<ColumnDataTypeExtension>) {
-        (self.datatype, self.datatype_ext)
+        (self.datatype, self.datatype_ext.clone())
     }
 }
 
@@ -159,6 +161,45 @@ impl From<ColumnDataTypeWrapper> for ConcreteDataType {
                     ConcreteDataType::vector_default_datatype()
                 }
             }
+            ColumnDataType::List => {
+                if let Some(TypeExt::ListType(d)) = datatype_wrapper
+                    .datatype_ext
+                    .as_ref()
+                    .and_then(|datatype_ext| datatype_ext.type_ext.as_ref())
+                {
+                    let item_type = ColumnDataTypeWrapper {
+                        datatype: d.datatype(),
+                        datatype_ext: d.datatype_extension.clone().map(|d| *d),
+                    };
+                    ConcreteDataType::list_datatype(item_type.into())
+                } else {
+                    // invalid state: type extension not found
+                    ConcreteDataType::null_datatype()
+                }
+            }
+            ColumnDataType::Struct => {
+                if let Some(TypeExt::StructType(d)) = datatype_wrapper
+                    .datatype_ext
+                    .as_ref()
+                    .and_then(|datatype_ext| datatype_ext.type_ext.as_ref())
+                {
+                    let fields = d
+                        .fields
+                        .iter()
+                        .map(|f| {
+                            let field_type = ColumnDataTypeWrapper {
+                                datatype: f.datatype(),
+                                datatype_ext: f.datatype_extension.clone(),
+                            };
+                            StructField::new(f.name.clone(), field_type.into(), true)
+                        })
+                        .collect::<Vec<_>>();
+                    ConcreteDataType::struct_datatype(StructType::from(fields))
+                } else {
+                    // invalid state: type extension not found
+                    ConcreteDataType::null_datatype()
+                }
+            }
         }
     }
 }
@@ -249,6 +290,39 @@ impl ColumnDataTypeWrapper {
             }),
         }
     }
+
+    /// Create a list datatype with the given item type.
+    pub fn list_datatype(item_type: ColumnDataTypeWrapper) -> Self {
+        ColumnDataTypeWrapper {
+            datatype: ColumnDataType::List,
+            datatype_ext: Some(ColumnDataTypeExtension {
+                type_ext: Some(TypeExt::ListType(Box::new(ListTypeExtension {
+                    datatype: item_type.datatype() as i32,
+                    datatype_extension: item_type.datatype_ext.map(Box::new),
+                }))),
+            }),
+        }
+    }
+
+    /// Create a struct datatype with the given field tuples (name, datatype).
+    pub fn struct_datatype(fields: Vec<(String, ColumnDataTypeWrapper)>) -> Self {
+        let struct_fields = fields
+            .into_iter()
+            .map(|(name, datatype)| greptime_proto::v1::StructField {
+                name,
+                datatype: datatype.datatype() as i32,
+                datatype_extension: datatype.datatype_ext,
+            })
+            .collect();
+        ColumnDataTypeWrapper {
+            datatype: ColumnDataType::Struct,
+            datatype_ext: Some(ColumnDataTypeExtension {
+                type_ext: Some(TypeExt::StructType(StructTypeExtension {
+                    fields: struct_fields,
+                })),
+            }),
+        }
+    }
 }
 
 impl TryFrom<ConcreteDataType> for ColumnDataTypeWrapper {
@@ -290,9 +364,9 @@ impl TryFrom<ConcreteDataType> for ColumnDataTypeWrapper {
             ConcreteDataType::Decimal128(_) => ColumnDataType::Decimal128,
             ConcreteDataType::Json(_) => ColumnDataType::Json,
             ConcreteDataType::Vector(_) => ColumnDataType::Vector,
+            ConcreteDataType::List(_) => ColumnDataType::List,
+            ConcreteDataType::Struct(_) => ColumnDataType::Struct,
             ConcreteDataType::Null(_)
-            | ConcreteDataType::List(_)
-            | ConcreteDataType::Struct(_)
             | ConcreteDataType::Dictionary(_)
             | ConcreteDataType::Duration(_) => {
                 return error::IntoColumnDataTypeSnafu { from: datatype }.fail();
@@ -321,6 +395,40 @@ impl TryFrom<ConcreteDataType> for ColumnDataTypeWrapper {
                         })),
                     })
             }
+            ColumnDataType::List => {
+                if let Some(list_type) = datatype.as_list() {
+                    let list_item_type =
+                        ColumnDataTypeWrapper::try_from(list_type.item_type().clone())?;
+                    Some(ColumnDataTypeExtension {
+                        type_ext: Some(TypeExt::ListType(Box::new(ListTypeExtension {
+                            datatype: list_item_type.datatype.into(),
+                            datatype_extension: list_item_type.datatype_ext.map(Box::new),
+                        }))),
+                    })
+                } else {
+                    None
+                }
+            }
+            ColumnDataType::Struct => {
+                if let Some(struct_type) = datatype.as_struct() {
+                    let mut fields = Vec::with_capacity(struct_type.fields().len());
+                    for field in struct_type.fields() {
+                        let field_type =
+                            ColumnDataTypeWrapper::try_from(field.data_type().clone())?;
+                        let proto_field = crate::v1::StructField {
+                            name: field.name().to_string(),
+                            datatype: field_type.datatype.into(),
+                            datatype_extension: field_type.datatype_ext,
+                        };
+                        fields.push(proto_field);
+                    }
+                    Some(ColumnDataTypeExtension {
+                        type_ext: Some(TypeExt::StructType(StructTypeExtension { fields })),
+                    })
+                } else {
+                    None
+                }
+            }
             _ => None,
         };
         Ok(Self {
@@ -448,56 +556,17 @@ pub fn values_with_capacity(datatype: ColumnDataType, capacity: usize) -> Values
             binary_values: Vec::with_capacity(capacity),
             ..Default::default()
         },
+        ColumnDataType::List => Values {
+            list_values: Vec::with_capacity(capacity),
+            ..Default::default()
+        },
+        ColumnDataType::Struct => Values {
+            struct_values: Vec::with_capacity(capacity),
+            ..Default::default()
+        },
     }
 }
 
-// The type of vals must be same.
-pub fn push_vals(column: &mut Column, origin_count: usize, vector: VectorRef) {
-    let values = column.values.get_or_insert_with(Values::default);
-    let mut null_mask = BitVec::from_slice(&column.null_mask);
-    let len = vector.len();
-    null_mask.reserve_exact(origin_count + len);
-    null_mask.extend(BitVec::repeat(false, len));
-
-    (0..len).for_each(|idx| match vector.get(idx) {
-        Value::Null => null_mask.set(idx + origin_count, true),
-        Value::Boolean(val) => values.bool_values.push(val),
-        Value::UInt8(val) => values.u8_values.push(val.into()),
-        Value::UInt16(val) => values.u16_values.push(val.into()),
-        Value::UInt32(val) => values.u32_values.push(val),
-        Value::UInt64(val) => values.u64_values.push(val),
-        Value::Int8(val) => values.i8_values.push(val.into()),
-        Value::Int16(val) => values.i16_values.push(val.into()),
-        Value::Int32(val) => values.i32_values.push(val),
-        Value::Int64(val) => values.i64_values.push(val),
-        Value::Float32(val) => values.f32_values.push(*val),
-        Value::Float64(val) => values.f64_values.push(*val),
-        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::Timestamp(val) => match val.unit() {
-            TimeUnit::Second => values.timestamp_second_values.push(val.value()),
-            TimeUnit::Millisecond => values.timestamp_millisecond_values.push(val.value()),
-            TimeUnit::Microsecond => values.timestamp_microsecond_values.push(val.value()),
-            TimeUnit::Nanosecond => values.timestamp_nanosecond_values.push(val.value()),
-        },
-        Value::Time(val) => match val.unit() {
-            TimeUnit::Second => values.time_second_values.push(val.value()),
-            TimeUnit::Millisecond => values.time_millisecond_values.push(val.value()),
-            TimeUnit::Microsecond => values.time_microsecond_values.push(val.value()),
-            TimeUnit::Nanosecond => values.time_nanosecond_values.push(val.value()),
-        },
-        Value::IntervalYearMonth(val) => values.interval_year_month_values.push(val.to_i32()),
-        Value::IntervalDayTime(val) => values.interval_day_time_values.push(val.to_i64()),
-        Value::IntervalMonthDayNano(val) => values
-            .interval_month_day_nano_values
-            .push(convert_month_day_nano_to_pb(val)),
-        Value::Decimal128(val) => values.decimal128_values.push(convert_to_pb_decimal128(val)),
-        Value::List(_) | Value::Duration(_) => unreachable!(),
-    });
-    column.null_mask = null_mask.into_vec();
-}
-
 /// Returns the type name of the [Request].
 pub fn request_type(request: &Request) -> &'static str {
     match request {
@@ -555,7 +624,7 @@ pub fn convert_to_pb_decimal128(v: Decimal128) -> v1::Decimal128 {
 
 pub fn pb_value_to_value_ref<'a>(
     value: &'a v1::Value,
-    datatype_ext: &'a Option<ColumnDataTypeExtension>,
+    datatype_ext: Option<&'a ColumnDataTypeExtension>,
 ) -> ValueRef<'a> {
     let Some(value) = &value.value_data else {
         return ValueRef::Null;
@@ -622,6 +691,77 @@ pub fn pb_value_to_value_ref<'a>(
                 ))
             }
         }
+        ValueData::ListValue(list) => {
+            let list_datatype_ext = datatype_ext
+                .as_ref()
+                .and_then(|ext| {
+                    if let Some(TypeExt::ListType(l)) = &ext.type_ext {
+                        Some(l)
+                    } else {
+                        None
+                    }
+                })
+                .expect("list must contain datatype ext");
+            let item_type = ConcreteDataType::from(ColumnDataTypeWrapper::new(
+                list_datatype_ext.datatype(),
+                list_datatype_ext
+                    .datatype_extension
+                    .as_ref()
+                    .map(|ext| *ext.clone()),
+            ));
+            let items = list
+                .items
+                .iter()
+                .map(|item| {
+                    pb_value_to_value_ref(item, list_datatype_ext.datatype_extension.as_deref())
+                })
+                .collect::<Vec<_>>();
+
+            let list_value = ListValueRef::RefList {
+                val: items,
+                item_datatype: item_type.clone(),
+            };
+            ValueRef::List(list_value)
+        }
+
+        ValueData::StructValue(struct_value) => {
+            let struct_datatype_ext = datatype_ext
+                .as_ref()
+                .and_then(|ext| {
+                    if let Some(TypeExt::StructType(s)) = &ext.type_ext {
+                        Some(s)
+                    } else {
+                        None
+                    }
+                })
+                .expect("struct must contain datatype ext");
+
+            let struct_fields = struct_datatype_ext
+                .fields
+                .iter()
+                .map(|field| {
+                    let field_type = ConcreteDataType::from(ColumnDataTypeWrapper::new(
+                        field.datatype(),
+                        field.datatype_extension.clone(),
+                    ));
+                    let field_name = field.name.clone();
+                    StructField::new(field_name, field_type, true)
+                })
+                .collect::<Vec<_>>();
+
+            let items = struct_value
+                .items
+                .iter()
+                .zip(struct_datatype_ext.fields.iter())
+                .map(|(item, field)| pb_value_to_value_ref(item, field.datatype_extension.as_ref()))
+                .collect::<Vec<ValueRef>>();
+
+            let struct_value_ref = StructValueRef::RefList {
+                val: items,
+                fields: StructType::new(struct_fields),
+            };
+            ValueRef::Struct(struct_value_ref)
+        }
     }
 }
 
@@ -896,8 +1036,8 @@ pub fn is_column_type_value_eq(
 }
 
 /// Convert value into proto's value.
-pub fn to_proto_value(value: Value) -> Option<v1::Value> {
-    let proto_value = match value {
+pub fn to_proto_value(value: Value) -> v1::Value {
+    match value {
         Value::Null => v1::Value { value_data: None },
         Value::Boolean(v) => v1::Value {
             value_data: Some(ValueData::BoolValue(v)),
@@ -983,10 +1123,34 @@ pub fn to_proto_value(value: Value) -> Option<v1::Value> {
         Value::Decimal128(v) => v1::Value {
             value_data: Some(ValueData::Decimal128Value(convert_to_pb_decimal128(v))),
         },
-        Value::List(_) | Value::Duration(_) => return None,
-    };
+        Value::List(list_value) => v1::Value {
+            value_data: Some(ValueData::ListValue(v1::ListValue {
+                items: convert_list_to_pb_values(list_value),
+            })),
+        },
+        Value::Struct(struct_value) => v1::Value {
+            value_data: Some(ValueData::StructValue(v1::StructValue {
+                items: convert_struct_to_pb_values(struct_value),
+            })),
+        },
+        Value::Duration(_) => v1::Value { value_data: None },
+    }
+}
 
-    Some(proto_value)
+fn convert_list_to_pb_values(list_value: ListValue) -> Vec<v1::Value> {
+    list_value
+        .take_items()
+        .into_iter()
+        .map(to_proto_value)
+        .collect()
+}
+
+fn convert_struct_to_pb_values(struct_value: StructValue) -> Vec<v1::Value> {
+    struct_value
+        .take_items()
+        .into_iter()
+        .map(to_proto_value)
+        .collect()
 }
 
 /// Returns the [ColumnDataTypeWrapper] of the value.
@@ -1021,6 +1185,8 @@ pub fn proto_value_type(value: &v1::Value) -> Option<ColumnDataType> {
         ValueData::IntervalDayTimeValue(_) => ColumnDataType::IntervalDayTime,
         ValueData::IntervalMonthDayNanoValue(_) => ColumnDataType::IntervalMonthDayNano,
         ValueData::Decimal128Value(_) => ColumnDataType::Decimal128,
+        ValueData::ListValue(_) => ColumnDataType::List,
+        ValueData::StructValue(_) => ColumnDataType::Struct,
     };
     Some(value_type)
 }
@@ -1075,7 +1241,23 @@ pub fn value_to_grpc_value(value: Value) -> GrpcValue {
                 convert_month_day_nano_to_pb(v),
             )),
             Value::Decimal128(v) => Some(ValueData::Decimal128Value(convert_to_pb_decimal128(v))),
-            Value::List(_) | Value::Duration(_) => unreachable!(),
+            Value::List(list_value) => {
+                let items = list_value
+                    .take_items()
+                    .into_iter()
+                    .map(value_to_grpc_value)
+                    .collect();
+                Some(ValueData::ListValue(v1::ListValue { items }))
+            }
+            Value::Struct(struct_value) => {
+                let items = struct_value
+                    .take_items()
+                    .into_iter()
+                    .map(value_to_grpc_value)
+                    .collect();
+                Some(ValueData::StructValue(v1::StructValue { items }))
+            }
+            Value::Duration(_) => unreachable!(),
         },
     }
 }
@@ -1173,15 +1355,11 @@ mod tests {
         TimeMillisecondType, TimeSecondType, TimestampMillisecondType, TimestampSecondType,
         UInt32Type,
     };
-    use datatypes::vectors::{
-        BooleanVector, IntervalDayTimeVector, IntervalMonthDayNanoVector, IntervalYearMonthVector,
-        TimeMicrosecondVector, TimeMillisecondVector, TimeNanosecondVector, TimeSecondVector,
-        TimestampMicrosecondVector, TimestampMillisecondVector, TimestampNanosecondVector,
-        TimestampSecondVector, Vector,
-    };
+    use datatypes::vectors::BooleanVector;
     use paste::paste;
 
     use super::*;
+    use crate::v1::Column;
 
     #[test]
     fn test_values_with_capacity() {
@@ -1260,6 +1438,14 @@ mod tests {
         let values = values_with_capacity(ColumnDataType::Vector, 2);
         let values = values.binary_values;
         assert_eq!(2, values.capacity());
+
+        let values = values_with_capacity(ColumnDataType::List, 2);
+        let values = values.list_values;
+        assert_eq!(2, values.capacity());
+
+        let values = values_with_capacity(ColumnDataType::Struct, 2);
+        let values = values.struct_values;
+        assert_eq!(2, values.capacity());
     }
 
     #[test]
@@ -1352,6 +1538,37 @@ mod tests {
             ConcreteDataType::vector_datatype(3),
             ColumnDataTypeWrapper::vector_datatype(3).into()
         );
+        assert_eq!(
+            ConcreteDataType::list_datatype(ConcreteDataType::string_datatype()),
+            ColumnDataTypeWrapper::list_datatype(ColumnDataTypeWrapper::string_datatype()).into()
+        );
+        let struct_type = StructType::new(vec![
+            StructField::new("id".to_string(), ConcreteDataType::int64_datatype(), true),
+            StructField::new(
+                "name".to_string(),
+                ConcreteDataType::string_datatype(),
+                true,
+            ),
+            StructField::new("age".to_string(), ConcreteDataType::int32_datatype(), true),
+            StructField::new(
+                "address".to_string(),
+                ConcreteDataType::string_datatype(),
+                true,
+            ),
+        ]);
+        assert_eq!(
+            ConcreteDataType::struct_datatype(struct_type.clone()),
+            ColumnDataTypeWrapper::struct_datatype(vec![
+                ("id".to_string(), ColumnDataTypeWrapper::int64_datatype()),
+                ("name".to_string(), ColumnDataTypeWrapper::string_datatype()),
+                ("age".to_string(), ColumnDataTypeWrapper::int32_datatype()),
+                (
+                    "address".to_string(),
+                    ColumnDataTypeWrapper::string_datatype()
+                )
+            ])
+            .into()
+        );
     }
 
     #[test]
@@ -1455,176 +1672,29 @@ mod tests {
             "Failed to create column datatype from Null(NullType)"
         );
 
-        let result: Result<ColumnDataTypeWrapper> =
-            ConcreteDataType::list_datatype(ConcreteDataType::boolean_datatype()).try_into();
-        assert!(result.is_err());
         assert_eq!(
-            result.unwrap_err().to_string(),
-            "Failed to create column datatype from List(ListType { item_type: Boolean(BooleanType) })"
-        );
-    }
-
-    #[test]
-    fn test_column_put_timestamp_values() {
-        let mut column = Column {
-            column_name: "test".to_string(),
-            semantic_type: 0,
-            values: Some(Values {
-                ..Default::default()
-            }),
-            null_mask: vec![],
-            datatype: 0,
-            ..Default::default()
-        };
-
-        let vector = Arc::new(TimestampNanosecondVector::from_vec(vec![1, 2, 3]));
-        push_vals(&mut column, 3, vector);
-        assert_eq!(
-            vec![1, 2, 3],
-            column.values.as_ref().unwrap().timestamp_nanosecond_values
+            ColumnDataTypeWrapper::list_datatype(ColumnDataTypeWrapper::int16_datatype()),
+            ConcreteDataType::list_datatype(ConcreteDataType::int16_datatype())
+                .try_into()
+                .expect("Failed to create column datatype from List(ListType { item_type: Int16(Int16Type) })")
         );
 
-        let vector = Arc::new(TimestampMillisecondVector::from_vec(vec![4, 5, 6]));
-        push_vals(&mut column, 3, vector);
         assert_eq!(
-            vec![4, 5, 6],
-            column.values.as_ref().unwrap().timestamp_millisecond_values
-        );
-
-        let vector = Arc::new(TimestampMicrosecondVector::from_vec(vec![7, 8, 9]));
-        push_vals(&mut column, 3, vector);
-        assert_eq!(
-            vec![7, 8, 9],
-            column.values.as_ref().unwrap().timestamp_microsecond_values
-        );
-
-        let vector = Arc::new(TimestampSecondVector::from_vec(vec![10, 11, 12]));
-        push_vals(&mut column, 3, vector);
-        assert_eq!(
-            vec![10, 11, 12],
-            column.values.as_ref().unwrap().timestamp_second_values
-        );
-    }
-
-    #[test]
-    fn test_column_put_time_values() {
-        let mut column = Column {
-            column_name: "test".to_string(),
-            semantic_type: 0,
-            values: Some(Values {
-                ..Default::default()
-            }),
-            null_mask: vec![],
-            datatype: 0,
-            ..Default::default()
-        };
-
-        let vector = Arc::new(TimeNanosecondVector::from_vec(vec![1, 2, 3]));
-        push_vals(&mut column, 3, vector);
-        assert_eq!(
-            vec![1, 2, 3],
-            column.values.as_ref().unwrap().time_nanosecond_values
-        );
-
-        let vector = Arc::new(TimeMillisecondVector::from_vec(vec![4, 5, 6]));
-        push_vals(&mut column, 3, vector);
-        assert_eq!(
-            vec![4, 5, 6],
-            column.values.as_ref().unwrap().time_millisecond_values
-        );
-
-        let vector = Arc::new(TimeMicrosecondVector::from_vec(vec![7, 8, 9]));
-        push_vals(&mut column, 3, vector);
-        assert_eq!(
-            vec![7, 8, 9],
-            column.values.as_ref().unwrap().time_microsecond_values
-        );
-
-        let vector = Arc::new(TimeSecondVector::from_vec(vec![10, 11, 12]));
-        push_vals(&mut column, 3, vector);
-        assert_eq!(
-            vec![10, 11, 12],
-            column.values.as_ref().unwrap().time_second_values
-        );
-    }
-
-    #[test]
-    fn test_column_put_interval_values() {
-        let mut column = Column {
-            column_name: "test".to_string(),
-            semantic_type: 0,
-            values: Some(Values {
-                ..Default::default()
-            }),
-            null_mask: vec![],
-            datatype: 0,
-            ..Default::default()
-        };
-
-        let vector = Arc::new(IntervalYearMonthVector::from_vec(vec![1, 2, 3]));
-        push_vals(&mut column, 3, vector);
-        assert_eq!(
-            vec![1, 2, 3],
-            column.values.as_ref().unwrap().interval_year_month_values
-        );
-
-        let vector = Arc::new(IntervalDayTimeVector::from_vec(vec![
-            IntervalDayTime::new(0, 4).into(),
-            IntervalDayTime::new(0, 5).into(),
-            IntervalDayTime::new(0, 6).into(),
-        ]));
-        push_vals(&mut column, 3, vector);
-        assert_eq!(
-            vec![4, 5, 6],
-            column.values.as_ref().unwrap().interval_day_time_values
-        );
-
-        let vector = Arc::new(IntervalMonthDayNanoVector::from_vec(vec![
-            IntervalMonthDayNano::new(0, 0, 7).into(),
-            IntervalMonthDayNano::new(0, 0, 8).into(),
-            IntervalMonthDayNano::new(0, 0, 9).into(),
-        ]));
-        let len = vector.len();
-        push_vals(&mut column, 3, vector);
-        (0..len).for_each(|i| {
-            assert_eq!(
-                7 + i as i64,
-                column
-                    .values
-                    .as_ref()
-                    .unwrap()
-                    .interval_month_day_nano_values
-                    .get(i)
-                    .unwrap()
-                    .nanoseconds
-            );
-        });
-    }
-
-    #[test]
-    fn test_column_put_vector() {
-        use crate::v1::SemanticType;
-        // Some(false), None, Some(true), Some(true)
-        let mut column = Column {
-            column_name: "test".to_string(),
-            semantic_type: SemanticType::Field as i32,
-            values: Some(Values {
-                bool_values: vec![false, true, true],
-                ..Default::default()
-            }),
-            null_mask: vec![2],
-            datatype: ColumnDataType::Boolean as i32,
-            ..Default::default()
-        };
-        let row_count = 4;
-
-        let vector = Arc::new(BooleanVector::from(vec![Some(true), None, Some(false)]));
-        push_vals(&mut column, row_count, vector);
-        // Some(false), None, Some(true), Some(true), Some(true), None, Some(false)
-        let bool_values = column.values.unwrap().bool_values;
-        assert_eq!(vec![false, true, true, true, false], bool_values);
-        let null_mask = column.null_mask;
-        assert_eq!(34, null_mask[0]);
+            ColumnDataTypeWrapper::struct_datatype(vec![
+                ("a".to_string(), ColumnDataTypeWrapper::int64_datatype()),
+                (
+                    "a.a".to_string(),
+                    ColumnDataTypeWrapper::list_datatype(ColumnDataTypeWrapper::string_datatype())
+                )
+            ]),
+            ConcreteDataType::struct_datatype(StructType::new(vec![
+                StructField::new("a".to_string(), ConcreteDataType::int64_datatype(), true),
+                StructField::new(
+                    "a.a".to_string(),
+                    ConcreteDataType::list_datatype(ConcreteDataType::string_datatype()), true
+                )
+            ])).try_into().expect("Failed to create column datatype from Struct(StructType { fields: [StructField { name: \"a\", data_type: Int64(Int64Type) }, StructField { name: \"a.a\", data_type: List(ListType { item_type: String(StringType) }) }] })")
+        )
     }
 
     #[test]
@@ -2000,4 +2070,50 @@ mod tests {
         assert_eq!(pb_decimal.lo, 123);
         assert_eq!(pb_decimal.hi, 0);
     }
+
+    #[test]
+    fn test_list_to_pb_value() {
+        let value = Value::List(ListValue::new(
+            vec![Value::Boolean(true)],
+            ConcreteDataType::boolean_datatype(),
+        ));
+
+        let pb_value = to_proto_value(value);
+
+        match pb_value.value_data.unwrap() {
+            ValueData::ListValue(pb_list_value) => {
+                assert_eq!(pb_list_value.items.len(), 1);
+            }
+            _ => panic!("Unexpected value type"),
+        }
+    }
+
+    #[test]
+    fn test_struct_to_pb_value() {
+        let items = vec![Value::Boolean(true), Value::String("tom".into())];
+
+        let value = Value::Struct(
+            StructValue::try_new(
+                items,
+                StructType::new(vec![
+                    StructField::new(
+                        "a.a".to_string(),
+                        ConcreteDataType::boolean_datatype(),
+                        true,
+                    ),
+                    StructField::new("a.b".to_string(), ConcreteDataType::string_datatype(), true),
+                ]),
+            )
+            .unwrap(),
+        );
+
+        let pb_value = to_proto_value(value);
+
+        match pb_value.value_data.unwrap() {
+            ValueData::StructValue(pb_struct_value) => {
+                assert_eq!(pb_struct_value.items.len(), 2);
+            }
+            _ => panic!("Unexpected value type"),
+        }
+    }
 }
diff --git a/src/api/src/lib.rs b/src/api/src/lib.rs
index 7670f8847c..45f3c95c99 100644
--- a/src/api/src/lib.rs
+++ b/src/api/src/lib.rs
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(let_chains)]
-
 pub mod error;
 pub mod helper;
 
diff --git a/src/api/src/v1/column_def.rs b/src/api/src/v1/column_def.rs
index ec3d7da3bf..5be3d5c196 100644
--- a/src/api/src/v1/column_def.rs
+++ b/src/api/src/v1/column_def.rs
@@ -37,8 +37,10 @@ const SKIPPING_INDEX_GRPC_KEY: &str = "skipping_index";
 
 /// Tries to construct a `ColumnSchema` from the given  `ColumnDef`.
 pub fn try_as_column_schema(column_def: &ColumnDef) -> Result<ColumnSchema> {
-    let data_type =
-        ColumnDataTypeWrapper::try_new(column_def.data_type, column_def.datatype_extension)?;
+    let data_type = ColumnDataTypeWrapper::try_new(
+        column_def.data_type,
+        column_def.datatype_extension.clone(),
+    )?;
 
     let constraint = if column_def.default_constraint.is_empty() {
         None
diff --git a/src/auth/src/common.rs b/src/auth/src/common.rs
index 96b8432580..7dbcd72086 100644
--- a/src/auth/src/common.rs
+++ b/src/auth/src/common.rs
@@ -35,7 +35,7 @@ pub fn userinfo_by_name(username: Option<String>) -> UserInfoRef {
     DefaultUserInfo::with_name(username.unwrap_or_else(|| DEFAULT_USERNAME.to_string()))
 }
 
-pub fn user_provider_from_option(opt: &String) -> Result<UserProviderRef> {
+pub fn user_provider_from_option(opt: &str) -> Result<UserProviderRef> {
     let (name, content) = opt.split_once(':').with_context(|| InvalidConfigSnafu {
         value: opt.to_string(),
         msg: "UserProviderOption must be in format `<option>:<value>`",
@@ -57,7 +57,7 @@ pub fn user_provider_from_option(opt: &String) -> Result<UserProviderRef> {
     }
 }
 
-pub fn static_user_provider_from_option(opt: &String) -> Result<StaticUserProvider> {
+pub fn static_user_provider_from_option(opt: &str) -> Result<StaticUserProvider> {
     let (name, content) = opt.split_once(':').with_context(|| InvalidConfigSnafu {
         value: opt.to_string(),
         msg: "UserProviderOption must be in format `<option>:<value>`",
diff --git a/src/catalog/src/lib.rs b/src/catalog/src/lib.rs
index 694594d052..b9c40d293d 100644
--- a/src/catalog/src/lib.rs
+++ b/src/catalog/src/lib.rs
@@ -14,7 +14,6 @@
 
 #![feature(assert_matches)]
 #![feature(try_blocks)]
-#![feature(let_chains)]
 
 use std::any::Any;
 use std::fmt::{Debug, Formatter};
diff --git a/src/catalog/src/memory/manager.rs b/src/catalog/src/memory/manager.rs
index 666fa8d5b9..571cd06468 100644
--- a/src/catalog/src/memory/manager.rs
+++ b/src/catalog/src/memory/manager.rs
@@ -392,15 +392,15 @@ impl MemoryCatalogManager {
         if !manager.schema_exist_sync(catalog, schema).unwrap() {
             manager
                 .register_schema_sync(RegisterSchemaRequest {
-                    catalog: catalog.to_string(),
-                    schema: schema.to_string(),
+                    catalog: catalog.clone(),
+                    schema: schema.clone(),
                 })
                 .unwrap();
         }
 
         let request = RegisterTableRequest {
-            catalog: catalog.to_string(),
-            schema: schema.to_string(),
+            catalog: catalog.clone(),
+            schema: schema.clone(),
             table_name: table.table_info().name.clone(),
             table_id: table.table_info().ident.table_id,
             table,
diff --git a/src/catalog/src/process_manager.rs b/src/catalog/src/process_manager.rs
index 353ec01714..1eebfec627 100644
--- a/src/catalog/src/process_manager.rs
+++ b/src/catalog/src/process_manager.rs
@@ -56,14 +56,21 @@ pub struct ProcessManager {
 #[derive(Debug, Clone)]
 pub enum QueryStatement {
     Sql(Statement),
-    Promql(EvalStmt),
+    // The optional string is the alias of the PromQL query.
+    Promql(EvalStmt, Option<String>),
 }
 
 impl Display for QueryStatement {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             QueryStatement::Sql(stmt) => write!(f, "{}", stmt),
-            QueryStatement::Promql(eval_stmt) => write!(f, "{}", eval_stmt),
+            QueryStatement::Promql(eval_stmt, alias) => {
+                if let Some(alias) = alias {
+                    write!(f, "{} AS {}", eval_stmt, alias)
+                } else {
+                    write!(f, "{}", eval_stmt)
+                }
+            }
         }
     }
 }
@@ -338,9 +345,9 @@ impl SlowQueryTimer {
         };
 
         match &self.stmt {
-            QueryStatement::Promql(stmt) => {
+            QueryStatement::Promql(stmt, _alias) => {
                 slow_query_event.is_promql = true;
-                slow_query_event.query = stmt.expr.to_string();
+                slow_query_event.query = self.stmt.to_string();
                 slow_query_event.promql_step = Some(stmt.interval.as_millis() as u64);
 
                 let start = stmt
diff --git a/src/catalog/src/system_schema/information_schema.rs b/src/catalog/src/system_schema/information_schema.rs
index 397ee69a23..fc9bafa604 100644
--- a/src/catalog/src/system_schema/information_schema.rs
+++ b/src/catalog/src/system_schema/information_schema.rs
@@ -362,7 +362,7 @@ impl InformationSchemaProvider {
         }
         #[cfg(feature = "enterprise")]
         for name in self.extra_table_factories.keys() {
-            tables.insert(name.to_string(), self.build_table(name).expect(name));
+            tables.insert(name.clone(), self.build_table(name).expect(name));
         }
         // Add memory tables
         for name in MEMORY_TABLES.iter() {
diff --git a/src/catalog/src/system_schema/information_schema/flows.rs b/src/catalog/src/system_schema/information_schema/flows.rs
index 838c41ab4e..531fb0a5ce 100644
--- a/src/catalog/src/system_schema/information_schema/flows.rs
+++ b/src/catalog/src/system_schema/information_schema/flows.rs
@@ -254,9 +254,9 @@ impl InformationSchemaFlowsBuilder {
                 .await
                 .map_err(BoxedError::new)
                 .context(InternalSnafu)?
-                .context(FlowInfoNotFoundSnafu {
-                    catalog_name: catalog_name.to_string(),
-                    flow_name: flow_name.to_string(),
+                .with_context(|| FlowInfoNotFoundSnafu {
+                    catalog_name: catalog_name.clone(),
+                    flow_name: flow_name.clone(),
                 })?;
             self.add_flow(&predicates, flow_id.flow_id(), flow_info, &flow_stat)
                 .await?;
@@ -273,11 +273,11 @@ impl InformationSchemaFlowsBuilder {
         flow_stat: &Option<FlowStat>,
     ) -> Result<()> {
         let row = [
-            (FLOW_NAME, &Value::from(flow_info.flow_name().to_string())),
+            (FLOW_NAME, &Value::from(flow_info.flow_name().clone())),
             (FLOW_ID, &Value::from(flow_id)),
             (
                 TABLE_CATALOG,
-                &Value::from(flow_info.catalog_name().to_string()),
+                &Value::from(flow_info.catalog_name().clone()),
             ),
         ];
         if !predicates.eval(&row) {
diff --git a/src/catalog/src/system_schema/information_schema/process_list.rs b/src/catalog/src/system_schema/information_schema/process_list.rs
index 7c32f34759..fb453c8c33 100644
--- a/src/catalog/src/system_schema/information_schema/process_list.rs
+++ b/src/catalog/src/system_schema/information_schema/process_list.rs
@@ -135,7 +135,7 @@ async fn make_process_list(
 
     for process in queries {
         let display_id = DisplayProcessId {
-            server_addr: process.frontend.to_string(),
+            server_addr: process.frontend.clone(),
             id: process.id,
         }
         .to_string();
diff --git a/src/catalog/src/system_schema/information_schema/region_peers.rs b/src/catalog/src/system_schema/information_schema/region_peers.rs
index 111dc15cc5..5bc91d207e 100644
--- a/src/catalog/src/system_schema/information_schema/region_peers.rs
+++ b/src/catalog/src/system_schema/information_schema/region_peers.rs
@@ -199,10 +199,7 @@ impl InformationSchemaRegionPeersBuilder {
                     if table_info.table_type == TableType::Temporary {
                         Ok(None)
                     } else {
-                        Ok(Some((
-                            table_info.ident.table_id,
-                            table_info.name.to_string(),
-                        )))
+                        Ok(Some((table_info.ident.table_id, table_info.name.clone())))
                     }
                 });
 
diff --git a/src/catalog/src/system_schema/pg_catalog.rs b/src/catalog/src/system_schema/pg_catalog.rs
index f6729ded28..b3ddec5b3b 100644
--- a/src/catalog/src/system_schema/pg_catalog.rs
+++ b/src/catalog/src/system_schema/pg_catalog.rs
@@ -166,7 +166,7 @@ impl CatalogInfo for CatalogManagerWrapper {
                 .await
                 .map_err(|e| DataFusionError::External(Box::new(e)))
         } else {
-            Ok(vec![self.catalog_name.to_string()])
+            Ok(vec![self.catalog_name.clone()])
         }
     }
 
diff --git a/src/catalog/src/table_source.rs b/src/catalog/src/table_source.rs
index 2bfc777798..9868ecd42a 100644
--- a/src/catalog/src/table_source.rs
+++ b/src/catalog/src/table_source.rs
@@ -201,7 +201,7 @@ impl DfTableSourceProvider {
 
         Ok(Arc::new(ViewTable::new(
             logical_plan,
-            Some(view_info.definition.to_string()),
+            Some(view_info.definition.clone()),
         )))
     }
 }
diff --git a/src/cli/src/metadata/control/del/key.rs b/src/cli/src/metadata/control/del/key.rs
index ded3e4d2fe..b83cd7db16 100644
--- a/src/cli/src/metadata/control/del/key.rs
+++ b/src/cli/src/metadata/control/del/key.rs
@@ -41,7 +41,7 @@ impl DelKeyCommand {
     pub async fn build(&self) -> Result<Box<dyn Tool>, BoxedError> {
         let kv_backend = self.store.build().await?;
         Ok(Box::new(DelKeyTool {
-            key: self.key.to_string(),
+            key: self.key.clone(),
             prefix: self.prefix,
             key_deleter: KeyDeleter::new(kv_backend),
         }))
diff --git a/src/cli/src/metadata/repair.rs b/src/cli/src/metadata/repair.rs
index ec4822206b..b864ab3857 100644
--- a/src/cli/src/metadata/repair.rs
+++ b/src/cli/src/metadata/repair.rs
@@ -138,13 +138,7 @@ impl RepairTool {
 
             let table_names = table_names
                 .iter()
-                .map(|table_name| {
-                    (
-                        catalog.to_string(),
-                        schema_name.to_string(),
-                        table_name.to_string(),
-                    )
-                })
+                .map(|table_name| (catalog.clone(), schema_name.clone(), table_name.clone()))
                 .collect::<Vec<_>>();
             return Ok(IteratorInput::new_table_names(table_names));
         } else if !self.table_ids.is_empty() {
diff --git a/src/cli/src/metadata/repair/alter_table.rs b/src/cli/src/metadata/repair/alter_table.rs
index c9d196d2d1..efe95c74b8 100644
--- a/src/cli/src/metadata/repair/alter_table.rs
+++ b/src/cli/src/metadata/repair/alter_table.rs
@@ -32,9 +32,9 @@ pub fn generate_alter_table_expr_for_all_columns(
     let schema = &table_info.meta.schema;
 
     let mut alter_table_expr = AlterTableExpr {
-        catalog_name: table_info.catalog_name.to_string(),
-        schema_name: table_info.schema_name.to_string(),
-        table_name: table_info.name.to_string(),
+        catalog_name: table_info.catalog_name.clone(),
+        schema_name: table_info.schema_name.clone(),
+        table_name: table_info.name.clone(),
         ..Default::default()
     };
 
diff --git a/src/cli/src/metadata/repair/create_table.rs b/src/cli/src/metadata/repair/create_table.rs
index 444f3558d2..b540e2175e 100644
--- a/src/cli/src/metadata/repair/create_table.rs
+++ b/src/cli/src/metadata/repair/create_table.rs
@@ -44,9 +44,9 @@ pub fn generate_create_table_expr(table_info: &RawTableInfo) -> Result<CreateTab
     let table_options = HashMap::from(&table_info.meta.options);
 
     Ok(CreateTableExpr {
-        catalog_name: table_info.catalog_name.to_string(),
-        schema_name: table_info.schema_name.to_string(),
-        table_name: table_info.name.to_string(),
+        catalog_name: table_info.catalog_name.clone(),
+        schema_name: table_info.schema_name.clone(),
+        table_name: table_info.name.clone(),
         desc: String::default(),
         column_defs,
         time_index,
@@ -54,7 +54,7 @@ pub fn generate_create_table_expr(table_info: &RawTableInfo) -> Result<CreateTab
         create_if_not_exists: true,
         table_options,
         table_id: None,
-        engine: table_info.meta.engine.to_string(),
+        engine: table_info.meta.engine.clone(),
     })
 }
 
diff --git a/src/client/src/error.rs b/src/client/src/error.rs
index 0e70296c26..5fdb383358 100644
--- a/src/client/src/error.rs
+++ b/src/client/src/error.rs
@@ -18,7 +18,7 @@ use common_error::define_from_tonic_status;
 use common_error::ext::{BoxedError, ErrorExt};
 use common_error::status_code::StatusCode;
 use common_macro::stack_trace_debug;
-use snafu::{Location, Snafu, location};
+use snafu::{Location, Snafu};
 use tonic::Code;
 use tonic::metadata::errors::InvalidMetadataValue;
 
diff --git a/src/cmd/src/frontend.rs b/src/cmd/src/frontend.rs
index d147fc648e..4c72021a47 100644
--- a/src/cmd/src/frontend.rs
+++ b/src/cmd/src/frontend.rs
@@ -252,10 +252,10 @@ impl StartCommand {
 
         if let Some(addr) = &self.internal_rpc_bind_addr {
             if let Some(internal_grpc) = &mut opts.internal_grpc {
-                internal_grpc.bind_addr = addr.to_string();
+                internal_grpc.bind_addr = addr.clone();
             } else {
                 let grpc_options = GrpcOptions {
-                    bind_addr: addr.to_string(),
+                    bind_addr: addr.clone(),
                     ..Default::default()
                 };
 
@@ -265,10 +265,10 @@ impl StartCommand {
 
         if let Some(addr) = &self.internal_rpc_server_addr {
             if let Some(internal_grpc) = &mut opts.internal_grpc {
-                internal_grpc.server_addr = addr.to_string();
+                internal_grpc.server_addr = addr.clone();
             } else {
                 let grpc_options = GrpcOptions {
-                    server_addr: addr.to_string(),
+                    server_addr: addr.clone(),
                     ..Default::default()
                 };
                 opts.internal_grpc = Some(grpc_options);
diff --git a/src/cmd/src/lib.rs b/src/cmd/src/lib.rs
index b7cf30b808..41c40da032 100644
--- a/src/cmd/src/lib.rs
+++ b/src/cmd/src/lib.rs
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(assert_matches, let_chains)]
+#![feature(assert_matches)]
 
 use async_trait::async_trait;
 use common_error::ext::ErrorExt;
diff --git a/src/common/base/src/plugins.rs b/src/common/base/src/plugins.rs
index 5d27ad1ac1..bbab003c69 100644
--- a/src/common/base/src/plugins.rs
+++ b/src/common/base/src/plugins.rs
@@ -75,11 +75,11 @@ impl Plugins {
         self.read().is_empty()
     }
 
-    fn read(&self) -> RwLockReadGuard<SendSyncAnyMap> {
+    fn read(&self) -> RwLockReadGuard<'_, SendSyncAnyMap> {
         self.inner.read().unwrap()
     }
 
-    fn write(&self) -> RwLockWriteGuard<SendSyncAnyMap> {
+    fn write(&self) -> RwLockWriteGuard<'_, SendSyncAnyMap> {
         self.inner.write().unwrap()
     }
 }
diff --git a/src/common/datasource/src/buffered_writer.rs b/src/common/datasource/src/buffered_writer.rs
index 19fb9ee5fc..e1571b0187 100644
--- a/src/common/datasource/src/buffered_writer.rs
+++ b/src/common/datasource/src/buffered_writer.rs
@@ -150,7 +150,7 @@ impl<
         if let Some(ref mut writer) = self.writer {
             Ok(writer)
         } else {
-            let writer = (self.writer_factory)(self.path.to_string()).await?;
+            let writer = (self.writer_factory)(self.path.clone()).await?;
             Ok(self.writer.insert(writer))
         }
     }
diff --git a/src/common/datasource/src/test_util.rs b/src/common/datasource/src/test_util.rs
index 0813030fa3..f3f813be34 100644
--- a/src/common/datasource/src/test_util.rs
+++ b/src/common/datasource/src/test_util.rs
@@ -87,7 +87,7 @@ pub(crate) fn scan_config(
 ) -> FileScanConfig {
     // object_store only recognize the Unix style path, so make it happy.
     let filename = &filename.replace('\\', "/");
-    let file_group = FileGroup::new(vec![PartitionedFile::new(filename.to_string(), 4096)]);
+    let file_group = FileGroup::new(vec![PartitionedFile::new(filename.clone(), 4096)]);
 
     FileScanConfigBuilder::new(ObjectStoreUrl::local_filesystem(), file_schema, file_source)
         .with_file_group(file_group)
diff --git a/src/common/function/src/function_registry.rs b/src/common/function/src/function_registry.rs
index 79f88d85d8..75bb71c63a 100644
--- a/src/common/function/src/function_registry.rs
+++ b/src/common/function/src/function_registry.rs
@@ -71,7 +71,7 @@ impl FunctionRegistry {
         for alias in func.aliases() {
             let func: ScalarFunctionFactory = func.clone().into();
             let alias = ScalarFunctionFactory {
-                name: alias.to_string(),
+                name: alias.clone(),
                 ..func
             };
             self.register(alias);
diff --git a/src/common/function/src/helper.rs b/src/common/function/src/helper.rs
index 086755e738..6e643443ec 100644
--- a/src/common/function/src/helper.rs
+++ b/src/common/function/src/helper.rs
@@ -38,7 +38,7 @@ pub(crate) fn one_of_sigs2(args1: Vec<DataType>, args2: Vec<DataType>) -> Signat
 
 /// Cast a [`ValueRef`] to u64, returns `None` if fails
 pub fn cast_u64(value: &ValueRef) -> Result<Option<u64>> {
-    cast((*value).into(), &ConcreteDataType::uint64_datatype())
+    cast(value.clone().into(), &ConcreteDataType::uint64_datatype())
         .context(InvalidInputTypeSnafu {
             err_msg: format!(
                 "Failed to cast input into uint64, actual type: {:#?}",
@@ -50,7 +50,7 @@ pub fn cast_u64(value: &ValueRef) -> Result<Option<u64>> {
 
 /// Cast a [`ValueRef`] to u32, returns `None` if fails
 pub fn cast_u32(value: &ValueRef) -> Result<Option<u32>> {
-    cast((*value).into(), &ConcreteDataType::uint32_datatype())
+    cast(value.clone().into(), &ConcreteDataType::uint32_datatype())
         .context(InvalidInputTypeSnafu {
             err_msg: format!(
                 "Failed to cast input into uint32, actual type: {:#?}",
diff --git a/src/common/function/src/lib.rs b/src/common/function/src/lib.rs
index 429d99892d..36fd27381d 100644
--- a/src/common/function/src/lib.rs
+++ b/src/common/function/src/lib.rs
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(let_chains)]
 #![feature(try_blocks)]
 #![feature(assert_matches)]
 
diff --git a/src/common/function/src/scalars/expression/binary.rs b/src/common/function/src/scalars/expression/binary.rs
index 9ef67a2b0f..4d9f6268a8 100644
--- a/src/common/function/src/scalars/expression/binary.rs
+++ b/src/common/function/src/scalars/expression/binary.rs
@@ -41,7 +41,7 @@ where
             let right: &<R as Scalar>::VectorType = unsafe { Helper::static_cast(right.inner()) };
             let b = right.get_data(0);
 
-            let it = left.iter_data().map(|a| f(a, b, ctx));
+            let it = left.iter_data().map(|a| f(a, b.clone(), ctx));
             <O as Scalar>::VectorType::from_owned_iterator(it)
         }
 
@@ -62,7 +62,7 @@ where
             let a = left.get_data(0);
 
             let right: &<R as Scalar>::VectorType = unsafe { Helper::static_cast(r) };
-            let it = right.iter_data().map(|b| f(a, b, ctx));
+            let it = right.iter_data().map(|b| f(a.clone(), b, ctx));
             <O as Scalar>::VectorType::from_owned_iterator(it)
         }
 
diff --git a/src/common/function/src/scalars/ip/range.rs b/src/common/function/src/scalars/ip/range.rs
index f7040e4040..a347d4b480 100644
--- a/src/common/function/src/scalars/ip/range.rs
+++ b/src/common/function/src/scalars/ip/range.rs
@@ -309,7 +309,7 @@ fn is_ipv6_in_range(ip: &Ipv6Addr, cidr_base: &Ipv6Addr, prefix_len: u8) -> Opti
     }
 
     // If there's a partial byte to check
-    if prefix_len % 8 != 0 && full_bytes < 16 {
+    if !prefix_len.is_multiple_of(8) && full_bytes < 16 {
         let bits_to_check = prefix_len % 8;
         let mask = 0xFF_u8 << (8 - bits_to_check);
 
diff --git a/src/common/function/src/scalars/vector/impl_conv.rs b/src/common/function/src/scalars/vector/impl_conv.rs
index 875a1a6a09..219361a302 100644
--- a/src/common/function/src/scalars/vector/impl_conv.rs
+++ b/src/common/function/src/scalars/vector/impl_conv.rs
@@ -36,7 +36,7 @@ pub fn as_veclit(arg: &ScalarValue) -> Result<Option<Cow<'_, [f32]>>> {
 
 /// Convert a u8 slice to a vector literal.
 pub fn binlit_as_veclit(bytes: &[u8]) -> Result<Cow<'_, [f32]>> {
-    if bytes.len() % std::mem::size_of::<f32>() != 0 {
+    if !bytes.len().is_multiple_of(size_of::<f32>()) {
         return InvalidFuncArgsSnafu {
             err_msg: format!("Invalid binary length of vector: {}", bytes.len()),
         }
diff --git a/src/common/grpc-expr/src/insert.rs b/src/common/grpc-expr/src/insert.rs
index 08857faf7b..d1e360d148 100644
--- a/src/common/grpc-expr/src/insert.rs
+++ b/src/common/grpc-expr/src/insert.rs
@@ -46,7 +46,7 @@ pub(crate) fn add_values_to_builder(
                 Some(true) => builder.push_null(),
                 _ => {
                     builder
-                        .try_push_value_ref(values[idx_of_values].as_value_ref())
+                        .try_push_value_ref(&values[idx_of_values].as_value_ref())
                         .context(CreateVectorSnafu)?;
                     idx_of_values += 1
                 }
diff --git a/src/common/grpc-expr/src/util.rs b/src/common/grpc-expr/src/util.rs
index b807b211b6..84e268b687 100644
--- a/src/common/grpc-expr/src/util.rs
+++ b/src/common/grpc-expr/src/util.rs
@@ -167,7 +167,7 @@ pub fn build_create_table_expr(
             default_constraint: vec![],
             semantic_type,
             comment: String::new(),
-            datatype_extension: *datatype_extension,
+            datatype_extension: datatype_extension.clone(),
             options: options.clone(),
         });
     }
@@ -209,7 +209,7 @@ pub fn extract_new_columns(
                 default_constraint: vec![],
                 semantic_type: expr.semantic_type,
                 comment: String::new(),
-                datatype_extension: *expr.datatype_extension,
+                datatype_extension: expr.datatype_extension.clone(),
                 options: expr.options.clone(),
             });
             AddColumn {
@@ -425,7 +425,7 @@ mod tests {
             ConcreteDataType::from(
                 ColumnDataTypeWrapper::try_new(
                     decimal_column.data_type,
-                    decimal_column.datatype_extension,
+                    decimal_column.datatype_extension.clone(),
                 )
                 .unwrap()
             )
@@ -520,6 +520,7 @@ mod tests {
                         .as_ref()
                         .unwrap()
                         .datatype_extension
+                        .clone()
                 )
                 .unwrap()
             )
diff --git a/src/common/grpc/src/channel_manager.rs b/src/common/grpc/src/channel_manager.rs
index b3862f7e22..cdea89cb86 100644
--- a/src/common/grpc/src/channel_manager.rs
+++ b/src/common/grpc/src/channel_manager.rs
@@ -479,7 +479,7 @@ impl Pool {
         })
     }
 
-    fn entry(&self, addr: String) -> Entry<String, Channel> {
+    fn entry(&self, addr: String) -> Entry<'_, String, Channel> {
         self.channels.entry(addr)
     }
 
diff --git a/src/common/macro/src/admin_fn.rs b/src/common/macro/src/admin_fn.rs
index 023ff977b5..ca97e5468f 100644
--- a/src/common/macro/src/admin_fn.rs
+++ b/src/common/macro/src/admin_fn.rs
@@ -325,7 +325,7 @@ fn build_struct(
                     let result = #fn_name(handler, query_ctx, &[]).await
                         .map_err(|e| datafusion_common::DataFusionError::Execution(format!("Function execution error: {}", e.output_msg())))?;
 
-                    builder.push_value_ref(result.as_value_ref());
+                    builder.push_value_ref(&result.as_value_ref());
                 } else {
                     for i in 0..rows_num {
                         let args: Vec<_> = columns.iter()
@@ -335,7 +335,7 @@ fn build_struct(
                         let result = #fn_name(handler, query_ctx, &args).await
                             .map_err(|e| datafusion_common::DataFusionError::Execution(format!("Function execution error: {}", e.output_msg())))?;
 
-                        builder.push_value_ref(result.as_value_ref());
+                        builder.push_value_ref(&result.as_value_ref());
                     }
                 }
 
diff --git a/src/common/macro/src/row/schema.rs b/src/common/macro/src/row/schema.rs
index 8a033b5aad..5e296c8600 100644
--- a/src/common/macro/src/row/schema.rs
+++ b/src/common/macro/src/row/schema.rs
@@ -90,6 +90,24 @@ fn impl_schema_method(fields: &[ParsedField<'_>]) -> Result<TokenStream2> {
                                 Some(ColumnDataTypeExtension { type_ext: Some(TypeExt::VectorType(VectorTypeExtension { dim: #dim })) })
                             }
                         }
+                        Some(TypeExt::ListType(ext)) => {
+                            let item_type = syn::Ident::new(&ext.datatype.to_string(), ident.span());
+                            quote! {
+                                Some(ColumnDataTypeExtension { type_ext: Some(TypeExt::ListType(ListTypeExtension { item_type: #item_type })) })
+                            }
+                        }
+                        Some(TypeExt::StructType(ext)) => {
+                            let fields = ext.fields.iter().map(|field| {
+                                let field_name = syn::Ident::new(&field.name.clone(), ident.span());
+                                let field_type = syn::Ident::new(&field.datatype.to_string(), ident.span());
+                                quote! {
+                                    StructField { name: #field_name, type_: #field_type }
+                                }
+                            }).collect::<Vec<_>>();
+                            quote! {
+                                Some(ColumnDataTypeExtension { type_ext: Some(TypeExt::StructType(StructTypeExtension { fields: [#(#fields),*] })) })
+                            }
+                        }
                         None => {
                             quote! { None }
                         }
diff --git a/src/common/macro/src/row/utils.rs b/src/common/macro/src/row/utils.rs
index 7b6547847a..40f990a40a 100644
--- a/src/common/macro/src/row/utils.rs
+++ b/src/common/macro/src/row/utils.rs
@@ -184,7 +184,7 @@ pub(crate) fn convert_semantic_type_to_proto_semantic_type(
     }
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub(crate) struct ColumnDataTypeWithExtension {
     pub(crate) data_type: ColumnDataType,
     pub(crate) extension: Option<ColumnDataTypeExtension>,
@@ -260,7 +260,10 @@ pub(crate) fn get_column_data_type(
     infer_column_data_type: &Option<ColumnDataTypeWithExtension>,
     attribute: &ColumnAttribute,
 ) -> Option<ColumnDataTypeWithExtension> {
-    attribute.datatype.or(*infer_column_data_type)
+    attribute
+        .datatype
+        .clone()
+        .or_else(|| infer_column_data_type.clone())
 }
 
 /// Convert a column data type to a value data ident.
@@ -304,5 +307,7 @@ pub(crate) fn convert_column_data_type_to_value_data_ident(
         // Json is a special case, it is actually a string column.
         ColumnDataType::Json => format_ident!("StringValue"),
         ColumnDataType::Vector => format_ident!("VectorValue"),
+        ColumnDataType::List => format_ident!("ListValue"),
+        ColumnDataType::Struct => format_ident!("StructValue"),
     }
 }
diff --git a/src/common/meta/src/datanode.rs b/src/common/meta/src/datanode.rs
index 2c57a09353..2083b5886b 100644
--- a/src/common/meta/src/datanode.rs
+++ b/src/common/meta/src/datanode.rs
@@ -29,22 +29,17 @@ use crate::error;
 use crate::error::Result;
 use crate::heartbeat::utils::get_datanode_workloads;
 
-pub(crate) const DATANODE_LEASE_PREFIX: &str = "__meta_datanode_lease";
-const INACTIVE_REGION_PREFIX: &str = "__meta_inactive_region";
-
 const DATANODE_STAT_PREFIX: &str = "__meta_datanode_stat";
 
 pub const REGION_STATISTIC_KEY: &str = "__region_statistic";
 
 lazy_static! {
     pub(crate) static ref DATANODE_LEASE_KEY_PATTERN: Regex =
-        Regex::new(&format!("^{DATANODE_LEASE_PREFIX}-([0-9]+)-([0-9]+)$")).unwrap();
+        Regex::new("^__meta_datanode_lease-([0-9]+)-([0-9]+)$").unwrap();
     static ref DATANODE_STAT_KEY_PATTERN: Regex =
         Regex::new(&format!("^{DATANODE_STAT_PREFIX}-([0-9]+)-([0-9]+)$")).unwrap();
-    static ref INACTIVE_REGION_KEY_PATTERN: Regex = Regex::new(&format!(
-        "^{INACTIVE_REGION_PREFIX}-([0-9]+)-([0-9]+)-([0-9]+)$"
-    ))
-    .unwrap();
+    static ref INACTIVE_REGION_KEY_PATTERN: Regex =
+        Regex::new("^__meta_inactive_region-([0-9]+)-([0-9]+)-([0-9]+)$").unwrap();
 }
 
 /// The key of the datanode stat in the storage.
@@ -297,7 +292,7 @@ impl From<&api::v1::meta::RegionStat> for RegionStat {
             rcus: value.rcus,
             wcus: value.wcus,
             approximate_bytes: value.approximate_bytes as u64,
-            engine: value.engine.to_string(),
+            engine: value.engine.clone(),
             role: RegionRole::from(value.role()),
             num_rows: region_stat.num_rows,
             memtable_size: region_stat.memtable_size,
diff --git a/src/common/meta/src/ddl/alter_logical_tables/validator.rs b/src/common/meta/src/ddl/alter_logical_tables/validator.rs
index f703584c50..d9d8581125 100644
--- a/src/common/meta/src/ddl/alter_logical_tables/validator.rs
+++ b/src/common/meta/src/ddl/alter_logical_tables/validator.rs
@@ -85,7 +85,7 @@ impl<'a> AlterLogicalTableValidator<'a> {
         Ok(())
     }
 
-    fn table_names(&self) -> Vec<TableReference> {
+    fn table_names(&self) -> Vec<TableReference<'_>> {
         self.alters
             .iter()
             .map(|alter| {
diff --git a/src/common/meta/src/ddl/alter_table.rs b/src/common/meta/src/ddl/alter_table.rs
index 2fcf9df5fb..3e913cae29 100644
--- a/src/common/meta/src/ddl/alter_table.rs
+++ b/src/common/meta/src/ddl/alter_table.rs
@@ -75,7 +75,7 @@ fn build_executor_from_alter_expr(alter_data: &AlterTableData) -> AlterTableExec
     let table_id = alter_data.table_id;
     let alter_kind = alter_data.task.alter_table.kind.as_ref().unwrap();
     let new_table_name = if let Kind::RenameTable(RenameTable { new_table_name }) = alter_kind {
-        Some(new_table_name.to_string())
+        Some(new_table_name.clone())
     } else {
         None
     };
@@ -418,7 +418,7 @@ impl AlterTableData {
         }
     }
 
-    fn table_ref(&self) -> TableReference {
+    fn table_ref(&self) -> TableReference<'_> {
         self.task.table_ref()
     }
 
diff --git a/src/common/meta/src/ddl/alter_table/executor.rs b/src/common/meta/src/ddl/alter_table/executor.rs
index 99b6a1e012..a5e843dd08 100644
--- a/src/common/meta/src/ddl/alter_table/executor.rs
+++ b/src/common/meta/src/ddl/alter_table/executor.rs
@@ -132,7 +132,7 @@ impl AlterTableExecutor {
             );
 
             table_metadata_manager
-                .rename_table(current_table_info_value, new_table_name.to_string())
+                .rename_table(current_table_info_value, new_table_name.clone())
                 .await?;
         } else {
             debug!(
@@ -293,7 +293,7 @@ fn build_new_table_info(
             new_info.meta.next_column_id += columns.len() as u32;
         }
         AlterKind::RenameTable { new_table_name } => {
-            new_info.name = new_table_name.to_string();
+            new_info.name = new_table_name.clone();
         }
         AlterKind::DropColumns { .. }
         | AlterKind::ModifyColumnTypes { .. }
diff --git a/src/common/meta/src/ddl/create_flow.rs b/src/common/meta/src/ddl/create_flow.rs
index 0ad6b782bc..7120e50425 100644
--- a/src/common/meta/src/ddl/create_flow.rs
+++ b/src/common/meta/src/ddl/create_flow.rs
@@ -379,9 +379,10 @@ pub enum CreateFlowState {
 }
 
 /// The type of flow.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
 pub enum FlowType {
     /// The flow is a batching task.
+    #[default]
     Batching,
     /// The flow is a streaming task.
     Streaming,
@@ -393,12 +394,6 @@ impl FlowType {
     pub const FLOW_TYPE_KEY: &str = "flow_type";
 }
 
-impl Default for FlowType {
-    fn default() -> Self {
-        Self::Batching
-    }
-}
-
 impl fmt::Display for FlowType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
diff --git a/src/common/meta/src/ddl/create_logical_tables/check.rs b/src/common/meta/src/ddl/create_logical_tables/check.rs
index 6ed94e7826..8e8002fda3 100644
--- a/src/common/meta/src/ddl/create_logical_tables/check.rs
+++ b/src/common/meta/src/ddl/create_logical_tables/check.rs
@@ -52,7 +52,7 @@ impl CreateLogicalTablesProcedure {
                 ensure!(
                     task.create_table.create_if_not_exists,
                     TableAlreadyExistsSnafu {
-                        table_name: task.create_table.table_name.to_string(),
+                        table_name: task.create_table.table_name.clone(),
                     }
                 );
                 continue;
diff --git a/src/common/meta/src/ddl/create_table_template.rs b/src/common/meta/src/ddl/create_table_template.rs
index df745e2f48..19ee82c091 100644
--- a/src/common/meta/src/ddl/create_table_template.rs
+++ b/src/common/meta/src/ddl/create_table_template.rs
@@ -90,7 +90,7 @@ pub(crate) fn build_template(create_table_expr: &CreateTableExpr) -> Result<Crea
                     default_constraint: c.default_constraint.clone(),
                     semantic_type: semantic_type as i32,
                     comment: String::new(),
-                    datatype_extension: c.datatype_extension,
+                    datatype_extension: c.datatype_extension.clone(),
                     options: c.options.clone(),
                 }),
                 column_id: i as u32,
@@ -119,7 +119,7 @@ pub(crate) fn build_template(create_table_expr: &CreateTableExpr) -> Result<Crea
 
     let template = CreateRequest {
         region_id: 0,
-        engine: create_table_expr.engine.to_string(),
+        engine: create_table_expr.engine.clone(),
         column_defs,
         primary_key,
         path: String::new(),
diff --git a/src/common/meta/src/ddl/drop_flow.rs b/src/common/meta/src/ddl/drop_flow.rs
index 3177cd8821..8a0858720c 100644
--- a/src/common/meta/src/ddl/drop_flow.rs
+++ b/src/common/meta/src/ddl/drop_flow.rs
@@ -167,8 +167,8 @@ impl DropFlowProcedure {
                 &[
                     CacheIdent::FlowId(flow_id),
                     CacheIdent::FlowName(FlowName {
-                        catalog_name: flow_info_value.catalog_name.to_string(),
-                        flow_name: flow_info_value.flow_name.to_string(),
+                        catalog_name: flow_info_value.catalog_name.clone(),
+                        flow_name: flow_info_value.flow_name.clone(),
                     }),
                     CacheIdent::DropFlow(DropFlow {
                         flow_id,
diff --git a/src/common/meta/src/ddl/drop_table.rs b/src/common/meta/src/ddl/drop_table.rs
index 394d749e07..bc51ba1918 100644
--- a/src/common/meta/src/ddl/drop_table.rs
+++ b/src/common/meta/src/ddl/drop_table.rs
@@ -291,7 +291,7 @@ impl DropTableData {
         }
     }
 
-    fn table_ref(&self) -> TableReference {
+    fn table_ref(&self) -> TableReference<'_> {
         self.task.table_ref()
     }
 
diff --git a/src/common/meta/src/ddl/drop_view.rs b/src/common/meta/src/ddl/drop_view.rs
index d339f3249c..300e2cbac8 100644
--- a/src/common/meta/src/ddl/drop_view.rs
+++ b/src/common/meta/src/ddl/drop_view.rs
@@ -219,7 +219,7 @@ pub(crate) struct DropViewData {
 }
 
 impl DropViewData {
-    fn table_ref(&self) -> TableReference {
+    fn table_ref(&self) -> TableReference<'_> {
         self.task.table_ref()
     }
 
diff --git a/src/common/meta/src/ddl/test_util.rs b/src/common/meta/src/ddl/test_util.rs
index d97448d6b9..5eef47defb 100644
--- a/src/common/meta/src/ddl/test_util.rs
+++ b/src/common/meta/src/ddl/test_util.rs
@@ -247,7 +247,7 @@ pub fn assert_column_name(table_info: &RawTableInfo, expected_column_names: &[&s
             .schema
             .column_schemas
             .iter()
-            .map(|c| c.name.to_string())
+            .map(|c| c.name.clone())
             .collect::<Vec<_>>(),
         expected_column_names
     );
diff --git a/src/common/meta/src/ddl/test_util/create_table.rs b/src/common/meta/src/ddl/test_util/create_table.rs
index 13ca2ec195..a4150fcb9c 100644
--- a/src/common/meta/src/ddl/test_util/create_table.rs
+++ b/src/common/meta/src/ddl/test_util/create_table.rs
@@ -98,10 +98,10 @@ pub fn build_raw_table_info_from_expr(expr: &CreateTableExpr) -> RawTableInfo {
                 .unwrap_or(0),
             version: 1,
         },
-        name: expr.table_name.to_string(),
-        desc: Some(expr.desc.to_string()),
-        catalog_name: expr.catalog_name.to_string(),
-        schema_name: expr.schema_name.to_string(),
+        name: expr.table_name.clone(),
+        desc: Some(expr.desc.clone()),
+        catalog_name: expr.catalog_name.clone(),
+        schema_name: expr.schema_name.clone(),
         meta: RawTableMeta {
             schema: RawSchema {
                 column_schemas: expr
@@ -126,7 +126,7 @@ pub fn build_raw_table_info_from_expr(expr: &CreateTableExpr) -> RawTableInfo {
                 })
                 .collect(),
             value_indices: vec![],
-            engine: expr.engine.to_string(),
+            engine: expr.engine.clone(),
             next_column_id: expr.column_defs.len() as u32,
             region_numbers: vec![],
             options: TableOptions::try_from_iter(&expr.table_options).unwrap(),
diff --git a/src/common/meta/src/ddl/test_util/datanode_handler.rs b/src/common/meta/src/ddl/test_util/datanode_handler.rs
index 839dbf9358..26c97efe91 100644
--- a/src/common/meta/src/ddl/test_util/datanode_handler.rs
+++ b/src/common/meta/src/ddl/test_util/datanode_handler.rs
@@ -218,7 +218,7 @@ pub struct PartialSuccessDatanodeHandler {
 #[async_trait::async_trait]
 impl MockDatanodeHandler for PartialSuccessDatanodeHandler {
     async fn handle(&self, peer: &Peer, _request: RegionRequest) -> Result<RegionResponse> {
-        let success = peer.id % 2 == 0;
+        let success = peer.id.is_multiple_of(2);
         if success {
             Ok(RegionResponse::new(0))
         } else if self.retryable {
diff --git a/src/common/meta/src/ddl/truncate_table.rs b/src/common/meta/src/ddl/truncate_table.rs
index 2206f0b6f8..bf46c8c9a1 100644
--- a/src/common/meta/src/ddl/truncate_table.rs
+++ b/src/common/meta/src/ddl/truncate_table.rs
@@ -218,7 +218,7 @@ impl TruncateTableData {
         }
     }
 
-    pub fn table_ref(&self) -> TableReference {
+    pub fn table_ref(&self) -> TableReference<'_> {
         self.task.table_ref()
     }
 
diff --git a/src/common/meta/src/instruction.rs b/src/common/meta/src/instruction.rs
index b2e4e261cd..4781911322 100644
--- a/src/common/meta/src/instruction.rs
+++ b/src/common/meta/src/instruction.rs
@@ -302,35 +302,25 @@ pub struct DropFlow {
 }
 
 /// Strategy for executing flush operations.
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
 pub enum FlushStrategy {
     /// Synchronous operation that waits for completion and expects a reply
+    #[default]
     Sync,
     /// Asynchronous hint operation (fire-and-forget, no reply expected)
     Async,
 }
 
 /// Error handling strategy for batch flush operations.
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
 pub enum FlushErrorStrategy {
     /// Abort on first error (fail-fast)
+    #[default]
     FailFast,
     /// Attempt to flush all regions and collect all errors
     TryAll,
 }
 
-impl Default for FlushStrategy {
-    fn default() -> Self {
-        Self::Sync
-    }
-}
-
-impl Default for FlushErrorStrategy {
-    fn default() -> Self {
-        Self::FailFast
-    }
-}
-
 /// Unified flush instruction supporting both single and batch operations
 /// with configurable execution strategies and error handling.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
diff --git a/src/common/meta/src/key.rs b/src/common/meta/src/key.rs
index 0813f4d249..a1d98db301 100644
--- a/src/common/meta/src/key.rs
+++ b/src/common/meta/src/key.rs
@@ -2172,7 +2172,7 @@ mod tests {
                 table_id,
                 RegionInfo {
                     engine: engine.to_string(),
-                    region_storage_path: region_storage_path.to_string(),
+                    region_storage_path: region_storage_path.clone(),
                     region_options: HashMap::new(),
                     region_wal_options: HashMap::new(),
                 },
@@ -2191,7 +2191,7 @@ mod tests {
                 table_id,
                 RegionInfo {
                     engine: engine.to_string(),
-                    region_storage_path: region_storage_path.to_string(),
+                    region_storage_path: region_storage_path.clone(),
                     region_options: HashMap::new(),
                     region_wal_options: HashMap::new(),
                 },
@@ -2216,7 +2216,7 @@ mod tests {
                 table_id,
                 RegionInfo {
                     engine: engine.to_string(),
-                    region_storage_path: region_storage_path.to_string(),
+                    region_storage_path: region_storage_path.clone(),
                     region_options: HashMap::new(),
                     region_wal_options: HashMap::new(),
                 },
@@ -2247,7 +2247,7 @@ mod tests {
                     table_id,
                     RegionInfo {
                         engine: engine.to_string(),
-                        region_storage_path: region_storage_path.to_string(),
+                        region_storage_path: region_storage_path.clone(),
                         region_options: HashMap::new(),
                         region_wal_options: HashMap::new(),
                     },
diff --git a/src/common/meta/src/key/table_info.rs b/src/common/meta/src/key/table_info.rs
index 42cdbe3dc8..1bb099f44c 100644
--- a/src/common/meta/src/key/table_info.rs
+++ b/src/common/meta/src/key/table_info.rs
@@ -113,7 +113,7 @@ impl TableInfoValue {
         }
     }
 
-    pub fn table_ref(&self) -> TableReference {
+    pub fn table_ref(&self) -> TableReference<'_> {
         TableReference::full(
             &self.table_info.catalog_name,
             &self.table_info.schema_name,
@@ -123,9 +123,9 @@ impl TableInfoValue {
 
     pub fn table_name(&self) -> TableName {
         TableName {
-            catalog_name: self.table_info.catalog_name.to_string(),
-            schema_name: self.table_info.schema_name.to_string(),
-            table_name: self.table_info.name.to_string(),
+            catalog_name: self.table_info.catalog_name.clone(),
+            schema_name: self.table_info.schema_name.clone(),
+            table_name: self.table_info.name.clone(),
         }
     }
 
diff --git a/src/common/meta/src/kv_backend/rds/mysql.rs b/src/common/meta/src/kv_backend/rds/mysql.rs
index 01bd45b67a..aa7654ae46 100644
--- a/src/common/meta/src/kv_backend/rds/mysql.rs
+++ b/src/common/meta/src/kv_backend/rds/mysql.rs
@@ -555,8 +555,8 @@ impl MySqlStore {
         sqlx::query(&sql_template_set.create_table_statement)
             .execute(&pool)
             .await
-            .context(MySqlExecutionSnafu {
-                sql: sql_template_set.create_table_statement.to_string(),
+            .with_context(|_| MySqlExecutionSnafu {
+                sql: sql_template_set.create_table_statement.clone(),
             })?;
         Ok(Arc::new(MySqlStore {
             max_txn_ops,
diff --git a/src/common/meta/src/kv_backend/rds/postgres.rs b/src/common/meta/src/kv_backend/rds/postgres.rs
index 05ed19b885..72c250d8d8 100644
--- a/src/common/meta/src/kv_backend/rds/postgres.rs
+++ b/src/common/meta/src/kv_backend/rds/postgres.rs
@@ -880,7 +880,7 @@ impl PgStore {
             .execute(&sql_template_set.create_table_statement, &[])
             .await
             .with_context(|_| PostgresExecutionSnafu {
-                sql: sql_template_set.create_table_statement.to_string(),
+                sql: sql_template_set.create_table_statement.clone(),
             })?;
         Ok(Arc::new(Self {
             max_txn_ops,
@@ -926,8 +926,8 @@ mod tests {
         client
             .execute(&sql_templates.create_table_statement, &[])
             .await
-            .context(PostgresExecutionSnafu {
-                sql: sql_templates.create_table_statement.to_string(),
+            .with_context(|_| PostgresExecutionSnafu {
+                sql: sql_templates.create_table_statement.clone(),
             })
             .unwrap();
         Some(PgStore {
diff --git a/src/common/meta/src/lib.rs b/src/common/meta/src/lib.rs
index 8381fa7cb8..17bca731b2 100644
--- a/src/common/meta/src/lib.rs
+++ b/src/common/meta/src/lib.rs
@@ -13,8 +13,6 @@
 // limitations under the License.
 
 #![feature(assert_matches)]
-#![feature(btree_extract_if)]
-#![feature(let_chains)]
 #![feature(duration_millis_float)]
 
 pub mod cache;
diff --git a/src/common/meta/src/reconciliation/reconcile_table/reconcile_regions.rs b/src/common/meta/src/reconciliation/reconcile_table/reconcile_regions.rs
index 04202986e7..6ee3df70f3 100644
--- a/src/common/meta/src/reconciliation/reconcile_table/reconcile_regions.rs
+++ b/src/common/meta/src/reconciliation/reconcile_table/reconcile_regions.rs
@@ -71,7 +71,7 @@ impl State for ReconcileRegions {
             .column_metadatas
             .iter()
             .filter(|c| c.semantic_type == SemanticType::Tag)
-            .map(|c| c.column_schema.name.to_string())
+            .map(|c| c.column_schema.name.clone())
             .collect::<HashSet<_>>();
         let column_defs = self
             .column_metadatas
diff --git a/src/common/meta/src/rpc/ddl.rs b/src/common/meta/src/rpc/ddl.rs
index d23c943c77..9f0d69442a 100644
--- a/src/common/meta/src/rpc/ddl.rs
+++ b/src/common/meta/src/rpc/ddl.rs
@@ -383,7 +383,7 @@ pub struct CreateViewTask {
 
 impl CreateViewTask {
     /// Returns the [`TableReference`] of view.
-    pub fn table_ref(&self) -> TableReference {
+    pub fn table_ref(&self) -> TableReference<'_> {
         TableReference {
             catalog: &self.create_view.catalog_name,
             schema: &self.create_view.schema_name,
@@ -496,7 +496,7 @@ pub struct DropViewTask {
 
 impl DropViewTask {
     /// Returns the [`TableReference`] of view.
-    pub fn table_ref(&self) -> TableReference {
+    pub fn table_ref(&self) -> TableReference<'_> {
         TableReference {
             catalog: &self.catalog,
             schema: &self.schema,
@@ -553,7 +553,7 @@ pub struct DropTableTask {
 }
 
 impl DropTableTask {
-    pub fn table_ref(&self) -> TableReference {
+    pub fn table_ref(&self) -> TableReference<'_> {
         TableReference {
             catalog: &self.catalog,
             schema: &self.schema,
@@ -563,9 +563,9 @@ impl DropTableTask {
 
     pub fn table_name(&self) -> TableName {
         TableName {
-            catalog_name: self.catalog.to_string(),
-            schema_name: self.schema.to_string(),
-            table_name: self.table.to_string(),
+            catalog_name: self.catalog.clone(),
+            schema_name: self.schema.clone(),
+            table_name: self.table.clone(),
         }
     }
 }
@@ -659,13 +659,13 @@ impl CreateTableTask {
         let table = &self.create_table;
 
         TableName {
-            catalog_name: table.catalog_name.to_string(),
-            schema_name: table.schema_name.to_string(),
-            table_name: table.table_name.to_string(),
+            catalog_name: table.catalog_name.clone(),
+            schema_name: table.schema_name.clone(),
+            table_name: table.table_name.clone(),
         }
     }
 
-    pub fn table_ref(&self) -> TableReference {
+    pub fn table_ref(&self) -> TableReference<'_> {
         let table = &self.create_table;
 
         TableReference {
@@ -750,7 +750,7 @@ impl AlterTableTask {
         Ok(())
     }
 
-    pub fn table_ref(&self) -> TableReference {
+    pub fn table_ref(&self) -> TableReference<'_> {
         TableReference {
             catalog: &self.alter_table.catalog_name,
             schema: &self.alter_table.schema_name,
@@ -762,9 +762,9 @@ impl AlterTableTask {
         let table = &self.alter_table;
 
         TableName {
-            catalog_name: table.catalog_name.to_string(),
-            schema_name: table.schema_name.to_string(),
-            table_name: table.table_name.to_string(),
+            catalog_name: table.catalog_name.clone(),
+            schema_name: table.schema_name.clone(),
+            table_name: table.table_name.clone(),
         }
     }
 }
@@ -834,7 +834,7 @@ pub struct TruncateTableTask {
 }
 
 impl TruncateTableTask {
-    pub fn table_ref(&self) -> TableReference {
+    pub fn table_ref(&self) -> TableReference<'_> {
         TableReference {
             catalog: &self.catalog,
             schema: &self.schema,
@@ -844,9 +844,9 @@ impl TruncateTableTask {
 
     pub fn table_name(&self) -> TableName {
         TableName {
-            catalog_name: self.catalog.to_string(),
-            schema_name: self.schema.to_string(),
-            table_name: self.table.to_string(),
+            catalog_name: self.catalog.clone(),
+            schema_name: self.schema.clone(),
+            table_name: self.table.clone(),
         }
     }
 }
@@ -1344,7 +1344,7 @@ impl From<QueryContextRef> for QueryContext {
     fn from(query_context: QueryContextRef) -> Self {
         QueryContext {
             current_catalog: query_context.current_catalog().to_string(),
-            current_schema: query_context.current_schema().to_string(),
+            current_schema: query_context.current_schema().clone(),
             timezone: query_context.timezone().to_string(),
             extensions: query_context.extensions(),
             channel: query_context.channel() as u8,
@@ -1401,7 +1401,7 @@ impl From<QueryContextRef> for FlowQueryContext {
     fn from(ctx: QueryContextRef) -> Self {
         Self {
             catalog: ctx.current_catalog().to_string(),
-            schema: ctx.current_schema().to_string(),
+            schema: ctx.current_schema().clone(),
             timezone: ctx.timezone().to_string(),
         }
     }
diff --git a/src/common/meta/src/rpc/procedure.rs b/src/common/meta/src/rpc/procedure.rs
index be41071b54..313b7e178e 100644
--- a/src/common/meta/src/rpc/procedure.rs
+++ b/src/common/meta/src/rpc/procedure.rs
@@ -128,7 +128,7 @@ pub fn procedure_details_to_pb_response(metas: Vec<ProcedureInfo>) -> PbProcedur
             let (status, error) = procedure_state_to_pb_state(&meta.state);
             PbProcedureMeta {
                 id: Some(pid_to_pb_pid(meta.id)),
-                type_name: meta.type_name.to_string(),
+                type_name: meta.type_name.clone(),
                 status: status.into(),
                 start_time_ms: meta.start_time_ms,
                 end_time_ms: meta.end_time_ms,
diff --git a/src/common/meta/src/state_store.rs b/src/common/meta/src/state_store.rs
index 5421972f3a..0ecbd5a8e4 100644
--- a/src/common/meta/src/state_store.rs
+++ b/src/common/meta/src/state_store.rs
@@ -121,7 +121,7 @@ impl StateStore for KvStateStore {
                 self.kv_backend
                     .put(
                         PutRequest::new()
-                            .with_key(key.to_string().into_bytes())
+                            .with_key(key.clone().into_bytes())
                             .with_value(value),
                     )
                     .await
@@ -145,7 +145,7 @@ impl StateStore for KvStateStore {
                         let key = if idx > 0 {
                             KeySet::with_segment_suffix(&key, idx)
                         } else {
-                            key.to_string()
+                            key.clone()
                         };
                         let kv_backend = self.kv_backend.clone();
                         async move {
diff --git a/src/common/meta/src/stats/topic.rs b/src/common/meta/src/stats/topic.rs
index 7855b801ec..b5a89cb356 100644
--- a/src/common/meta/src/stats/topic.rs
+++ b/src/common/meta/src/stats/topic.rs
@@ -169,7 +169,7 @@ impl ActiveBucket {
             }
         } else {
             datanode_stats.insert(
-                stat.topic.to_string(),
+                stat.topic.clone(),
                 PartialTopicStat {
                     latest_entry_id: stat.latest_entry_id,
                     record_size: stat.record_size,
@@ -205,7 +205,7 @@ impl ActiveBucket {
             let record_num = stats.iter().map(|stat| stat.record_num).sum::<u64>();
 
             output.insert(
-                topic.to_string(),
+                topic.clone(),
                 HistoryTopicStat {
                     latest_entry_id,
                     record_size,
diff --git a/src/common/meta/src/wal_options_allocator/topic_creator.rs b/src/common/meta/src/wal_options_allocator/topic_creator.rs
index 5b6d5870ef..8ba5b9ec59 100644
--- a/src/common/meta/src/wal_options_allocator/topic_creator.rs
+++ b/src/common/meta/src/wal_options_allocator/topic_creator.rs
@@ -104,8 +104,8 @@ impl KafkaTopicCreator {
         let end_offset = partition_client
             .get_offset(OffsetAt::Latest)
             .await
-            .context(KafkaGetOffsetSnafu {
-                topic: topic.to_string(),
+            .with_context(|_| KafkaGetOffsetSnafu {
+                topic: topic.clone(),
                 partition: DEFAULT_PARTITION,
             })?;
         if end_offset > 0 {
@@ -284,9 +284,11 @@ mod tests {
         let creator = test_topic_creator(get_kafka_endpoints()).await;
 
         let topic = format!("{}{}", prefix, "0");
+        let topics = std::slice::from_ref(&topic);
+
         // Clean up the topics before test
-        creator.delete_topics(&[topic.to_string()]).await.unwrap();
-        creator.create_topics(&[topic.to_string()]).await.unwrap();
+        creator.delete_topics(topics).await.unwrap();
+        creator.create_topics(topics).await.unwrap();
 
         let partition_client = creator.partition_client(&topic).await.unwrap();
         let end_offset = partition_client.get_offset(OffsetAt::Latest).await.unwrap();
@@ -309,10 +311,12 @@ mod tests {
         let creator = test_topic_creator(get_kafka_endpoints()).await;
 
         let topic = format!("{}{}", prefix, "0");
-        // Clean up the topics before test
-        creator.delete_topics(&[topic.to_string()]).await.unwrap();
+        let topics = std::slice::from_ref(&topic);
 
-        creator.create_topics(&[topic.to_string()]).await.unwrap();
+        // Clean up the topics before test
+        creator.delete_topics(topics).await.unwrap();
+
+        creator.create_topics(topics).await.unwrap();
         let partition_client = creator.partition_client(&topic).await.unwrap();
         append_records(&partition_client, 2).await.unwrap();
 
@@ -336,12 +340,14 @@ mod tests {
         let creator = test_topic_creator(get_kafka_endpoints()).await;
 
         let topic = format!("{}{}", prefix, "0");
-        // Clean up the topics before test
-        creator.delete_topics(&[topic.to_string()]).await.unwrap();
+        let topics = std::slice::from_ref(&topic);
 
-        creator.create_topics(&[topic.to_string()]).await.unwrap();
+        // Clean up the topics before test
+        creator.delete_topics(topics).await.unwrap();
+
+        creator.create_topics(topics).await.unwrap();
         // Should be ok
-        creator.create_topics(&[topic.to_string()]).await.unwrap();
+        creator.create_topics(topics).await.unwrap();
 
         let partition_client = creator.partition_client(&topic).await.unwrap();
         let end_offset = partition_client.get_offset(OffsetAt::Latest).await.unwrap();
@@ -356,10 +362,12 @@ mod tests {
         let creator = test_topic_creator(get_kafka_endpoints()).await;
 
         let topic = format!("{}{}", prefix, "0");
-        // Clean up the topics before test
-        creator.delete_topics(&[topic.to_string()]).await.unwrap();
+        let topics = std::slice::from_ref(&topic);
 
-        creator.create_topics(&[topic.to_string()]).await.unwrap();
+        // Clean up the topics before test
+        creator.delete_topics(topics).await.unwrap();
+
+        creator.create_topics(topics).await.unwrap();
         creator.prepare_topic(&topic).await.unwrap();
 
         let partition_client = creator.partition_client(&topic).await.unwrap();
@@ -382,10 +390,12 @@ mod tests {
         let creator = test_topic_creator(get_kafka_endpoints()).await;
 
         let topic = format!("{}{}", prefix, "0");
-        // Clean up the topics before test
-        creator.delete_topics(&[topic.to_string()]).await.unwrap();
+        let topics = std::slice::from_ref(&topic);
 
-        creator.create_topics(&[topic.to_string()]).await.unwrap();
+        // Clean up the topics before test
+        creator.delete_topics(topics).await.unwrap();
+
+        creator.create_topics(topics).await.unwrap();
         let partition_client = creator.partition_client(&topic).await.unwrap();
         append_records(&partition_client, 10).await.unwrap();
 
diff --git a/src/common/meta/src/wal_options_allocator/topic_manager.rs b/src/common/meta/src/wal_options_allocator/topic_manager.rs
index 072298d0b2..c0e82b1351 100644
--- a/src/common/meta/src/wal_options_allocator/topic_manager.rs
+++ b/src/common/meta/src/wal_options_allocator/topic_manager.rs
@@ -47,7 +47,7 @@ impl KafkaTopicManager {
         let mut topics_to_create = Vec::with_capacity(all_topics.len());
         for topic in all_topics {
             if !existing_topic_set.contains(topic) {
-                topics_to_create.push(topic.to_string());
+                topics_to_create.push(topic.clone());
             }
         }
         Ok(topics_to_create)
diff --git a/src/common/procedure/src/local.rs b/src/common/procedure/src/local.rs
index 8aeb5a359b..72445858ac 100644
--- a/src/common/procedure/src/local.rs
+++ b/src/common/procedure/src/local.rs
@@ -195,18 +195,18 @@ pub async fn acquire_dynamic_key_lock(
 ) -> DynamicKeyLockGuard {
     match key {
         StringKey::Share(key) => {
-            let guard = lock.read(key.to_string()).await;
+            let guard = lock.read(key.clone()).await;
             DynamicKeyLockGuard {
                 guard: Some(OwnedKeyRwLockGuard::from(guard)),
-                key: key.to_string(),
+                key: key.clone(),
                 lock: lock.clone(),
             }
         }
         StringKey::Exclusive(key) => {
-            let guard = lock.write(key.to_string()).await;
+            let guard = lock.write(key.clone()).await;
             DynamicKeyLockGuard {
                 guard: Some(OwnedKeyRwLockGuard::from(guard)),
-                key: key.to_string(),
+                key: key.clone(),
                 lock: lock.clone(),
             }
         }
@@ -227,7 +227,7 @@ impl Drop for DynamicKeyLockGuard {
         if let Some(guard) = self.guard.take() {
             drop(guard);
         }
-        self.lock.clean_keys(&[self.key.to_string()]);
+        self.lock.clean_keys(std::slice::from_ref(&self.key));
     }
 }
 
diff --git a/src/common/procedure/src/local/runner.rs b/src/common/procedure/src/local/runner.rs
index 59f5e2cca2..9135bee9b4 100644
--- a/src/common/procedure/src/local/runner.rs
+++ b/src/common/procedure/src/local/runner.rs
@@ -1616,7 +1616,7 @@ mod tests {
             .unwrap();
 
         // If the procedure is poisoned, the poison key shouldn't be deleted.
-        assert_eq!(&procedure_id.to_string(), ROOT_ID);
+        assert_eq!(&procedure_id.clone(), ROOT_ID);
     }
 
     #[tokio::test]
diff --git a/src/common/procedure/src/store.rs b/src/common/procedure/src/store.rs
index fcbaf0ae47..906682ed6e 100644
--- a/src/common/procedure/src/store.rs
+++ b/src/common/procedure/src/store.rs
@@ -37,6 +37,7 @@ macro_rules! proc_path {
     ($store: expr, $fmt:expr, $($args:tt)*) => { format!("{}{}", $store.proc_path(), format_args!($fmt, $($args)*)) };
 }
 
+#[cfg(test)]
 pub(crate) use proc_path;
 
 /// Serialized data of a procedure.
@@ -579,13 +580,7 @@ mod tests {
         let type_name = procedure.type_name().to_string();
         let data = procedure.dump().unwrap();
         store
-            .store_procedure(
-                procedure_id,
-                0,
-                type_name.to_string(),
-                data.to_string(),
-                None,
-            )
+            .store_procedure(procedure_id, 0, type_name.clone(), data.clone(), None)
             .await
             .unwrap();
         let message = ProcedureMessage {
diff --git a/src/common/procedure/src/store/state_store.rs b/src/common/procedure/src/store/state_store.rs
index d98ce06a1e..f4785becb2 100644
--- a/src/common/procedure/src/store/state_store.rs
+++ b/src/common/procedure/src/store/state_store.rs
@@ -68,7 +68,7 @@ impl KeySet {
 
     pub fn keys(&self) -> Vec<String> {
         let mut keys = Vec::with_capacity(self.segments + 1);
-        keys.push(self.key.to_string());
+        keys.push(self.key.clone());
         for i in 1..=self.segments {
             keys.push(Self::with_segment_suffix(&self.key, i))
         }
diff --git a/src/common/procedure/src/test_util.rs b/src/common/procedure/src/test_util.rs
index 083736a45c..39085a1f4f 100644
--- a/src/common/procedure/src/test_util.rs
+++ b/src/common/procedure/src/test_util.rs
@@ -41,7 +41,7 @@ impl PoisonStore for InMemoryPoisonStore {
         let mut map = self.map.write().unwrap();
         match map.entry(key) {
             Entry::Vacant(v) => {
-                v.insert(token.to_string());
+                v.insert(token.clone());
             }
             Entry::Occupied(o) => {
                 let value = o.get();
diff --git a/src/common/query/src/lib.rs b/src/common/query/src/lib.rs
index e528bd9d33..77ecec8eed 100644
--- a/src/common/query/src/lib.rs
+++ b/src/common/query/src/lib.rs
@@ -145,7 +145,7 @@ impl From<&AddColumnLocation> for Location {
             },
             AddColumnLocation::After { column_name } => Location {
                 location_type: LocationType::After.into(),
-                after_column_name: column_name.to_string(),
+                after_column_name: column_name.clone(),
             },
         }
     }
diff --git a/src/common/recordbatch/src/lib.rs b/src/common/recordbatch/src/lib.rs
index 1e50d76506..c008a9312e 100644
--- a/src/common/recordbatch/src/lib.rs
+++ b/src/common/recordbatch/src/lib.rs
@@ -137,7 +137,7 @@ pub fn map_json_type_to_string_schema(schema: SchemaRef) -> (SchemaRef, bool) {
     for column in schema.column_schemas() {
         if matches!(column.data_type, ConcreteDataType::Json(_)) {
             new_columns.push(ColumnSchema::new(
-                column.name.to_string(),
+                column.name.clone(),
                 ConcreteDataType::string_datatype(),
                 column.is_nullable(),
             ));
diff --git a/src/common/sql/src/convert.rs b/src/common/sql/src/convert.rs
index a9aba95fac..690788feef 100644
--- a/src/common/sql/src/convert.rs
+++ b/src/common/sql/src/convert.rs
@@ -220,7 +220,7 @@ pub fn sql_value_to_value(
                 _ => return InvalidUnaryOpSnafu { unary_op, value }.fail(),
             },
 
-            Value::String(_) | Value::Binary(_) | Value::List(_) => {
+            Value::String(_) | Value::Binary(_) | Value::List(_) | Value::Struct(_) => {
                 return InvalidUnaryOpSnafu { unary_op, value }.fail();
             }
         }
diff --git a/src/common/substrait/src/lib.rs b/src/common/substrait/src/lib.rs
index f5f4586939..a168d9c119 100644
--- a/src/common/substrait/src/lib.rs
+++ b/src/common/substrait/src/lib.rs
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(let_chains)]
-
 mod df_substrait;
 pub mod error;
 pub mod extension_serializer;
diff --git a/src/common/telemetry/src/lib.rs b/src/common/telemetry/src/lib.rs
index 0e1f9fa94a..ba46bfa0d9 100644
--- a/src/common/telemetry/src/lib.rs
+++ b/src/common/telemetry/src/lib.rs
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(let_chains)]
 #![feature(duration_constructors)]
 
 pub mod logging;
diff --git a/src/common/telemetry/src/logging.rs b/src/common/telemetry/src/logging.rs
index 3260d79097..d2b8a64b39 100644
--- a/src/common/telemetry/src/logging.rs
+++ b/src/common/telemetry/src/logging.rs
@@ -454,7 +454,7 @@ fn build_otlp_exporter(opts: &LoggingOptions) -> SpanExporter {
         .as_ref()
         .map(|e| {
             if e.starts_with("http") {
-                e.to_string()
+                e.clone()
             } else {
                 format!("http://{}", e)
             }
diff --git a/src/common/time/src/timestamp.rs b/src/common/time/src/timestamp.rs
index f94543f493..120dc8e1e9 100644
--- a/src/common/time/src/timestamp.rs
+++ b/src/common/time/src/timestamp.rs
@@ -308,12 +308,12 @@ impl Timestamp {
     fn from_splits(sec: i64, nsec: u32) -> Option<Self> {
         if nsec == 0 {
             Some(Timestamp::new_second(sec))
-        } else if nsec % 1_000_000 == 0 {
+        } else if nsec.is_multiple_of(1_000_000) {
             let millis = nsec / 1_000_000;
             sec.checked_mul(1000)
                 .and_then(|v| v.checked_add(millis as i64))
                 .map(Timestamp::new_millisecond)
-        } else if nsec % 1000 == 0 {
+        } else if nsec.is_multiple_of(1_000) {
             let micros = nsec / 1000;
             sec.checked_mul(1_000_000)
                 .and_then(|v| v.checked_add(micros as i64))
diff --git a/src/common/wal/src/lib.rs b/src/common/wal/src/lib.rs
index 49b16ea598..659a045f57 100644
--- a/src/common/wal/src/lib.rs
+++ b/src/common/wal/src/lib.rs
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 #![feature(assert_matches)]
-#![feature(duration_constructors_lite)]
 
 use std::net::SocketAddr;
 
diff --git a/src/datanode/src/lib.rs b/src/datanode/src/lib.rs
index 8ca9a27c91..55d2b1796d 100644
--- a/src/datanode/src/lib.rs
+++ b/src/datanode/src/lib.rs
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 #![feature(assert_matches)]
-#![feature(let_chains)]
 
 pub mod alive_keeper;
 pub mod config;
diff --git a/src/datanode/src/region_server.rs b/src/datanode/src/region_server.rs
index b7a2087ef5..75a28fec45 100644
--- a/src/datanode/src/region_server.rs
+++ b/src/datanode/src/region_server.rs
@@ -706,7 +706,7 @@ impl RegionServerParallelism {
         })
     }
 
-    pub async fn acquire(&self) -> Result<SemaphorePermit> {
+    pub async fn acquire(&self) -> Result<SemaphorePermit<'_>> {
         timeout(self.timeout, self.semaphore.acquire())
             .await
             .context(ConcurrentQueryLimiterTimeoutSnafu)?
@@ -919,8 +919,7 @@ impl RegionServerInner {
             if let Some(requests) = engine_grouped_requests.get_mut(&request.engine) {
                 requests.push((region_id, request));
             } else {
-                engine_grouped_requests
-                    .insert(request.engine.to_string(), vec![(region_id, request)]);
+                engine_grouped_requests.insert(request.engine.clone(), vec![(region_id, request)]);
             }
         }
 
diff --git a/src/datatypes/src/data_type.rs b/src/datatypes/src/data_type.rs
index fb03869e41..8b97399284 100644
--- a/src/datatypes/src/data_type.rs
+++ b/src/datatypes/src/data_type.rs
@@ -285,6 +285,13 @@ impl ConcreteDataType {
         }
     }
 
+    pub fn as_struct(&self) -> Option<&StructType> {
+        match self {
+            ConcreteDataType::Struct(s) => Some(s),
+            _ => None,
+        }
+    }
+
     /// Try to cast data type as a [`TimestampType`].
     pub fn as_timestamp(&self) -> Option<TimestampType> {
         match self {
diff --git a/src/datatypes/src/error.rs b/src/datatypes/src/error.rs
index 565daae4cf..85e78ce1eb 100644
--- a/src/datatypes/src/error.rs
+++ b/src/datatypes/src/error.rs
@@ -220,6 +220,14 @@ pub enum Error {
         location: Location,
     },
 
+    #[snafu(display("Failed to convert scalar value to Arrow array"))]
+    ConvertScalarToArrowArray {
+        #[snafu(source)]
+        error: datafusion_common::DataFusionError,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
     #[snafu(display("Failed to parse extended type in metadata: {}", value))]
     ParseExtendedType {
         value: String,
@@ -238,6 +246,13 @@ pub enum Error {
         #[snafu(implicit)]
         location: Location,
     },
+    #[snafu(display("Inconsistent struct field count {field_len} and item count {item_len}"))]
+    InconsistentStructFieldsAndItems {
+        field_len: usize,
+        item_len: usize,
+        #[snafu(implicit)]
+        location: Location,
+    },
     #[snafu(display("Failed to process JSONB value"))]
     InvalidJsonb {
         error: jsonb::Error,
@@ -282,7 +297,9 @@ impl ErrorExt for Error {
             | ToScalarValue { .. }
             | TryFromValue { .. }
             | ConvertArrowArrayToScalars { .. }
-            | ParseExtendedType { .. } => StatusCode::Internal,
+            | ConvertScalarToArrowArray { .. }
+            | ParseExtendedType { .. }
+            | InconsistentStructFieldsAndItems { .. } => StatusCode::Internal,
         }
     }
 
diff --git a/src/datatypes/src/lib.rs b/src/datatypes/src/lib.rs
index 0b2588c753..6ad27fc656 100644
--- a/src/datatypes/src/lib.rs
+++ b/src/datatypes/src/lib.rs
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(let_chains)]
 #![feature(assert_matches)]
 
 pub mod arrow_array;
diff --git a/src/datatypes/src/scalars.rs b/src/datatypes/src/scalars.rs
index 389888a9dd..2032f6bc56 100644
--- a/src/datatypes/src/scalars.rs
+++ b/src/datatypes/src/scalars.rs
@@ -21,10 +21,10 @@ use crate::types::{
     Float32Type, Float64Type, Int8Type, Int16Type, Int32Type, Int64Type, UInt8Type, UInt16Type,
     UInt32Type, UInt64Type,
 };
-use crate::value::{ListValue, ListValueRef, Value};
+use crate::value::{ListValue, ListValueRef, StructValue, StructValueRef, Value};
 use crate::vectors::{
     BinaryVector, BooleanVector, DateVector, Decimal128Vector, ListVector, MutableVector,
-    PrimitiveVector, StringVector, Vector,
+    NullVector, PrimitiveVector, StringVector, StructVector, Vector,
 };
 
 fn get_iter_capacity<T, I: Iterator<Item = T>>(iter: &I) -> usize {
@@ -52,7 +52,7 @@ where
     fn upcast_gat<'short, 'long: 'short>(long: Self::RefType<'long>) -> Self::RefType<'short>;
 }
 
-pub trait ScalarRef<'a>: std::fmt::Debug + Clone + Copy + Send + 'a {
+pub trait ScalarRef<'a>: std::fmt::Debug + Clone + Send + 'a {
     /// The corresponding [`Scalar`] type.
     type ScalarType: Scalar<RefType<'a> = Self>;
 
@@ -95,7 +95,7 @@ where
     fn from_slice(data: &[Self::RefItem<'_>]) -> Self {
         let mut builder = Self::Builder::with_capacity(data.len());
         for item in data {
-            builder.push(Some(*item));
+            builder.push(Some(item.clone()));
         }
         builder.finish()
     }
@@ -152,13 +152,11 @@ macro_rules! impl_scalar_for_native {
             type VectorType = PrimitiveVector<$DataType>;
             type RefType<'a> = $Native;
 
-            #[inline]
             fn as_scalar_ref(&self) -> $Native {
                 *self
             }
 
             #[allow(clippy::needless_lifetimes)]
-            #[inline]
             fn upcast_gat<'short, 'long: 'short>(long: $Native) -> $Native {
                 long
             }
@@ -168,7 +166,6 @@ macro_rules! impl_scalar_for_native {
         impl<'a> ScalarRef<'a> for $Native {
             type ScalarType = $Native;
 
-            #[inline]
             fn to_owned_scalar(&self) -> $Native {
                 *self
             }
@@ -187,17 +184,33 @@ impl_scalar_for_native!(i64, Int64Type);
 impl_scalar_for_native!(f32, Float32Type);
 impl_scalar_for_native!(f64, Float64Type);
 
+impl Scalar for () {
+    type VectorType = NullVector;
+    type RefType<'a> = ();
+
+    fn as_scalar_ref(&self) {}
+
+    #[allow(clippy::needless_lifetimes)]
+    fn upcast_gat<'short, 'long: 'short>(long: ()) {
+        long
+    }
+}
+
+impl ScalarRef<'_> for () {
+    type ScalarType = ();
+
+    fn to_owned_scalar(&self) {}
+}
+
 impl Scalar for bool {
     type VectorType = BooleanVector;
     type RefType<'a> = bool;
 
-    #[inline]
     fn as_scalar_ref(&self) -> bool {
         *self
     }
 
     #[allow(clippy::needless_lifetimes)]
-    #[inline]
     fn upcast_gat<'short, 'long: 'short>(long: bool) -> bool {
         long
     }
@@ -206,7 +219,6 @@ impl Scalar for bool {
 impl ScalarRef<'_> for bool {
     type ScalarType = bool;
 
-    #[inline]
     fn to_owned_scalar(&self) -> bool {
         *self
     }
@@ -216,12 +228,10 @@ impl Scalar for String {
     type VectorType = StringVector;
     type RefType<'a> = &'a str;
 
-    #[inline]
     fn as_scalar_ref(&self) -> &str {
         self
     }
 
-    #[inline]
     fn upcast_gat<'short, 'long: 'short>(long: &'long str) -> &'short str {
         long
     }
@@ -230,7 +240,6 @@ impl Scalar for String {
 impl<'a> ScalarRef<'a> for &'a str {
     type ScalarType = String;
 
-    #[inline]
     fn to_owned_scalar(&self) -> String {
         self.to_string()
     }
@@ -240,12 +249,10 @@ impl Scalar for Vec<u8> {
     type VectorType = BinaryVector;
     type RefType<'a> = &'a [u8];
 
-    #[inline]
     fn as_scalar_ref(&self) -> &[u8] {
         self
     }
 
-    #[inline]
     fn upcast_gat<'short, 'long: 'short>(long: &'long [u8]) -> &'short [u8] {
         long
     }
@@ -254,7 +261,6 @@ impl Scalar for Vec<u8> {
 impl<'a> ScalarRef<'a> for &'a [u8] {
     type ScalarType = Vec<u8>;
 
-    #[inline]
     fn to_owned_scalar(&self) -> Vec<u8> {
         self.to_vec()
     }
@@ -332,6 +338,42 @@ impl<'a> ScalarRef<'a> for ListValueRef<'a> {
                 _ => unreachable!(),
             },
             ListValueRef::Ref { val } => (*val).clone(),
+            ListValueRef::RefList { val, item_datatype } => ListValue::new(
+                val.iter().map(|v| Value::from(v.clone())).collect(),
+                item_datatype.clone(),
+            ),
+        }
+    }
+}
+
+impl Scalar for StructValue {
+    type VectorType = StructVector;
+    type RefType<'a> = StructValueRef<'a>;
+
+    fn as_scalar_ref(&self) -> Self::RefType<'_> {
+        StructValueRef::Ref(self)
+    }
+
+    fn upcast_gat<'short, 'long: 'short>(long: Self::RefType<'long>) -> Self::RefType<'short> {
+        long
+    }
+}
+
+impl<'a> ScalarRef<'a> for StructValueRef<'a> {
+    type ScalarType = StructValue;
+
+    fn to_owned_scalar(&self) -> Self::ScalarType {
+        match self {
+            Self::Indexed { vector, idx } => match vector.get(*idx) {
+                Value::Null => StructValue::default(),
+                Value::Struct(v) => v,
+                _ => unreachable!(),
+            },
+            StructValueRef::Ref(val) => (*val).clone(),
+            StructValueRef::RefList { val, fields } => {
+                let items = val.iter().map(|v| Value::from(v.clone())).collect();
+                StructValue::try_new(items, fields.clone()).unwrap()
+            }
         }
     }
 }
@@ -346,7 +388,7 @@ mod tests {
     fn build_vector_from_slice<T: ScalarVector>(items: &[Option<T::RefItem<'_>>]) -> T {
         let mut builder = T::Builder::with_capacity(items.len());
         for item in items {
-            builder.push(*item);
+            builder.push(item.clone());
         }
         builder.finish()
     }
diff --git a/src/datatypes/src/schema.rs b/src/datatypes/src/schema.rs
index 87dd788b91..8a79b3c02e 100644
--- a/src/datatypes/src/schema.rs
+++ b/src/datatypes/src/schema.rs
@@ -329,7 +329,7 @@ impl TryFrom<Arc<ArrowSchema>> for Schema {
         let mut name_to_index = HashMap::with_capacity(arrow_schema.fields.len());
         for field in &arrow_schema.fields {
             let column_schema = ColumnSchema::try_from(field.as_ref())?;
-            let _ = name_to_index.insert(field.name().to_string(), column_schemas.len());
+            let _ = name_to_index.insert(field.name().clone(), column_schemas.len());
             column_schemas.push(column_schema);
         }
 
diff --git a/src/datatypes/src/schema/column_schema.rs b/src/datatypes/src/schema/column_schema.rs
index 24ab30b61b..f176350b8c 100644
--- a/src/datatypes/src/schema/column_schema.rs
+++ b/src/datatypes/src/schema/column_schema.rs
@@ -296,7 +296,7 @@ impl ColumnSchema {
         let value_ref = padding_value.as_value_ref();
         let mut mutable_vector = self.data_type.create_mutable_vector(num_rows);
         for _ in 0..num_rows {
-            mutable_vector.push_value_ref(value_ref);
+            mutable_vector.push_value_ref(&value_ref);
         }
         mutable_vector.to_vector()
     }
diff --git a/src/datatypes/src/schema/constraint.rs b/src/datatypes/src/schema/constraint.rs
index 01928dc3b5..60025be68e 100644
--- a/src/datatypes/src/schema/constraint.rs
+++ b/src/datatypes/src/schema/constraint.rs
@@ -157,7 +157,7 @@ impl ColumnDefaultConstraint {
                 //  attempt to downcast the vector fail if they don't check whether the vector is const
                 //  first.
                 let mut mutable_vector = data_type.create_mutable_vector(1);
-                mutable_vector.try_push_value_ref(v.as_value_ref())?;
+                mutable_vector.try_push_value_ref(&v.as_value_ref())?;
                 let base_vector = mutable_vector.to_vector();
                 Ok(base_vector.replicate(&[num_rows]))
             }
diff --git a/src/datatypes/src/types/date_type.rs b/src/datatypes/src/types/date_type.rs
index a78da1d65b..a34bc6069b 100644
--- a/src/datatypes/src/types/date_type.rs
+++ b/src/datatypes/src/types/date_type.rs
@@ -83,10 +83,10 @@ impl LogicalPrimitiveType for DateType {
             })
     }
 
-    fn cast_value_ref(value: ValueRef) -> Result<Option<Date>> {
+    fn cast_value_ref(value: &ValueRef) -> Result<Option<Date>> {
         match value {
             ValueRef::Null => Ok(None),
-            ValueRef::Date(v) => Ok(Some(v)),
+            ValueRef::Date(v) => Ok(Some(*v)),
             other => error::CastTypeSnafu {
                 msg: format!("Failed to cast value {other:?} to Date"),
             }
diff --git a/src/datatypes/src/types/duration_type.rs b/src/datatypes/src/types/duration_type.rs
index e5e5c66be5..961be38182 100644
--- a/src/datatypes/src/types/duration_type.rs
+++ b/src/datatypes/src/types/duration_type.rs
@@ -133,11 +133,11 @@ macro_rules! impl_data_type_for_duration {
                         })
                 }
 
-                fn cast_value_ref(value: ValueRef) -> crate::Result<Option<Self::Wrapper>> {
+                fn cast_value_ref(value: &ValueRef) -> crate::Result<Option<Self::Wrapper>> {
                     match value {
                         ValueRef::Null => Ok(None),
                         ValueRef::Duration(t) => match t.unit() {
-                            TimeUnit::$unit => Ok(Some([<Duration $unit>](t))),
+                            TimeUnit::$unit => Ok(Some([<Duration $unit>](*t))),
                             other => error::CastTypeSnafu {
                                 msg: format!(
                                     "Failed to cast Duration value with different unit {:?} to {}",
diff --git a/src/datatypes/src/types/interval_type.rs b/src/datatypes/src/types/interval_type.rs
index e6b6544d0d..8687c714c6 100644
--- a/src/datatypes/src/types/interval_type.rs
+++ b/src/datatypes/src/types/interval_type.rs
@@ -123,10 +123,10 @@ macro_rules! impl_data_type_for_interval {
                         })
                 }
 
-                fn cast_value_ref(value: ValueRef) -> crate::Result<Option<Self::Wrapper>> {
+                fn cast_value_ref(value: &ValueRef) -> crate::Result<Option<Self::Wrapper>> {
                     match value {
                         ValueRef::Null => Ok(None),
-                        ValueRef::[<Interval $unit>](t) => Ok(Some(t)),
+                        ValueRef::[<Interval $unit>](t) => Ok(Some(*t)),
                         other => error::CastTypeSnafu {
                             msg: format!("Failed to cast value {:?} to {}", other, stringify!([<Interval $unit>])),
                         }
diff --git a/src/datatypes/src/types/json_type.rs b/src/datatypes/src/types/json_type.rs
index 0e600afe44..f36372d6df 100644
--- a/src/datatypes/src/types/json_type.rs
+++ b/src/datatypes/src/types/json_type.rs
@@ -28,17 +28,14 @@ use crate::vectors::{BinaryVectorBuilder, MutableVector};
 
 pub const JSON_TYPE_NAME: &str = "Json";
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize, Default,
+)]
 pub enum JsonFormat {
+    #[default]
     Jsonb,
 }
 
-impl Default for JsonFormat {
-    fn default() -> Self {
-        Self::Jsonb
-    }
-}
-
 /// JsonType is a data type for JSON data. It is stored as binary data of jsonb format.
 /// It utilizes current binary value and vector implementation.
 #[derive(
diff --git a/src/datatypes/src/types/list_type.rs b/src/datatypes/src/types/list_type.rs
index 91f4c8654f..acdb443c7e 100644
--- a/src/datatypes/src/types/list_type.rs
+++ b/src/datatypes/src/types/list_type.rs
@@ -65,7 +65,11 @@ impl DataType for ListType {
     }
 
     fn as_arrow_type(&self) -> ArrowDataType {
-        let field = Arc::new(Field::new("item", self.item_type.as_arrow_type(), true));
+        let field = Arc::new(Field::new(
+            Field::LIST_FIELD_DEFAULT_NAME,
+            self.item_type.as_arrow_type(),
+            true,
+        ));
         ArrowDataType::List(field)
     }
 
diff --git a/src/datatypes/src/types/primitive_type.rs b/src/datatypes/src/types/primitive_type.rs
index bcd228df35..b861b4c158 100644
--- a/src/datatypes/src/types/primitive_type.rs
+++ b/src/datatypes/src/types/primitive_type.rs
@@ -80,7 +80,7 @@ pub trait LogicalPrimitiveType: 'static + Sized {
     fn cast_vector(vector: &dyn Vector) -> Result<&PrimitiveVector<Self>>;
 
     /// Cast value ref to the primitive type.
-    fn cast_value_ref(value: ValueRef) -> Result<Option<Self::Wrapper>>;
+    fn cast_value_ref(value: &ValueRef) -> Result<Option<Self::Wrapper>>;
 }
 
 /// A new type for [WrapperType], complement the `Ord` feature for it.
@@ -194,10 +194,10 @@ macro_rules! define_logical_primitive_type {
                     })
             }
 
-            fn cast_value_ref(value: ValueRef) -> Result<Option<$Native>> {
+            fn cast_value_ref(value: &ValueRef) -> Result<Option<$Native>> {
                 match value {
                     ValueRef::Null => Ok(None),
-                    ValueRef::$TypeId(v) => Ok(Some(v.into())),
+                    ValueRef::$TypeId(v) => Ok(Some((*v).into())),
                     other => error::CastTypeSnafu {
                         msg: format!(
                             "Failed to cast value {:?} to primitive type {}",
diff --git a/src/datatypes/src/types/string_type.rs b/src/datatypes/src/types/string_type.rs
index 4cf0522b1f..fdca963707 100644
--- a/src/datatypes/src/types/string_type.rs
+++ b/src/datatypes/src/types/string_type.rs
@@ -89,8 +89,8 @@ impl DataType for StringType {
             Value::Duration(v) => Some(Value::String(StringBytes::from(v.to_string()))),
             Value::Decimal128(v) => Some(Value::String(StringBytes::from(v.to_string()))),
 
-            // StringBytes is only support for utf-8, Value::Binary is not allowed.
-            Value::Binary(_) | Value::List(_) => None,
+            // StringBytes is only support for utf-8, Value::Binary and collections are not allowed.
+            Value::Binary(_) | Value::List(_) | Value::Struct(_) => None,
         }
     }
 }
diff --git a/src/datatypes/src/types/struct_type.rs b/src/datatypes/src/types/struct_type.rs
index 2b59a0d603..4f7b758d55 100644
--- a/src/datatypes/src/types/struct_type.rs
+++ b/src/datatypes/src/types/struct_type.rs
@@ -18,6 +18,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::prelude::{ConcreteDataType, DataType, LogicalTypeId};
 use crate::value::Value;
+use crate::vectors::StructVectorBuilder;
 
 #[derive(Clone, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct StructType {
@@ -31,7 +32,7 @@ impl TryFrom<&Fields> for StructType {
             .iter()
             .map(|field| {
                 Ok(StructField::new(
-                    field.name().to_string(),
+                    field.name().clone(),
                     ConcreteDataType::try_from(field.data_type())?,
                     field.is_nullable(),
                 ))
@@ -68,16 +69,15 @@ impl DataType for StructType {
     }
 
     fn as_arrow_type(&self) -> ArrowDataType {
-        let fields = self
-            .fields
-            .iter()
-            .map(|f| Field::new(f.name.clone(), f.data_type.as_arrow_type(), f.nullable))
-            .collect();
+        let fields = self.as_arrow_fields();
         ArrowDataType::Struct(fields)
     }
 
-    fn create_mutable_vector(&self, _capacity: usize) -> Box<dyn crate::prelude::MutableVector> {
-        unimplemented!("What is the mutable vector for StructVector?");
+    fn create_mutable_vector(&self, capacity: usize) -> Box<dyn crate::prelude::MutableVector> {
+        Box::new(StructVectorBuilder::with_type_and_capacity(
+            self.clone(),
+            capacity,
+        ))
     }
 
     fn try_cast(&self, _from: Value) -> Option<Value> {
@@ -94,6 +94,13 @@ impl StructType {
     pub fn fields(&self) -> &[StructField] {
         &self.fields
     }
+
+    pub fn as_arrow_fields(&self) -> Fields {
+        self.fields
+            .iter()
+            .map(|f| Field::new(f.name.clone(), f.data_type.as_arrow_type(), f.nullable))
+            .collect()
+    }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
diff --git a/src/datatypes/src/types/time_type.rs b/src/datatypes/src/types/time_type.rs
index bb360f5a08..2f9408b472 100644
--- a/src/datatypes/src/types/time_type.rs
+++ b/src/datatypes/src/types/time_type.rs
@@ -149,14 +149,14 @@ macro_rules! impl_data_type_for_time {
                         })
                 }
 
-                fn cast_value_ref(value: ValueRef) -> crate::Result<Option<Self::Wrapper>> {
+                fn cast_value_ref(value: &ValueRef) -> crate::Result<Option<Self::Wrapper>> {
                     match value {
                         ValueRef::Null => Ok(None),
                         ValueRef::Int64(v) =>{
-                            Ok(Some([<Time $unit>]::from(v)))
+                            Ok(Some([<Time $unit>]::from(*v)))
                         }
                         ValueRef::Time(t) => match t.unit() {
-                            TimeUnit::$unit => Ok(Some([<Time $unit>](t))),
+                            TimeUnit::$unit => Ok(Some([<Time $unit>](*t))),
                             other => error::CastTypeSnafu {
                                 msg: format!(
                                     "Failed to cast Time value with different unit {:?} to {}",
diff --git a/src/datatypes/src/types/timestamp_type.rs b/src/datatypes/src/types/timestamp_type.rs
index 2c9adb8bc1..9d6dc2f68f 100644
--- a/src/datatypes/src/types/timestamp_type.rs
+++ b/src/datatypes/src/types/timestamp_type.rs
@@ -166,14 +166,14 @@ macro_rules! impl_data_type_for_timestamp {
                         })
                 }
 
-                fn cast_value_ref(value: ValueRef) -> crate::Result<Option<Self::Wrapper>> {
+                fn cast_value_ref(value: &ValueRef) -> crate::Result<Option<Self::Wrapper>> {
                     match value {
                         ValueRef::Null => Ok(None),
                         ValueRef::Int64(v) =>{
-                            Ok(Some([<Timestamp $unit>]::from(v)))
+                            Ok(Some([<Timestamp $unit>]::from(*v)))
                         }
                         ValueRef::Timestamp(t) => match t.unit() {
-                            TimeUnit::$unit => Ok(Some([<Timestamp $unit>](t))),
+                            TimeUnit::$unit => Ok(Some([<Timestamp $unit>](*t))),
                             other => error::CastTypeSnafu {
                                 msg: format!(
                                     "Failed to cast Timestamp value with different unit {:?} to {}",
diff --git a/src/datatypes/src/value.rs b/src/datatypes/src/value.rs
index d2eb41a015..d1eb6c09d3 100644
--- a/src/datatypes/src/value.rs
+++ b/src/datatypes/src/value.rs
@@ -16,8 +16,7 @@ use std::cmp::Ordering;
 use std::fmt::{Display, Formatter};
 use std::sync::Arc;
 
-use arrow::datatypes::{DataType as ArrowDataType, Field};
-use arrow_array::{Array, ListArray};
+use arrow_array::{Array, StructArray};
 use common_base::bytes::{Bytes, StringBytes};
 use common_decimal::Decimal128;
 use common_telemetry::error;
@@ -30,13 +29,17 @@ use datafusion_common::ScalarValue;
 use datafusion_common::scalar::ScalarStructBuilder;
 pub use ordered_float::OrderedFloat;
 use serde::{Deserialize, Serialize, Serializer};
+use serde_json::Map;
 use snafu::{ResultExt, ensure};
 
-use crate::error::{self, ConvertArrowArrayToScalarsSnafu, Error, Result, TryFromValueSnafu};
+use crate::error::{
+    self, ConvertArrowArrayToScalarsSnafu, ConvertScalarToArrowArraySnafu, Error,
+    InconsistentStructFieldsAndItemsSnafu, Result, TryFromValueSnafu,
+};
 use crate::prelude::*;
 use crate::type_id::LogicalTypeId;
-use crate::types::{IntervalType, ListType};
-use crate::vectors::ListVector;
+use crate::types::{IntervalType, ListType, StructType};
+use crate::vectors::{ListVector, StructVector};
 
 pub type OrderedF32 = OrderedFloat<f32>;
 pub type OrderedF64 = OrderedFloat<f64>;
@@ -79,6 +82,7 @@ pub enum Value {
     IntervalMonthDayNano(IntervalMonthDayNano),
 
     List(ListValue),
+    Struct(StructValue),
 }
 
 impl Display for Value {
@@ -128,6 +132,18 @@ impl Display for Value {
                 write!(f, "{}[{}]", v.datatype.name(), items)
             }
             Value::Decimal128(v) => write!(f, "{}", v),
+            Value::Struct(s) => {
+                let items = s
+                    .fields
+                    .fields()
+                    .iter()
+                    .map(|f| f.name())
+                    .zip(s.items().iter())
+                    .map(|(k, v)| format!("{k}: {v}"))
+                    .collect::<Vec<String>>()
+                    .join(", ");
+                write!(f, "{{ {items} }}")
+            }
         }
     }
 }
@@ -171,6 +187,9 @@ macro_rules! define_data_type_func {
                 $struct::Decimal128(d) => {
                     ConcreteDataType::decimal128_datatype(d.precision(), d.scale())
                 }
+                $struct::Struct(struct_value) => {
+                    ConcreteDataType::struct_datatype(struct_value.struct_type().clone())
+                }
             }
         }
     };
@@ -196,8 +215,19 @@ impl Value {
         }
     }
 
+    pub fn as_struct(&self) -> Result<Option<&StructValue>> {
+        match self {
+            Value::Null => Ok(None),
+            Value::Struct(v) => Ok(Some(v)),
+            other => error::CastTypeSnafu {
+                msg: format!("Failed to cast {other:?} to struct value"),
+            }
+            .fail(),
+        }
+    }
+
     /// Cast itself to [ValueRef].
-    pub fn as_value_ref(&self) -> ValueRef {
+    pub fn as_value_ref(&self) -> ValueRef<'_> {
         match self {
             Value::Null => ValueRef::Null,
             Value::Boolean(v) => ValueRef::Boolean(*v),
@@ -222,6 +252,7 @@ impl Value {
             Value::IntervalMonthDayNano(v) => ValueRef::IntervalMonthDayNano(*v),
             Value::Duration(v) => ValueRef::Duration(*v),
             Value::Decimal128(v) => ValueRef::Decimal128(*v),
+            Value::Struct(v) => ValueRef::Struct(StructValueRef::Ref(v)),
         }
     }
 
@@ -379,6 +410,7 @@ impl Value {
                 TimeUnit::Nanosecond => LogicalTypeId::DurationNanosecond,
             },
             Value::Decimal128(_) => LogicalTypeId::Decimal128,
+            Value::Struct(_) => LogicalTypeId::Struct,
         }
     }
 
@@ -431,6 +463,10 @@ impl Value {
                 let (v, p, s) = d.to_scalar_value();
                 ScalarValue::Decimal128(v, p, s)
             }
+            Value::Struct(struct_value) => {
+                let struct_type = output_type.as_struct().unwrap();
+                struct_value.try_to_scalar_value(struct_type)?
+            }
         };
 
         Ok(scalar_value)
@@ -483,7 +519,11 @@ impl Value {
             Value::IntervalDayTime(x) => Some(Value::IntervalDayTime(x.negative())),
             Value::IntervalMonthDayNano(x) => Some(Value::IntervalMonthDayNano(x.negative())),
 
-            Value::Binary(_) | Value::String(_) | Value::Boolean(_) | Value::List(_) => None,
+            Value::Binary(_)
+            | Value::String(_)
+            | Value::Boolean(_)
+            | Value::List(_)
+            | Value::Struct(_) => None,
         }
     }
 }
@@ -543,16 +583,11 @@ pub fn to_null_scalar_value(output_type: &ConcreteDataType) -> Result<ScalarValu
             IntervalType::DayTime(_) => ScalarValue::IntervalDayTime(None),
             IntervalType::MonthDayNano(_) => ScalarValue::IntervalMonthDayNano(None),
         },
-        ConcreteDataType::List(_) => ScalarValue::List(Arc::new(ListArray::new_null(
-            Arc::new(new_item_field(output_type.as_arrow_type())),
-            0,
-        ))),
+        ConcreteDataType::List(list_type) => {
+            ScalarValue::new_null_list(list_type.item_type().as_arrow_type(), true, 1)
+        }
         ConcreteDataType::Struct(fields) => {
-            let fields = fields
-                .fields()
-                .iter()
-                .map(|f| f.to_df_field())
-                .collect::<Vec<_>>();
+            let fields = fields.as_arrow_fields();
             ScalarStructBuilder::new_null(fields)
         }
         ConcreteDataType::Dictionary(dict) => ScalarValue::Dictionary(
@@ -565,10 +600,6 @@ pub fn to_null_scalar_value(output_type: &ConcreteDataType) -> Result<ScalarValu
     })
 }
 
-fn new_item_field(data_type: ArrowDataType) -> Field {
-    Field::new("item", data_type, false)
-}
-
 pub fn timestamp_to_scalar_value(unit: TimeUnit, val: Option<i64>) -> ScalarValue {
     match unit {
         TimeUnit::Second => ScalarValue::TimestampSecond(val, None),
@@ -819,7 +850,14 @@ 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::List(v) => serde_json::to_value(v)?,
+            Value::List(v) => {
+                let items = v
+                    .take_items()
+                    .into_iter()
+                    .map(serde_json::Value::try_from)
+                    .collect::<serde_json::Result<Vec<_>>>()?;
+                serde_json::Value::Array(items)
+            }
             Value::Timestamp(v) => serde_json::to_value(v.value())?,
             Value::Time(v) => serde_json::to_value(v.value())?,
             Value::IntervalYearMonth(v) => serde_json::to_value(v.to_i32())?,
@@ -827,6 +865,22 @@ impl TryFrom<Value> for serde_json::Value {
             Value::IntervalMonthDayNano(v) => serde_json::to_value(v.to_i128())?,
             Value::Duration(v) => serde_json::to_value(v.value())?,
             Value::Decimal128(v) => serde_json::to_value(v.to_string())?,
+            Value::Struct(v) => {
+                let map = v
+                    .fields
+                    .clone() // TODO:(sunng87) remove in next patch when into_parts is merged
+                    .fields()
+                    .iter()
+                    .zip(v.take_items().into_iter())
+                    .map(|(field, value)| {
+                        Ok((
+                            field.name().to_string(),
+                            serde_json::Value::try_from(value)?,
+                        ))
+                    })
+                    .collect::<serde_json::Result<Map<String, serde_json::Value>>>()?;
+                serde_json::Value::Object(map)
+            }
         };
 
         Ok(json_value)
@@ -854,6 +908,10 @@ impl ListValue {
         &self.items
     }
 
+    pub fn take_items(self) -> Vec<Value> {
+        self.items
+    }
+
     pub fn datatype(&self) -> &ConcreteDataType {
         &self.datatype
     }
@@ -903,6 +961,67 @@ impl Ord for ListValue {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct StructValue {
+    items: Vec<Value>,
+    fields: StructType,
+}
+
+impl StructValue {
+    pub fn try_new(items: Vec<Value>, fields: StructType) -> Result<Self> {
+        ensure!(
+            items.len() == fields.fields().len(),
+            InconsistentStructFieldsAndItemsSnafu {
+                field_len: fields.fields().len(),
+                item_len: items.len()
+            }
+        );
+        Ok(Self { items, fields })
+    }
+
+    pub fn items(&self) -> &[Value] {
+        &self.items
+    }
+
+    pub fn take_items(self) -> Vec<Value> {
+        self.items
+    }
+
+    pub fn struct_type(&self) -> &StructType {
+        &self.fields
+    }
+
+    fn estimated_size(&self) -> usize {
+        self.items
+            .iter()
+            .map(|x| x.as_value_ref().data_size())
+            .sum()
+    }
+
+    fn try_to_scalar_value(&self, output_type: &StructType) -> Result<ScalarValue> {
+        let arrays = self
+            .items
+            .iter()
+            .map(|value| {
+                let scalar_value = value.try_to_scalar_value(&value.data_type())?;
+                scalar_value
+                    .to_array()
+                    .context(ConvertScalarToArrowArraySnafu)
+            })
+            .collect::<Result<Vec<Arc<dyn Array>>>>()?;
+
+        let fields = output_type.as_arrow_fields();
+        let struct_array = StructArray::new(fields, arrays, None);
+        Ok(ScalarValue::Struct(Arc::new(struct_array)))
+    }
+}
+
+impl Default for StructValue {
+    fn default() -> StructValue {
+        StructValue::try_new(vec![], StructType::new(vec![])).unwrap()
+    }
+}
+
 // TODO(ruihang): Implement this type
 /// Dictionary value.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -938,7 +1057,8 @@ impl TryFrom<ScalarValue> for Value {
             | ScalarValue::LargeBinary(b)
             | ScalarValue::FixedSizeBinary(_, b) => Value::from(b.map(Bytes::from)),
             ScalarValue::List(array) => {
-                let datatype = ConcreteDataType::try_from(array.data_type())?;
+                // this is for item type
+                let datatype = ConcreteDataType::try_from(&array.value_type())?;
                 let items = ScalarValue::convert_array_to_scalar_vec(array.as_ref())
                     .context(ConvertArrowArrayToScalarsSnafu)?
                     .into_iter()
@@ -997,8 +1117,21 @@ impl TryFrom<ScalarValue> for Value {
             ScalarValue::Decimal128(v, p, s) => v
                 .map(|v| Value::Decimal128(Decimal128::new(v, p, s)))
                 .unwrap_or(Value::Null),
+            ScalarValue::Struct(struct_array) => {
+                let struct_type: StructType = (struct_array.fields()).try_into()?;
+                let items = struct_array
+                    .columns()
+                    .iter()
+                    .map(|array| {
+                        // we only take first element from each array
+                        let field_scalar_value = ScalarValue::try_from_array(array.as_ref(), 0)
+                            .context(ConvertArrowArrayToScalarsSnafu)?;
+                        field_scalar_value.try_into()
+                    })
+                    .collect::<Result<Vec<Value>>>()?;
+                Value::Struct(StructValue::try_new(items, struct_type)?)
+            }
             ScalarValue::Decimal256(_, _, _)
-            | ScalarValue::Struct(_)
             | ScalarValue::FixedSizeList(_)
             | ScalarValue::LargeList(_)
             | ScalarValue::Dictionary(_, _)
@@ -1044,12 +1177,13 @@ impl From<ValueRef<'_>> for Value {
             ValueRef::Duration(v) => Value::Duration(v),
             ValueRef::List(v) => v.to_value(),
             ValueRef::Decimal128(v) => Value::Decimal128(v),
+            ValueRef::Struct(v) => v.to_value(),
         }
     }
 }
 
 /// Reference to [Value].
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
 pub enum ValueRef<'a> {
     Null,
 
@@ -1085,13 +1219,14 @@ pub enum ValueRef<'a> {
 
     // Compound types:
     List(ListValueRef<'a>),
+    Struct(StructValueRef<'a>),
 }
 
 macro_rules! impl_as_for_value_ref {
     ($value: ident, $Variant: ident) => {
         match $value {
             ValueRef::Null => Ok(None),
-            ValueRef::$Variant(v) => Ok(Some(*v)),
+            ValueRef::$Variant(v) => Ok(Some(v.clone())),
             other => error::CastTypeSnafu {
                 msg: format!(
                     "Failed to cast value ref {:?} to {}",
@@ -1216,10 +1351,14 @@ impl<'a> ValueRef<'a> {
     }
 
     /// Cast itself to [ListValueRef].
-    pub fn as_list(&self) -> Result<Option<ListValueRef>> {
+    pub fn as_list(&self) -> Result<Option<ListValueRef<'_>>> {
         impl_as_for_value_ref!(self, List)
     }
 
+    pub fn as_struct(&self) -> Result<Option<StructValueRef<'_>>> {
+        impl_as_for_value_ref!(self, Struct)
+    }
+
     /// Cast itself to [Decimal128].
     pub fn as_decimal128(&self) -> Result<Option<Decimal128>> {
         impl_as_for_value_ref!(self, Decimal128)
@@ -1303,27 +1442,40 @@ impl<'a> From<Option<ListValueRef<'a>>> for ValueRef<'a> {
 /// Now comparison still requires some allocation (call of `to_value()`) and
 /// might be avoidable by downcasting and comparing the underlying array slice
 /// if it becomes bottleneck.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub enum ListValueRef<'a> {
     // TODO(yingwen): Consider replace this by VectorRef.
-    Indexed { vector: &'a ListVector, idx: usize },
-    Ref { val: &'a ListValue },
+    Indexed {
+        vector: &'a ListVector,
+        idx: usize,
+    },
+    Ref {
+        val: &'a ListValue,
+    },
+    RefList {
+        val: Vec<ValueRef<'a>>,
+        item_datatype: ConcreteDataType,
+    },
 }
 
 impl ListValueRef<'_> {
     /// Convert self to [Value]. This method would clone the underlying data.
-    fn to_value(self) -> Value {
+    fn to_value(&self) -> Value {
         match self {
-            ListValueRef::Indexed { vector, idx } => vector.get(idx),
-            ListValueRef::Ref { val } => Value::List(val.clone()),
+            ListValueRef::Indexed { vector, idx } => vector.get(*idx),
+            ListValueRef::Ref { val } => Value::List((*val).clone()),
+            ListValueRef::RefList { val, item_datatype } => Value::List(ListValue::new(
+                val.iter().map(|v| Value::from(v.clone())).collect(),
+                item_datatype.clone(),
+            )),
         }
     }
-
     /// Returns the inner element's data type.
     fn datatype(&self) -> ConcreteDataType {
         match self {
             ListValueRef::Indexed { vector, .. } => vector.data_type(),
             ListValueRef::Ref { val } => val.datatype().clone(),
+            ListValueRef::RefList { item_datatype, .. } => item_datatype.clone(),
         }
     }
 }
@@ -1336,6 +1488,7 @@ impl Serialize for ListValueRef<'_> {
                 _ => unreachable!(),
             },
             ListValueRef::Ref { val } => val.serialize(serializer),
+            ListValueRef::RefList { val, .. } => val.serialize(serializer),
         }
     }
 }
@@ -1361,11 +1514,79 @@ impl PartialOrd for ListValueRef<'_> {
     }
 }
 
+#[derive(Debug, Clone)]
+pub enum StructValueRef<'a> {
+    Indexed {
+        vector: &'a StructVector,
+        idx: usize,
+    },
+    Ref(&'a StructValue),
+    RefList {
+        val: Vec<ValueRef<'a>>,
+        fields: StructType,
+    },
+}
+
+impl<'a> StructValueRef<'a> {
+    pub fn to_value(&self) -> Value {
+        match self {
+            StructValueRef::Indexed { vector, idx } => vector.get(*idx),
+            StructValueRef::Ref(val) => Value::Struct((*val).clone()),
+            StructValueRef::RefList { val, fields } => {
+                let items = val.iter().map(|v| Value::from(v.clone())).collect();
+                Value::Struct(StructValue::try_new(items, fields.clone()).unwrap())
+            }
+        }
+    }
+
+    pub fn struct_type(&self) -> &StructType {
+        match self {
+            StructValueRef::Indexed { vector, .. } => vector.struct_type(),
+            StructValueRef::Ref(val) => val.struct_type(),
+            StructValueRef::RefList { fields, .. } => fields,
+        }
+    }
+}
+
+impl Serialize for StructValueRef<'_> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
+        match self {
+            StructValueRef::Indexed { vector, idx } => match vector.get(*idx) {
+                Value::Struct(v) => v.serialize(serializer),
+                _ => unreachable!(),
+            },
+            StructValueRef::Ref(val) => val.serialize(serializer),
+            StructValueRef::RefList { val, .. } => val.serialize(serializer),
+        }
+    }
+}
+
+impl PartialEq for StructValueRef<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_value().eq(&other.to_value())
+    }
+}
+
+impl Eq for StructValueRef<'_> {}
+
+impl Ord for StructValueRef<'_> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        // Respect the order of `Value` by converting into value before comparison.
+        self.to_value().cmp(&other.to_value())
+    }
+}
+
+impl PartialOrd for StructValueRef<'_> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
 impl ValueRef<'_> {
     /// Returns the size of the underlying data in bytes,
     /// The size is estimated and only considers the data size.
     pub fn data_size(&self) -> usize {
-        match *self {
+        match self {
             // Since the `Null` type is also considered to occupy space, we have opted to use the
             // size of `i64` as an initial approximation.
             ValueRef::Null => 8,
@@ -1380,8 +1601,8 @@ impl ValueRef<'_> {
             ValueRef::Int64(_) => 8,
             ValueRef::Float32(_) => 4,
             ValueRef::Float64(_) => 8,
-            ValueRef::String(v) => std::mem::size_of_val(v),
-            ValueRef::Binary(v) => std::mem::size_of_val(v),
+            ValueRef::String(v) => std::mem::size_of_val(*v),
+            ValueRef::Binary(v) => std::mem::size_of_val(*v),
             ValueRef::Date(_) => 4,
             ValueRef::Timestamp(_) => 16,
             ValueRef::Time(_) => 16,
@@ -1393,20 +1614,81 @@ impl ValueRef<'_> {
             ValueRef::List(v) => match v {
                 ListValueRef::Indexed { vector, .. } => vector.memory_size() / vector.len(),
                 ListValueRef::Ref { val } => val.estimated_size(),
+                ListValueRef::RefList { val, .. } => val.iter().map(|v| v.data_size()).sum(),
+            },
+            ValueRef::Struct(val) => match val {
+                StructValueRef::Indexed { vector, .. } => vector.memory_size() / vector.len(),
+                StructValueRef::Ref(val) => val.estimated_size(),
+                StructValueRef::RefList { val, .. } => val.iter().map(|v| v.data_size()).sum(),
             },
         }
     }
 }
 
 #[cfg(test)]
-mod tests {
-    use arrow::datatypes::DataType as ArrowDataType;
+pub(crate) mod tests {
+    use arrow::datatypes::{DataType as ArrowDataType, Field};
     use common_time::timezone::set_default_timezone;
     use num_traits::Float;
 
     use super::*;
+    use crate::types::StructField;
     use crate::vectors::ListVectorBuilder;
 
+    pub(crate) fn build_struct_type() -> StructType {
+        StructType::new(vec![
+            StructField::new("id".to_string(), ConcreteDataType::int32_datatype(), false),
+            StructField::new(
+                "name".to_string(),
+                ConcreteDataType::string_datatype(),
+                true,
+            ),
+            StructField::new("age".to_string(), ConcreteDataType::uint8_datatype(), true),
+            StructField::new(
+                "address".to_string(),
+                ConcreteDataType::string_datatype(),
+                true,
+            ),
+        ])
+    }
+
+    pub(crate) fn build_struct_value() -> StructValue {
+        let struct_type = build_struct_type();
+
+        let struct_items = vec![
+            Value::Int32(1),
+            Value::String("tom".into()),
+            Value::UInt8(25),
+            Value::String("94038".into()),
+        ];
+        StructValue::try_new(struct_items, struct_type).unwrap()
+    }
+
+    pub(crate) fn build_scalar_struct_value() -> ScalarValue {
+        let struct_type = build_struct_type();
+        let arrays = vec![
+            ScalarValue::Int32(Some(1)).to_array().unwrap(),
+            ScalarValue::Utf8(Some("tom".into())).to_array().unwrap(),
+            ScalarValue::UInt8(Some(25)).to_array().unwrap(),
+            ScalarValue::Utf8(Some("94038".into())).to_array().unwrap(),
+        ];
+        let struct_arrow_array = StructArray::new(struct_type.as_arrow_fields(), arrays, None);
+        ScalarValue::Struct(Arc::new(struct_arrow_array))
+    }
+
+    pub(crate) fn build_list_value() -> ListValue {
+        let items = vec![Value::Boolean(true), Value::Boolean(false)];
+        ListValue::new(items, ConcreteDataType::boolean_datatype())
+    }
+
+    pub(crate) fn build_scalar_list_value() -> ScalarValue {
+        let items = vec![
+            ScalarValue::Boolean(Some(true)),
+            ScalarValue::Boolean(Some(false)),
+        ];
+        ScalarValue::List(ScalarValue::new_list(&items, &ArrowDataType::Boolean, true))
+    }
+
     #[test]
     fn test_try_from_scalar_value() {
         assert_eq!(
@@ -1518,23 +1800,11 @@ mod tests {
         );
 
         assert_eq!(
-            Value::List(ListValue::new(
-                vec![Value::Int32(1), Value::Null],
-                ConcreteDataType::list_datatype(ConcreteDataType::int32_datatype())
-            )),
-            ScalarValue::List(ScalarValue::new_list(
-                &[ScalarValue::Int32(Some(1)), ScalarValue::Int32(None)],
-                &ArrowDataType::Int32,
-                true,
-            ))
-            .try_into()
-            .unwrap()
+            Value::List(build_list_value()),
+            build_scalar_list_value().try_into().unwrap()
         );
         assert_eq!(
-            Value::List(ListValue::new(
-                vec![],
-                ConcreteDataType::list_datatype(ConcreteDataType::uint32_datatype())
-            )),
+            Value::List(ListValue::new(vec![], ConcreteDataType::uint32_datatype())),
             ScalarValue::List(ScalarValue::new_list(&[], &ArrowDataType::UInt32, true))
                 .try_into()
                 .unwrap()
@@ -1690,6 +1960,13 @@ mod tests {
             Value::Null,
             ScalarValue::Decimal128(None, 0, 0).try_into().unwrap()
         );
+
+        let struct_value = build_struct_value();
+        let scalar_struct_value = build_scalar_struct_value();
+        assert_eq!(
+            Value::Struct(struct_value),
+            scalar_struct_value.try_into().unwrap()
+        );
     }
 
     #[test]
@@ -1861,6 +2138,19 @@ mod tests {
             &ConcreteDataType::decimal128_datatype(38, 10),
             &Value::Decimal128(Decimal128::new(1, 38, 10)),
         );
+
+        check_type_and_value(
+            &ConcreteDataType::list_datatype(ConcreteDataType::boolean_datatype()),
+            &Value::List(ListValue::new(
+                vec![Value::Boolean(true)],
+                ConcreteDataType::boolean_datatype(),
+            )),
+        );
+
+        check_type_and_value(
+            &ConcreteDataType::struct_datatype(build_struct_type()),
+            &Value::Struct(build_struct_value()),
+        );
     }
 
     #[test]
@@ -1960,8 +2250,7 @@ mod tests {
             to_json(Value::Duration(Duration::new_millisecond(1)))
         );
 
-        let json_value: serde_json::Value =
-            serde_json::from_str(r#"{"items":[{"Int32":123}],"datatype":{"Int32":{}}}"#).unwrap();
+        let json_value: serde_json::Value = serde_json::from_str(r#"[123]"#).unwrap();
         assert_eq!(
             json_value,
             to_json(Value::List(ListValue {
@@ -1969,6 +2258,36 @@ mod tests {
                 datatype: ConcreteDataType::int32_datatype(),
             }))
         );
+
+        let struct_value = StructValue::try_new(
+            vec![
+                Value::Int64(42),
+                Value::String("tomcat".into()),
+                Value::Boolean(true),
+            ],
+            StructType::new(vec![
+                StructField::new("num".to_string(), ConcreteDataType::int64_datatype(), true),
+                StructField::new(
+                    "name".to_string(),
+                    ConcreteDataType::string_datatype(),
+                    true,
+                ),
+                StructField::new(
+                    "yes_or_no".to_string(),
+                    ConcreteDataType::boolean_datatype(),
+                    true,
+                ),
+            ]),
+        )
+        .unwrap();
+        assert_eq!(
+            serde_json::Value::try_from(Value::Struct(struct_value)).unwrap(),
+            serde_json::json!({
+                "num": 42,
+                "name": "tomcat",
+                "yes_or_no": true
+            })
+        );
     }
 
     #[test]
@@ -2033,10 +2352,7 @@ mod tests {
 
         check_as_value_ref!(Date, Date::new(103));
 
-        let list = ListValue {
-            items: vec![],
-            datatype: ConcreteDataType::int32_datatype(),
-        };
+        let list = build_list_value();
         assert_eq!(
             ValueRef::List(ListValueRef::Ref { val: &list }),
             Value::List(list.clone()).as_value_ref()
@@ -2049,6 +2365,12 @@ mod tests {
             ValueRef::Binary(jsonb_value.clone().as_slice()),
             Value::Binary(jsonb_value.into()).as_value_ref()
         );
+
+        let struct_value = build_struct_value();
+        assert_eq!(
+            ValueRef::Struct(StructValueRef::Ref(&struct_value)),
+            Value::Struct(struct_value.clone()).as_value_ref()
+        );
     }
 
     #[test]
@@ -2077,12 +2399,13 @@ mod tests {
         check_as_correct!(Date::new(123), Date, as_date);
         check_as_correct!(Time::new_second(12), Time, as_time);
         check_as_correct!(Duration::new_second(12), Duration, as_duration);
-        let list = ListValue {
-            items: vec![],
-            datatype: ConcreteDataType::int32_datatype(),
-        };
+
+        let list = build_list_value();
         check_as_correct!(ListValueRef::Ref { val: &list }, List, as_list);
 
+        let struct_value = build_struct_value();
+        check_as_correct!(StructValueRef::Ref(&struct_value), Struct, as_struct);
+
         let wrong_value = ValueRef::Int32(12345);
         assert!(wrong_value.as_binary().is_err());
         assert!(wrong_value.as_string().is_err());
@@ -2128,12 +2451,8 @@ mod tests {
             "1000ms"
         );
         assert_eq!(
-            Value::List(ListValue::new(
-                vec![Value::Int8(1), Value::Int8(2)],
-                ConcreteDataType::int8_datatype(),
-            ))
-            .to_string(),
-            "Int8[1, 2]"
+            Value::List(build_list_value()).to_string(),
+            "Boolean[true, false]"
         );
         assert_eq!(
             Value::List(ListValue::new(
@@ -2167,6 +2486,11 @@ mod tests {
             .to_string(),
             "TimestampNanosecond[]"
         );
+
+        assert_eq!(
+            Value::Struct(build_struct_value()).to_string(),
+            "{ id: 1, name: tom, age: 25, address: 94038 }"
+        );
     }
 
     #[test]
@@ -2265,6 +2589,22 @@ mod tests {
                 .try_to_scalar_value(&ConcreteDataType::json_datatype())
                 .unwrap()
         );
+
+        assert_eq!(
+            build_scalar_struct_value(),
+            Value::Struct(build_struct_value())
+                .try_to_scalar_value(&ConcreteDataType::struct_datatype(build_struct_type()))
+                .unwrap()
+        );
+
+        assert_eq!(
+            build_scalar_list_value(),
+            Value::List(build_list_value())
+                .try_to_scalar_value(&ConcreteDataType::list_datatype(
+                    ConcreteDataType::boolean_datatype()
+                ))
+                .unwrap()
+        );
     }
 
     #[test]
@@ -2403,6 +2743,22 @@ mod tests {
                 .try_to_scalar_value(&ConcreteDataType::json_datatype())
                 .unwrap()
         );
+
+        assert_eq!(
+            ScalarValue::new_null_list(ArrowDataType::Boolean, true, 1),
+            Value::Null
+                .try_to_scalar_value(&ConcreteDataType::list_datatype(
+                    ConcreteDataType::boolean_datatype(),
+                ))
+                .unwrap()
+        );
+
+        assert_eq!(
+            ScalarStructBuilder::new_null(build_struct_type().as_arrow_fields()),
+            Value::Null
+                .try_to_scalar_value(&ConcreteDataType::struct_datatype(build_struct_type()))
+                .unwrap()
+        );
     }
 
     #[test]
@@ -2439,6 +2795,41 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_struct_value_to_scalar_value() {
+        let struct_value = build_struct_value();
+        let scalar_value = struct_value
+            .try_to_scalar_value(&build_struct_type())
+            .unwrap();
+
+        assert_eq!(scalar_value, build_scalar_struct_value());
+
+        assert!(matches!(scalar_value, ScalarValue::Struct(_)));
+        match scalar_value {
+            ScalarValue::Struct(values) => {
+                assert_eq!(&build_struct_type().as_arrow_fields(), values.fields());
+
+                assert_eq!(
+                    ScalarValue::try_from_array(values.column(0), 0).unwrap(),
+                    ScalarValue::Int32(Some(1))
+                );
+                assert_eq!(
+                    ScalarValue::try_from_array(values.column(1), 0).unwrap(),
+                    ScalarValue::Utf8(Some("tom".into()))
+                );
+                assert_eq!(
+                    ScalarValue::try_from_array(values.column(2), 0).unwrap(),
+                    ScalarValue::UInt8(Some(25))
+                );
+                assert_eq!(
+                    ScalarValue::try_from_array(values.column(3), 0).unwrap(),
+                    ScalarValue::Utf8(Some("94038".into()))
+                );
+            }
+            _ => panic!("Unexpected value type"),
+        }
+    }
+
     #[test]
     fn test_timestamp_to_scalar_value() {
         assert_eq!(
@@ -2582,7 +2973,12 @@ mod tests {
             }),
             74,
         );
-        check_value_ref_size_eq(&ValueRef::Decimal128(Decimal128::new(1234, 3, 1)), 32)
+        check_value_ref_size_eq(&ValueRef::Decimal128(Decimal128::new(1234, 3, 1)), 32);
+
+        check_value_ref_size_eq(
+            &ValueRef::Struct(StructValueRef::Ref(&build_struct_value())),
+            13,
+        );
     }
 
     #[test]
diff --git a/src/datatypes/src/vectors.rs b/src/datatypes/src/vectors.rs
index 77678840d8..b80287fec5 100644
--- a/src/datatypes/src/vectors.rs
+++ b/src/datatypes/src/vectors.rs
@@ -71,6 +71,7 @@ pub use primitive::{
     UInt32VectorBuilder, UInt64Vector, UInt64VectorBuilder,
 };
 pub use string::{StringVector, StringVectorBuilder};
+pub use struct_vector::{StructVector, StructVectorBuilder};
 pub use time::{
     TimeMicrosecondVector, TimeMicrosecondVectorBuilder, TimeMillisecondVector,
     TimeMillisecondVectorBuilder, TimeNanosecondVector, TimeNanosecondVectorBuilder,
@@ -165,7 +166,7 @@ pub trait Vector: Send + Sync + Serializable + Debug + VectorOp {
     ///
     /// # Panics
     /// Panic if `index` is out of bound.
-    fn get_ref(&self, index: usize) -> ValueRef;
+    fn get_ref(&self, index: usize) -> ValueRef<'_>;
 }
 
 pub type VectorRef = Arc<dyn Vector>;
@@ -196,13 +197,13 @@ pub trait MutableVector: Send + Sync {
     fn to_vector_cloned(&self) -> VectorRef;
 
     /// Try to push value ref to this mutable vector.
-    fn try_push_value_ref(&mut self, value: ValueRef) -> Result<()>;
+    fn try_push_value_ref(&mut self, value: &ValueRef) -> Result<()>;
 
     /// Push value ref to this mutable vector.
     ///
     /// # Panics
     /// Panics if error if data types mismatch.
-    fn push_value_ref(&mut self, value: ValueRef) {
+    fn push_value_ref(&mut self, value: &ValueRef) {
         self.try_push_value_ref(value).unwrap_or_else(|_| {
             panic!(
                 "expecting pushing value of datatype {:?}, actual {:?}",
@@ -439,9 +440,9 @@ pub mod tests {
     fn test_mutable_vector_to_vector_cloned() {
         // create a string vector builder
         let mut builder = ConcreteDataType::string_datatype().create_mutable_vector(1024);
-        builder.push_value_ref(ValueRef::String("hello"));
-        builder.push_value_ref(ValueRef::String("world"));
-        builder.push_value_ref(ValueRef::String("!"));
+        builder.push_value_ref(&ValueRef::String("hello"));
+        builder.push_value_ref(&ValueRef::String("world"));
+        builder.push_value_ref(&ValueRef::String("!"));
 
         // use MutableVector trait to_vector_cloned won't reset builder
         let vector = builder.to_vector_cloned();
diff --git a/src/datatypes/src/vectors/binary.rs b/src/datatypes/src/vectors/binary.rs
index 50e9011909..abda58e7fa 100644
--- a/src/datatypes/src/vectors/binary.rs
+++ b/src/datatypes/src/vectors/binary.rs
@@ -180,7 +180,7 @@ impl Vector for BinaryVector {
         vectors::impl_get_for_vector!(self.array, index)
     }
 
-    fn get_ref(&self, index: usize) -> ValueRef {
+    fn get_ref(&self, index: usize) -> ValueRef<'_> {
         vectors::impl_get_ref_for_vector!(self.array, index)
     }
 }
@@ -241,7 +241,7 @@ impl MutableVector for BinaryVectorBuilder {
         Arc::new(self.finish_cloned())
     }
 
-    fn try_push_value_ref(&mut self, value: ValueRef) -> Result<()> {
+    fn try_push_value_ref(&mut self, value: &ValueRef) -> Result<()> {
         match value.as_binary()? {
             Some(v) => self.mutable_array.append_value(v),
             None => self.mutable_array.append_null(),
@@ -427,8 +427,8 @@ mod tests {
         let input = BinaryVector::from_slice(&[b"world", b"one", b"two"]);
 
         let mut builder = BinaryType.create_mutable_vector(3);
-        builder.push_value_ref(ValueRef::Binary("hello".as_bytes()));
-        assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
+        builder.push_value_ref(&ValueRef::Binary("hello".as_bytes()));
+        assert!(builder.try_push_value_ref(&ValueRef::Int32(123)).is_err());
         builder.extend_slice_of(&input, 1, 2).unwrap();
         assert!(
             builder
diff --git a/src/datatypes/src/vectors/boolean.rs b/src/datatypes/src/vectors/boolean.rs
index 86e336bf9a..3bcc9118ed 100644
--- a/src/datatypes/src/vectors/boolean.rs
+++ b/src/datatypes/src/vectors/boolean.rs
@@ -126,7 +126,7 @@ impl Vector for BooleanVector {
         vectors::impl_get_for_vector!(self.array, index)
     }
 
-    fn get_ref(&self, index: usize) -> ValueRef {
+    fn get_ref(&self, index: usize) -> ValueRef<'_> {
         vectors::impl_get_ref_for_vector!(self.array, index)
     }
 }
@@ -179,7 +179,7 @@ impl MutableVector for BooleanVectorBuilder {
         Arc::new(self.finish_cloned())
     }
 
-    fn try_push_value_ref(&mut self, value: ValueRef) -> Result<()> {
+    fn try_push_value_ref(&mut self, value: &ValueRef) -> Result<()> {
         match value.as_boolean()? {
             Some(v) => self.mutable_array.append_value(v),
             None => self.mutable_array.append_null(),
@@ -357,8 +357,8 @@ mod tests {
         let input = BooleanVector::from_slice(&[true, false, true]);
 
         let mut builder = BooleanType.create_mutable_vector(3);
-        builder.push_value_ref(ValueRef::Boolean(true));
-        assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
+        builder.push_value_ref(&ValueRef::Boolean(true));
+        assert!(builder.try_push_value_ref(&ValueRef::Int32(123)).is_err());
         builder.extend_slice_of(&input, 1, 2).unwrap();
         assert!(
             builder
diff --git a/src/datatypes/src/vectors/constant.rs b/src/datatypes/src/vectors/constant.rs
index c0249b630b..3a0adc7b62 100644
--- a/src/datatypes/src/vectors/constant.rs
+++ b/src/datatypes/src/vectors/constant.rs
@@ -52,7 +52,7 @@ impl ConstantVector {
     }
 
     /// Returns the constant value.
-    pub fn get_constant_ref(&self) -> ValueRef {
+    pub fn get_constant_ref(&self) -> ValueRef<'_> {
         self.vector.get_ref(0)
     }
 
@@ -179,7 +179,7 @@ impl Vector for ConstantVector {
         self.vector.get(0)
     }
 
-    fn get_ref(&self, _index: usize) -> ValueRef {
+    fn get_ref(&self, _index: usize) -> ValueRef<'_> {
         self.vector.get_ref(0)
     }
 
diff --git a/src/datatypes/src/vectors/date.rs b/src/datatypes/src/vectors/date.rs
index 15e3cdc17e..f959f9c4cb 100644
--- a/src/datatypes/src/vectors/date.rs
+++ b/src/datatypes/src/vectors/date.rs
@@ -69,8 +69,8 @@ mod tests {
         let input = DateVector::from_slice([1, 2, 3]);
 
         let mut builder = DateType.create_mutable_vector(3);
-        builder.push_value_ref(ValueRef::Date(Date::new(5)));
-        assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
+        builder.push_value_ref(&ValueRef::Date(Date::new(5)));
+        assert!(builder.try_push_value_ref(&ValueRef::Int32(123)).is_err());
         builder.extend_slice_of(&input, 1, 2).unwrap();
         assert!(
             builder
diff --git a/src/datatypes/src/vectors/decimal.rs b/src/datatypes/src/vectors/decimal.rs
index f75ef1a238..6ba3fb6267 100644
--- a/src/datatypes/src/vectors/decimal.rs
+++ b/src/datatypes/src/vectors/decimal.rs
@@ -207,7 +207,7 @@ impl Vector for Decimal128Vector {
         }
     }
 
-    fn get_ref(&self, index: usize) -> ValueRef {
+    fn get_ref(&self, index: usize) -> ValueRef<'_> {
         if let Some(decimal) = self.get_decimal128_value_from_array(index) {
             ValueRef::Decimal128(decimal)
         } else {
@@ -314,7 +314,7 @@ impl MutableVector for Decimal128VectorBuilder {
         Arc::new(self.finish_cloned())
     }
 
-    fn try_push_value_ref(&mut self, value: ValueRef) -> Result<()> {
+    fn try_push_value_ref(&mut self, value: &ValueRef) -> Result<()> {
         let decimal_val = value.as_decimal128()?.map(|v| v.val());
         self.mutable_array.append_option(decimal_val);
         Ok(())
diff --git a/src/datatypes/src/vectors/dictionary.rs b/src/datatypes/src/vectors/dictionary.rs
index 1ba06a6ca8..5b65120019 100644
--- a/src/datatypes/src/vectors/dictionary.rs
+++ b/src/datatypes/src/vectors/dictionary.rs
@@ -154,7 +154,7 @@ impl<K: ArrowDictionaryKeyType> Vector for DictionaryVector<K> {
         self.item_vector.get(key.as_usize())
     }
 
-    fn get_ref(&self, index: usize) -> ValueRef {
+    fn get_ref(&self, index: usize) -> ValueRef<'_> {
         if !self.array.is_valid(index) {
             return ValueRef::Null;
         }
diff --git a/src/datatypes/src/vectors/helper.rs b/src/datatypes/src/vectors/helper.rs
index d58b085e31..035ebf4ab6 100644
--- a/src/datatypes/src/vectors/helper.rs
+++ b/src/datatypes/src/vectors/helper.rs
@@ -33,6 +33,7 @@ use crate::data_type::ConcreteDataType;
 use crate::error::{self, ConvertArrowArrayToScalarsSnafu, Result};
 use crate::prelude::DataType;
 use crate::scalars::{Scalar, ScalarVectorBuilder};
+use crate::types::StructType;
 use crate::value::{ListValue, ListValueRef, Value};
 use crate::vectors::struct_vector::StructVector;
 use crate::vectors::{
@@ -237,8 +238,14 @@ impl Helper {
                 let vector = Decimal128Vector::from(vec![v]).with_precision_and_scale(p, s)?;
                 ConstantVector::new(Arc::new(vector), length)
             }
+            ScalarValue::Struct(v) => {
+                let struct_type = StructType::try_from(v.fields())?;
+                ConstantVector::new(
+                    Arc::new(StructVector::try_new(struct_type, (*v).clone())?),
+                    length,
+                )
+            }
             ScalarValue::Decimal256(_, _, _)
-            | ScalarValue::Struct(_)
             | ScalarValue::FixedSizeList(_)
             | ScalarValue::LargeList(_)
             | ScalarValue::Dictionary(_, _)
@@ -386,13 +393,16 @@ impl Helper {
                 }
             }
 
-            ArrowDataType::Struct(_fields) => {
+            ArrowDataType::Struct(fields) => {
                 let array = array
                     .as_ref()
                     .as_any()
                     .downcast_ref::<StructArray>()
                     .unwrap();
-                Arc::new(StructVector::new(array.clone())?)
+                Arc::new(StructVector::try_new(
+                    StructType::try_from(fields)?,
+                    array.clone(),
+                )?)
             }
             ArrowDataType::Float16
             | ArrowDataType::LargeList(_)
@@ -418,7 +428,7 @@ impl Helper {
     pub fn try_from_row_into_vector(row: &[Value], dt: &ConcreteDataType) -> Result<VectorRef> {
         let mut builder = dt.create_mutable_vector(row.len());
         for val in row {
-            builder.try_push_value_ref(val.as_value_ref())?;
+            builder.try_push_value_ref(&val.as_value_ref())?;
         }
         let vector = builder.to_vector();
         Ok(vector)
diff --git a/src/datatypes/src/vectors/list.rs b/src/datatypes/src/vectors/list.rs
index dfd418bcbd..d1a1fb14a2 100644
--- a/src/datatypes/src/vectors/list.rs
+++ b/src/datatypes/src/vectors/list.rs
@@ -49,11 +49,15 @@ impl ListVector {
     pub(crate) fn as_arrow(&self) -> &dyn Array {
         &self.array
     }
+
+    pub(crate) fn item_type(&self) -> ConcreteDataType {
+        self.item_type.clone()
+    }
 }
 
 impl Vector for ListVector {
     fn data_type(&self) -> ConcreteDataType {
-        ConcreteDataType::List(ListType::new(self.item_type.clone()))
+        ConcreteDataType::List(ListType::new(self.item_type()))
     }
 
     fn vector_type_name(&self) -> String {
@@ -117,7 +121,7 @@ impl Vector for ListVector {
         Value::List(ListValue::new(values, self.item_type.clone()))
     }
 
-    fn get_ref(&self, index: usize) -> ValueRef {
+    fn get_ref(&self, index: usize) -> ValueRef<'_> {
         ValueRef::List(ListValueRef::Indexed {
             vector: self,
             idx: index,
@@ -246,7 +250,7 @@ impl ListVectorBuilder {
 
     fn push_list_value(&mut self, list_value: &ListValue) -> Result<()> {
         for v in list_value.items() {
-            self.values_builder.try_push_value_ref(v.as_value_ref())?;
+            self.values_builder.try_push_value_ref(&v.as_value_ref())?;
         }
 
         self.finish_list(true);
@@ -279,7 +283,7 @@ impl MutableVector for ListVectorBuilder {
         Arc::new(self.finish_cloned())
     }
 
-    fn try_push_value_ref(&mut self, value: ValueRef) -> Result<()> {
+    fn try_push_value_ref(&mut self, value: &ValueRef) -> Result<()> {
         if let Some(list_ref) = value.as_list()? {
             match list_ref {
                 ListValueRef::Indexed { vector, idx } => match vector.get(idx).as_list()? {
@@ -287,6 +291,13 @@ impl MutableVector for ListVectorBuilder {
                     None => self.push_null(),
                 },
                 ListValueRef::Ref { val } => self.push_list_value(val)?,
+                ListValueRef::RefList { val, item_datatype } => {
+                    let list_value = ListValue::new(
+                        val.iter().map(|v| Value::from(v.clone())).collect(),
+                        item_datatype.clone(),
+                    );
+                    self.push_list_value(&list_value)?;
+                }
             }
         } else {
             self.push_null();
@@ -298,7 +309,7 @@ impl MutableVector for ListVectorBuilder {
     fn extend_slice_of(&mut self, vector: &dyn Vector, offset: usize, length: usize) -> Result<()> {
         for idx in offset..offset + length {
             let value = vector.get_ref(idx);
-            self.try_push_value_ref(value)?;
+            self.try_push_value_ref(&value)?;
         }
 
         Ok(())
@@ -320,7 +331,7 @@ impl ScalarVectorBuilder for ListVectorBuilder {
         // We expect the input ListValue has the same inner type as the builder when using
         // push(), so just panic if `push_value_ref()` returns error, which indicate an
         // invalid input value type.
-        self.try_push_value_ref(value.into()).unwrap_or_else(|e| {
+        self.try_push_value_ref(&value.into()).unwrap_or_else(|e| {
             panic!(
                 "Failed to push value, expect value type {:?}, err:{}",
                 self.item_type, e
@@ -663,13 +674,13 @@ pub mod tests {
     fn test_list_vector_builder() {
         let mut builder =
             ListType::new(ConcreteDataType::int32_datatype()).create_mutable_vector(3);
-        builder.push_value_ref(ValueRef::List(ListValueRef::Ref {
+        builder.push_value_ref(&ValueRef::List(ListValueRef::Ref {
             val: &ListValue::new(
                 vec![Value::Int32(4), Value::Null, Value::Int32(6)],
                 ConcreteDataType::int32_datatype(),
             ),
         }));
-        assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
+        assert!(builder.try_push_value_ref(&ValueRef::Int32(123)).is_err());
 
         let data = vec![
             Some(vec![Some(1), Some(2), Some(3)]),
diff --git a/src/datatypes/src/vectors/null.rs b/src/datatypes/src/vectors/null.rs
index 8c67041ac6..e049eb205c 100644
--- a/src/datatypes/src/vectors/null.rs
+++ b/src/datatypes/src/vectors/null.rs
@@ -21,6 +21,7 @@ use snafu::{OptionExt, ensure};
 
 use crate::data_type::ConcreteDataType;
 use crate::error::{self, Result};
+use crate::prelude::{ScalarVector, ScalarVectorBuilder};
 use crate::serialize::Serializable;
 use crate::types::NullType;
 use crate::value::{Value, ValueRef};
@@ -106,12 +107,27 @@ impl Vector for NullVector {
         Value::Null
     }
 
-    fn get_ref(&self, _index: usize) -> ValueRef {
+    fn get_ref(&self, _index: usize) -> ValueRef<'_> {
         // Skips bound check for null array.
         ValueRef::Null
     }
 }
 
+impl ScalarVector for NullVector {
+    type OwnedItem = ();
+    type RefItem<'a> = ();
+    type Iter<'a> = NullIter<'a>;
+    type Builder = NullVectorBuilder;
+
+    fn get_data(&self, _idx: usize) -> Option<Self::RefItem<'_>> {
+        Some(())
+    }
+
+    fn iter_data(&self) -> Self::Iter<'_> {
+        NullIter::new(self)
+    }
+}
+
 impl fmt::Debug for NullVector {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "NullVector({})", self.len())
@@ -126,6 +142,30 @@ impl Serializable for NullVector {
 
 vectors::impl_try_from_arrow_array_for_vector!(NullArray, NullVector);
 
+pub struct NullIter<'a> {
+    vector: &'a NullVector,
+    index: usize,
+}
+
+impl<'a> NullIter<'a> {
+    pub fn new(vector: &'a NullVector) -> Self {
+        NullIter { vector, index: 0 }
+    }
+}
+
+impl<'a> Iterator for NullIter<'a> {
+    type Item = Option<()>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.index < self.vector.len() {
+            self.index += 1;
+            Some(Some(()))
+        } else {
+            None
+        }
+    }
+}
+
 #[derive(Default)]
 pub struct NullVectorBuilder {
     length: usize,
@@ -158,7 +198,7 @@ impl MutableVector for NullVectorBuilder {
         Arc::new(NullVector::new(self.length))
     }
 
-    fn try_push_value_ref(&mut self, value: ValueRef) -> Result<()> {
+    fn try_push_value_ref(&mut self, value: &ValueRef) -> Result<()> {
         ensure!(
             value.is_null(),
             error::CastTypeSnafu {
@@ -197,6 +237,29 @@ impl MutableVector for NullVectorBuilder {
     }
 }
 
+impl ScalarVectorBuilder for NullVectorBuilder {
+    type VectorType = NullVector;
+
+    fn with_capacity(_capacity: usize) -> Self {
+        Self::default()
+    }
+
+    fn push(&mut self, _value: Option<<Self::VectorType as ScalarVector>::RefItem<'_>>) {
+        self.length += 1;
+    }
+
+    fn finish(&mut self) -> Self::VectorType {
+        let result = NullVector::new(self.length);
+
+        self.length = 0;
+        result
+    }
+
+    fn finish_cloned(&self) -> Self::VectorType {
+        NullVector::new(self.length)
+    }
+}
+
 pub(crate) fn replicate_null(vector: &NullVector, offsets: &[usize]) -> VectorRef {
     assert_eq!(offsets.len(), vector.len());
 
@@ -265,7 +328,7 @@ mod tests {
     fn test_null_vector_builder() {
         let mut builder = NullType.create_mutable_vector(3);
         builder.push_null();
-        assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
+        assert!(builder.try_push_value_ref(&ValueRef::Int32(123)).is_err());
 
         let input = NullVector::new(3);
         builder.extend_slice_of(&input, 1, 2).unwrap();
diff --git a/src/datatypes/src/vectors/operations/replicate.rs b/src/datatypes/src/vectors/operations/replicate.rs
index 4684cc7f82..9e0591efa3 100644
--- a/src/datatypes/src/vectors/operations/replicate.rs
+++ b/src/datatypes/src/vectors/operations/replicate.rs
@@ -29,7 +29,7 @@ pub(crate) fn replicate_scalar<C: ScalarVector>(c: &C, offsets: &[usize]) -> Vec
     for (i, offset) in offsets.iter().enumerate() {
         let data = c.get_data(i);
         for _ in previous_offset..*offset {
-            builder.push(data);
+            builder.push(data.clone());
         }
         previous_offset = *offset;
     }
diff --git a/src/datatypes/src/vectors/primitive.rs b/src/datatypes/src/vectors/primitive.rs
index f2737f45c2..dc85f94c4f 100644
--- a/src/datatypes/src/vectors/primitive.rs
+++ b/src/datatypes/src/vectors/primitive.rs
@@ -172,7 +172,7 @@ impl<T: LogicalPrimitiveType> Vector for PrimitiveVector<T> {
         }
     }
 
-    fn get_ref(&self, index: usize) -> ValueRef {
+    fn get_ref(&self, index: usize) -> ValueRef<'_> {
         if self.array.is_valid(index) {
             // Safety: The index have been checked by `is_valid()`.
             let wrapper = unsafe { T::Wrapper::from_native(self.array.value_unchecked(index)) };
@@ -309,7 +309,7 @@ impl<T: LogicalPrimitiveType> MutableVector for PrimitiveVectorBuilder<T> {
         Arc::new(self.finish_cloned())
     }
 
-    fn try_push_value_ref(&mut self, value: ValueRef) -> Result<()> {
+    fn try_push_value_ref(&mut self, value: &ValueRef) -> Result<()> {
         let primitive = T::cast_value_ref(value)?;
         match primitive {
             Some(v) => self.mutable_array.append_value(v.into_native()),
@@ -549,8 +549,8 @@ mod tests {
     #[test]
     fn test_primitive_vector_builder() {
         let mut builder = Int64Type::default().create_mutable_vector(3);
-        builder.push_value_ref(ValueRef::Int64(123));
-        assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
+        builder.push_value_ref(&ValueRef::Int64(123));
+        assert!(builder.try_push_value_ref(&ValueRef::Int32(123)).is_err());
 
         let input = Int64Vector::from_slice([7, 8, 9]);
         builder.extend_slice_of(&input, 1, 2).unwrap();
@@ -711,8 +711,8 @@ mod tests {
     #[test]
     fn test_primitive_vector_builder_finish_cloned() {
         let mut builder = Int64Type::default().create_mutable_vector(3);
-        builder.push_value_ref(ValueRef::Int64(123));
-        builder.push_value_ref(ValueRef::Int64(456));
+        builder.push_value_ref(&ValueRef::Int64(123));
+        builder.push_value_ref(&ValueRef::Int64(456));
         let vector = builder.to_vector_cloned();
         assert_eq!(vector.len(), 2);
         assert_eq!(vector.null_count(), 0);
diff --git a/src/datatypes/src/vectors/string.rs b/src/datatypes/src/vectors/string.rs
index 1c33bc5732..ba3023522f 100644
--- a/src/datatypes/src/vectors/string.rs
+++ b/src/datatypes/src/vectors/string.rs
@@ -141,7 +141,7 @@ impl Vector for StringVector {
         vectors::impl_get_for_vector!(self.array, index)
     }
 
-    fn get_ref(&self, index: usize) -> ValueRef {
+    fn get_ref(&self, index: usize) -> ValueRef<'_> {
         vectors::impl_get_ref_for_vector!(self.array, index)
     }
 }
@@ -194,7 +194,7 @@ impl MutableVector for StringVectorBuilder {
         Arc::new(self.finish_cloned())
     }
 
-    fn try_push_value_ref(&mut self, value: ValueRef) -> Result<()> {
+    fn try_push_value_ref(&mut self, value: &ValueRef) -> Result<()> {
         match value.as_string()? {
             Some(v) => self.mutable_array.append_value(v),
             None => self.mutable_array.append_null(),
@@ -289,8 +289,8 @@ mod tests {
     #[test]
     fn test_string_vector_builder() {
         let mut builder = StringVectorBuilder::with_capacity(3);
-        builder.push_value_ref(ValueRef::String("hello"));
-        assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
+        builder.push_value_ref(&ValueRef::String("hello"));
+        assert!(builder.try_push_value_ref(&ValueRef::Int32(123)).is_err());
 
         let input = StringVector::from_slice(&["world", "one", "two"]);
         builder.extend_slice_of(&input, 1, 2).unwrap();
diff --git a/src/datatypes/src/vectors/struct_vector.rs b/src/datatypes/src/vectors/struct_vector.rs
index 85445eb24d..b46d1353fb 100644
--- a/src/datatypes/src/vectors/struct_vector.rs
+++ b/src/datatypes/src/vectors/struct_vector.rs
@@ -12,33 +12,44 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::any::Any;
 use std::sync::Arc;
 
+use arrow::array::NullBufferBuilder;
 use arrow::compute::TakeOptions;
+use arrow::datatypes::DataType as ArrowDataType;
 use arrow_array::{Array, ArrayRef, StructArray};
-use serde_json::Value as JsonValue;
-use snafu::ResultExt;
+use datafusion_common::ScalarValue;
+use snafu::{ResultExt, ensure};
 
-use crate::error::{self, ArrowComputeSnafu, Result, UnsupportedOperationSnafu};
-use crate::prelude::ConcreteDataType;
+use crate::error::{
+    ArrowComputeSnafu, ConversionSnafu, Error, InconsistentStructFieldsAndItemsSnafu, Result,
+    SerializeSnafu, UnsupportedOperationSnafu,
+};
+use crate::prelude::{ConcreteDataType, DataType, ScalarVector, ScalarVectorBuilder};
 use crate::serialize::Serializable;
-use crate::value::{Value, ValueRef};
+use crate::types::StructType;
+use crate::value::{StructValue, StructValueRef, Value, ValueRef};
 use crate::vectors::operations::VectorOp;
-use crate::vectors::{self, Helper, Validity, Vector, VectorRef};
+use crate::vectors::{self, Helper, MutableVector, Validity, Vector, VectorRef};
 
 /// A simple wrapper around `StructArray` to represent a vector of structs in GreptimeDB.
 #[derive(Debug, PartialEq)]
 pub struct StructVector {
     array: StructArray,
-    data_type: ConcreteDataType,
+    fields: StructType,
 }
 
-#[allow(unused)]
 impl StructVector {
-    pub fn new(array: StructArray) -> Result<Self> {
-        let fields = array.fields();
-        let data_type = ConcreteDataType::Struct(fields.try_into()?);
-        Ok(StructVector { array, data_type })
+    pub fn try_new(fields: StructType, array: StructArray) -> Result<Self> {
+        ensure!(
+            fields.fields().len() == array.fields().len(),
+            InconsistentStructFieldsAndItemsSnafu {
+                field_len: fields.fields().len(),
+                item_len: array.fields().len(),
+            }
+        );
+        Ok(StructVector { array, fields })
     }
 
     pub fn array(&self) -> &StructArray {
@@ -48,11 +59,15 @@ impl StructVector {
     pub fn as_arrow(&self) -> &dyn Array {
         &self.array
     }
+
+    pub fn struct_type(&self) -> &StructType {
+        &self.fields
+    }
 }
 
 impl Vector for StructVector {
     fn data_type(&self) -> ConcreteDataType {
-        self.data_type.clone()
+        ConcreteDataType::struct_datatype(self.fields.clone())
     }
 
     fn vector_type_name(&self) -> String {
@@ -94,16 +109,36 @@ impl Vector for StructVector {
     fn slice(&self, offset: usize, length: usize) -> VectorRef {
         Arc::new(StructVector {
             array: self.array.slice(offset, length),
-            data_type: self.data_type.clone(),
+            fields: self.fields.clone(),
         })
     }
 
-    fn get(&self, _: usize) -> Value {
-        unimplemented!("StructValue not supported yet")
+    fn get(&self, index: usize) -> Value {
+        if !self.array.is_valid(index) {
+            return Value::Null;
+        }
+
+        let values = (0..self.fields.fields().len())
+            .map(|i| {
+                let field_array = &self.array.column(i);
+
+                if field_array.is_null(i) {
+                    Value::Null
+                } else {
+                    let scalar_value = ScalarValue::try_from_array(field_array, index).unwrap();
+                    Value::try_from(scalar_value).unwrap()
+                }
+            })
+            .collect();
+
+        Value::Struct(StructValue::try_new(values, self.fields.clone()).unwrap())
     }
 
-    fn get_ref(&self, _: usize) -> ValueRef {
-        unimplemented!("StructValue not supported yet")
+    fn get_ref(&self, index: usize) -> ValueRef<'_> {
+        ValueRef::Struct(StructValueRef::Indexed {
+            vector: self,
+            idx: index,
+        })
     }
 }
 
@@ -124,9 +159,7 @@ impl VectorOp for StructVector {
             column_arrays,
             self.array.nulls().cloned(),
         );
-        Arc::new(
-            StructVector::new(replicated_array).expect("Failed to create replicated StructVector"),
-        )
+        Arc::new(StructVector::try_new(self.fields.clone(), replicated_array).unwrap())
     }
 
     fn cast(&self, _to_type: &ConcreteDataType) -> Result<VectorRef> {
@@ -159,23 +192,295 @@ impl VectorOp for StructVector {
 
 impl Serializable for StructVector {
     fn serialize_to_json(&self) -> Result<Vec<serde_json::Value>> {
-        let mut result = serde_json::Map::new();
-        for (field, value) in self.array.fields().iter().zip(self.array.columns().iter()) {
-            let value_vector = Helper::try_into_vector(value)?;
-
-            let field_value = value_vector.serialize_to_json()?;
-            result.insert(field.name().clone(), JsonValue::Array(field_value));
-        }
-        let fields = JsonValue::Object(result);
-        let data_type = serde_json::to_value(&self.data_type).context(error::SerializeSnafu)?;
-        Ok(vec![JsonValue::Object(
-            [
-                ("fields".to_string(), fields),
-                ("data_type".to_string(), data_type),
-            ]
+        let vectors = self
+            .array
+            .columns()
             .iter()
-            .cloned()
-            .collect(),
-        )])
+            .map(|value_array| Helper::try_into_vector(value_array))
+            .collect::<Result<Vec<_>>>()?;
+
+        (0..self.array.len())
+            .map(|idx| {
+                let mut result = serde_json::Map::with_capacity(vectors.len());
+                for (field, vector) in self.fields.fields().iter().zip(vectors.iter()) {
+                    let field_value = vector.get(idx);
+                    result.insert(
+                        field.name().to_string(),
+                        field_value.try_into().context(SerializeSnafu)?,
+                    );
+                }
+                Ok(result.into())
+            })
+            .collect::<Result<Vec<serde_json::Value>>>()
+    }
+}
+
+impl TryFrom<StructArray> for StructVector {
+    type Error = Error;
+
+    fn try_from(array: StructArray) -> Result<Self> {
+        let fields = match array.data_type() {
+            ArrowDataType::Struct(fields) => StructType::try_from(fields)?,
+            other => ConversionSnafu {
+                from: other.to_string(),
+            }
+            .fail()?,
+        };
+        Ok(Self { array, fields })
+    }
+}
+
+impl ScalarVector for StructVector {
+    type OwnedItem = StructValue;
+    type RefItem<'a> = StructValueRef<'a>;
+    type Iter<'a> = StructIter<'a>;
+    type Builder = StructVectorBuilder;
+
+    fn get_data(&self, idx: usize) -> Option<Self::RefItem<'_>> {
+        if self.array.is_valid(idx) {
+            Some(StructValueRef::Indexed { vector: self, idx })
+        } else {
+            None
+        }
+    }
+
+    fn iter_data(&self) -> Self::Iter<'_> {
+        StructIter::new(self)
+    }
+}
+
+pub struct StructIter<'a> {
+    vector: &'a StructVector,
+    index: usize,
+}
+
+impl<'a> StructIter<'a> {
+    pub fn new(vector: &'a StructVector) -> Self {
+        Self { vector, index: 0 }
+    }
+}
+
+impl<'a> Iterator for StructIter<'a> {
+    type Item = Option<StructValueRef<'a>>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.index < self.vector.len() {
+            let idx = self.index;
+            self.index += 1;
+
+            if self.vector.is_null(idx) {
+                Some(None)
+            } else {
+                let value = StructValueRef::Indexed {
+                    vector: self.vector,
+                    idx,
+                };
+
+                Some(Some(value))
+            }
+        } else {
+            None
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.vector.len(), Some(self.vector.len()))
+    }
+}
+
+pub struct StructVectorBuilder {
+    value_builders: Vec<Box<dyn MutableVector>>,
+    null_buffer: NullBufferBuilder,
+    fields: StructType,
+}
+
+impl StructVectorBuilder {
+    pub fn with_type_and_capacity(fields: StructType, capacity: usize) -> Self {
+        let value_builders = fields
+            .fields()
+            .iter()
+            .map(|f| f.data_type().create_mutable_vector(capacity))
+            .collect();
+        Self {
+            value_builders,
+            null_buffer: NullBufferBuilder::new(capacity),
+            fields,
+        }
+    }
+
+    fn push_struct_value(&mut self, struct_value: &StructValue) -> Result<()> {
+        for (index, value) in struct_value.items().iter().enumerate() {
+            self.value_builders[index].try_push_value_ref(&value.as_value_ref())?;
+        }
+        self.null_buffer.append_non_null();
+
+        Ok(())
+    }
+
+    fn push_null_struct_value(&mut self) {
+        for builder in &mut self.value_builders {
+            builder.push_null();
+        }
+        self.null_buffer.append_null();
+    }
+}
+
+impl MutableVector for StructVectorBuilder {
+    fn data_type(&self) -> ConcreteDataType {
+        ConcreteDataType::struct_datatype(self.fields.clone())
+    }
+
+    fn len(&self) -> usize {
+        self.null_buffer.len()
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn as_mut_any(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    fn to_vector(&mut self) -> VectorRef {
+        Arc::new(self.finish())
+    }
+
+    fn to_vector_cloned(&self) -> VectorRef {
+        Arc::new(self.finish_cloned())
+    }
+
+    fn try_push_value_ref(&mut self, value: &ValueRef) -> Result<()> {
+        if let Some(struct_ref) = value.as_struct()? {
+            match struct_ref {
+                StructValueRef::Indexed { vector, idx } => match vector.get(idx).as_struct()? {
+                    Some(struct_value) => self.push_struct_value(struct_value)?,
+                    None => self.push_null(),
+                },
+                StructValueRef::Ref(val) => self.push_struct_value(val)?,
+                StructValueRef::RefList { val, fields } => {
+                    let struct_value = StructValue::try_new(
+                        val.iter().map(|v| Value::from(v.clone())).collect(),
+                        fields.clone(),
+                    )?;
+                    self.push_struct_value(&struct_value)?;
+                }
+            }
+        } else {
+            self.push_null();
+        }
+
+        Ok(())
+    }
+
+    fn extend_slice_of(&mut self, vector: &dyn Vector, offset: usize, length: usize) -> Result<()> {
+        for idx in offset..offset + length {
+            let value = vector.get_ref(idx);
+            self.try_push_value_ref(&value)?;
+        }
+
+        Ok(())
+    }
+
+    fn push_null(&mut self) {
+        self.push_null_struct_value();
+    }
+}
+
+impl ScalarVectorBuilder for StructVectorBuilder {
+    type VectorType = StructVector;
+
+    fn with_capacity(_capacity: usize) -> Self {
+        panic!("Must use StructVectorBuilder::with_type_capacity()");
+    }
+
+    fn push(&mut self, value: Option<<Self::VectorType as ScalarVector>::RefItem<'_>>) {
+        self.try_push_value_ref(&value.map(ValueRef::Struct).unwrap_or(ValueRef::Null))
+            .unwrap_or_else(|e| {
+                panic!(
+                    "Failed to push value, expect value type {:?}, err:{}",
+                    self.fields, e
+                );
+            });
+    }
+
+    fn finish(&mut self) -> Self::VectorType {
+        let arrays = self
+            .value_builders
+            .iter_mut()
+            .map(|b| b.to_vector().to_arrow_array())
+            .collect();
+        let struct_array = StructArray::new(
+            self.fields.as_arrow_fields(),
+            arrays,
+            self.null_buffer.finish(),
+        );
+
+        StructVector::try_new(self.fields.clone(), struct_array).unwrap()
+    }
+
+    fn finish_cloned(&self) -> Self::VectorType {
+        let arrays = self
+            .value_builders
+            .iter()
+            .map(|b| b.to_vector_cloned().to_arrow_array())
+            .collect();
+
+        let struct_array = StructArray::new(
+            self.fields.as_arrow_fields(),
+            arrays,
+            self.null_buffer.finish_cloned(),
+        );
+        StructVector::try_new(self.fields.clone(), struct_array).unwrap()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::value::tests::*;
+
+    #[test]
+    fn test_struct_vector_builder() {
+        let struct_type = build_struct_type();
+
+        let struct_values = (0..10).map(|_| build_struct_value());
+        let mut builder = StructVectorBuilder::with_type_and_capacity(struct_type.clone(), 20);
+        for value in struct_values {
+            builder.push(Some(StructValueRef::Ref(&value)));
+        }
+
+        builder.push_nulls(5);
+
+        let vector = builder.finish();
+        assert_eq!(
+            vector.data_type(),
+            ConcreteDataType::struct_datatype(struct_type.clone())
+        );
+        assert_eq!(vector.len(), 15);
+        assert_eq!(vector.null_count(), 5);
+
+        let mut null_count = 0;
+        for item in vector.iter_data() {
+            if let Some(value) = item.as_ref() {
+                assert_eq!(value.struct_type(), &struct_type);
+            } else {
+                null_count += 1;
+            }
+        }
+        assert_eq!(5, null_count);
+
+        let value = vector.get(2);
+        if let Value::Struct(struct_value) = value {
+            assert_eq!(struct_value.struct_type(), &struct_type);
+            let mut items = struct_value.items().iter();
+            assert_eq!(items.next(), Some(&Value::Int32(1)));
+            assert_eq!(items.next(), Some(&Value::String("tom".into())));
+            assert_eq!(items.next(), Some(&Value::UInt8(25)));
+            assert_eq!(items.next(), Some(&Value::String("94038".into())));
+            assert_eq!(items.next(), None);
+        } else {
+            panic!("Expected a struct value");
+        }
     }
 }
diff --git a/src/file-engine/src/query/file_stream.rs b/src/file-engine/src/query/file_stream.rs
index df9c018b96..1f26c25493 100644
--- a/src/file-engine/src/query/file_stream.rs
+++ b/src/file-engine/src/query/file_stream.rs
@@ -52,7 +52,7 @@ fn build_record_batch_stream(
     let files = scan_plan_config
         .files
         .iter()
-        .map(|filename| PartitionedFile::new(filename.to_string(), 0))
+        .map(|filename| PartitionedFile::new(filename.clone(), 0))
         .collect::<Vec<_>>();
 
     let config = FileScanConfigBuilder::new(
@@ -122,7 +122,7 @@ fn new_parquet_stream_with_exec_plan(config: &ScanPlanConfig) -> Result<Sendable
     let file_group = FileGroup::new(
         files
             .iter()
-            .map(|filename| PartitionedFile::new(filename.to_string(), 0))
+            .map(|filename| PartitionedFile::new(filename.clone(), 0))
             .collect::<Vec<_>>(),
     );
 
diff --git a/src/flow/src/adapter/flownode_impl.rs b/src/flow/src/adapter/flownode_impl.rs
index a6ab4851c0..b876c0c9e5 100644
--- a/src/flow/src/adapter/flownode_impl.rs
+++ b/src/flow/src/adapter/flownode_impl.rs
@@ -335,7 +335,7 @@ impl FlowDualEngine {
                             .or_else(|| {
                                 Some(
                                     QueryContextBuilder::default()
-                                        .current_catalog(info.catalog_name().to_string())
+                                        .current_catalog(info.catalog_name().clone())
                                         .build(),
                                 )
                             }),
diff --git a/src/flow/src/adapter/util.rs b/src/flow/src/adapter/util.rs
index aaed0b5d28..661b4406a1 100644
--- a/src/flow/src/adapter/util.rs
+++ b/src/flow/src/adapter/util.rs
@@ -193,10 +193,12 @@ pub fn table_info_value_to_relation_desc(
 pub fn from_proto_to_data_type(
     column_schema: &api::v1::ColumnSchema,
 ) -> Result<ConcreteDataType, Error> {
-    let wrapper =
-        ColumnDataTypeWrapper::try_new(column_schema.datatype, column_schema.datatype_extension)
-            .map_err(BoxedError::new)
-            .context(ExternalSnafu)?;
+    let wrapper = ColumnDataTypeWrapper::try_new(
+        column_schema.datatype,
+        column_schema.datatype_extension.clone(),
+    )
+    .map_err(BoxedError::new)
+    .context(ExternalSnafu)?;
     let cdt = ConcreteDataType::from(wrapper);
 
     Ok(cdt)
diff --git a/src/flow/src/batching_mode/task.rs b/src/flow/src/batching_mode/task.rs
index 5436d9a225..2d0ae40bd3 100644
--- a/src/flow/src/batching_mode/task.rs
+++ b/src/flow/src/batching_mode/task.rs
@@ -947,7 +947,7 @@ fn build_pk_from_aggr(plan: &LogicalPlan) -> Result<Option<TableDef>, Error> {
 
     let all_pk_cols: Vec<_> = all_pk_cols
         .into_iter()
-        .filter(|col| first_time_stamp != Some(col.to_string()))
+        .filter(|col| first_time_stamp.as_ref() != Some(col))
         .collect();
 
     Ok(Some(TableDef {
diff --git a/src/flow/src/batching_mode/time_window.rs b/src/flow/src/batching_mode/time_window.rs
index b7a5f5f2cf..410de4a81c 100644
--- a/src/flow/src/batching_mode/time_window.rs
+++ b/src/flow/src/batching_mode/time_window.rs
@@ -210,8 +210,8 @@ impl TimeWindowExpr {
 
             let mut vector = cdt.create_mutable_vector(rows.rows.len());
             for row in rows.rows {
-                let value = pb_value_to_value_ref(&row.values[ts_col_index], &None);
-                vector.try_push_value_ref(value).context(DataTypeSnafu {
+                let value = pb_value_to_value_ref(&row.values[ts_col_index], None);
+                vector.try_push_value_ref(&value).context(DataTypeSnafu {
                     msg: "Failed to convert rows to columns",
                 })?;
             }
@@ -928,13 +928,13 @@ mod test {
                 .await
                 .unwrap();
             let (col_name, lower, upper) = real;
-            let new_sql = if lower.is_some() {
+            let new_sql = if let Some(lower) = lower {
                 let to_df_literal = |value| {
                     let value = Value::from(value);
 
                     value.try_to_scalar_value(&value.data_type()).unwrap()
                 };
-                let lower = to_df_literal(lower.unwrap());
+                let lower = to_df_literal(lower);
                 let upper = to_df_literal(upper.unwrap());
                 let expr = col(&col_name)
                     .gt_eq(lit(lower))
diff --git a/src/flow/src/batching_mode/utils.rs b/src/flow/src/batching_mode/utils.rs
index 2891cf2541..e40e0c5e49 100644
--- a/src/flow/src/batching_mode/utils.rs
+++ b/src/flow/src/batching_mode/utils.rs
@@ -107,6 +107,7 @@ pub async fn sql_to_df_plan(
                     lookback: eval
                         .lookback
                         .unwrap_or_else(|| DEFAULT_LOOKBACK_STRING.to_string()),
+                    alias: eval.alias.clone(),
                 };
 
                 QueryLanguageParser::parse_promql(&promql, &query_ctx)
diff --git a/src/flow/src/compute/render/reduce.rs b/src/flow/src/compute/render/reduce.rs
index 38ea92b7dc..935c29763d 100644
--- a/src/flow/src/compute/render/reduce.rs
+++ b/src/flow/src/compute/render/reduce.rs
@@ -611,7 +611,7 @@ fn reduce_batch_subgraph(
                             i
                         )
                     })?
-                    .try_push_value_ref(v.as_value_ref())
+                    .try_push_value_ref(&v.as_value_ref())
                     .context(DataTypeSnafu {
                         msg: "Failed to push value",
                     })?;
diff --git a/src/flow/src/expr.rs b/src/flow/src/expr.rs
index a57234efb7..c17db3bf7e 100644
--- a/src/flow/src/expr.rs
+++ b/src/flow/src/expr.rs
@@ -122,7 +122,7 @@ impl Batch {
             );
             for (idx, value) in row.iter().enumerate() {
                 builder[idx]
-                    .try_push_value_ref(value.as_value_ref())
+                    .try_push_value_ref(&value.as_value_ref())
                     .context(DataTypeSnafu {
                         msg: "Failed to convert rows to columns",
                     })?;
diff --git a/src/flow/src/expr/df_func.rs b/src/flow/src/expr/df_func.rs
index 1cb5712a23..9093425323 100644
--- a/src/flow/src/expr/df_func.rs
+++ b/src/flow/src/expr/df_func.rs
@@ -136,7 +136,7 @@ impl DfScalarFunction {
         {
             let typ = typ.scalar_type();
             let mut array = typ.create_mutable_vector(1);
-            array.push_value_ref(values[idx].as_value_ref());
+            array.push_value_ref(&values[idx].as_value_ref());
             cols.push(array.to_vector().to_arrow_array());
         }
         let schema = self.df_schema.inner().clone();
diff --git a/src/flow/src/lib.rs b/src/flow/src/lib.rs
index 509fc49123..3556fc32a7 100644
--- a/src/flow/src/lib.rs
+++ b/src/flow/src/lib.rs
@@ -16,7 +16,6 @@
 //! It can transform substrait plan into it's own plan and execute it.
 //! It also contains definition of expression, adapter and plan, and internal state management.
 
-#![feature(let_chains)]
 #![allow(dead_code)]
 #![warn(clippy::missing_docs_in_private_items)]
 #![warn(clippy::too_many_lines)]
diff --git a/src/flow/src/repr.rs b/src/flow/src/repr.rs
index a2db5df1e2..301431aff5 100644
--- a/src/flow/src/repr.rs
+++ b/src/flow/src/repr.rs
@@ -194,7 +194,7 @@ impl From<ProtoRow> for Row {
         Row::pack(
             row.values
                 .iter()
-                .map(|pb_val| -> Value { pb_value_to_value_ref(pb_val, &None).into() }),
+                .map(|pb_val| -> Value { pb_value_to_value_ref(pb_val, None).into() }),
         )
     }
 }
diff --git a/src/flow/src/transform/aggr.rs b/src/flow/src/transform/aggr.rs
index 82d814ed2c..579f0e8ee3 100644
--- a/src/flow/src/transform/aggr.rs
+++ b/src/flow/src/transform/aggr.rs
@@ -208,7 +208,6 @@ impl KeyValPlan {
     ) -> Result<KeyValPlan, Error> {
         let group_expr_val = group_exprs
             .iter()
-            .cloned()
             .map(|expr| expr.expr.clone())
             .collect_vec();
         let output_arity = group_expr_val.len();
diff --git a/src/flow/src/transform/plan.rs b/src/flow/src/transform/plan.rs
index a87dce0d26..cdd558d84d 100644
--- a/src/flow/src/transform/plan.rs
+++ b/src/flow/src/transform/plan.rs
@@ -158,7 +158,7 @@ impl TypedPlan {
             let table_reference = match nt.names.len() {
                 1 => [
                     query_ctx.current_catalog().to_string(),
-                    query_ctx.current_schema().to_string(),
+                    query_ctx.current_schema().clone(),
                     nt.names[0].clone(),
                 ],
                 2 => [
diff --git a/src/frontend/src/heartbeat/tests.rs b/src/frontend/src/heartbeat/tests.rs
index b3aff9e8fd..cf4959ddc7 100644
--- a/src/frontend/src/heartbeat/tests.rs
+++ b/src/frontend/src/heartbeat/tests.rs
@@ -26,8 +26,6 @@ use common_meta::instruction::{CacheIdent, Instruction};
 use common_meta::key::MetadataKey;
 use common_meta::key::schema_name::{SchemaName, SchemaNameKey};
 use common_meta::key::table_info::TableInfoKey;
-use partition::manager::TableRouteCacheInvalidator;
-use table::metadata::TableId;
 use tokio::sync::mpsc;
 
 #[derive(Default)]
@@ -42,17 +40,6 @@ impl KvCacheInvalidator for MockKvCacheInvalidator {
     }
 }
 
-pub struct MockTableRouteCacheInvalidator {
-    inner: Mutex<HashMap<TableId, i32>>,
-}
-
-#[async_trait::async_trait]
-impl TableRouteCacheInvalidator for MockTableRouteCacheInvalidator {
-    async fn invalidate_table_route(&self, table_id: TableId) {
-        let _ = self.inner.lock().unwrap().remove(&table_id);
-    }
-}
-
 pub fn test_message_meta(id: u64, subject: &str, to: &str, from: &str) -> MessageMeta {
     MessageMeta {
         id,
diff --git a/src/frontend/src/instance.rs b/src/frontend/src/instance.rs
index 3e0a22b6d2..062bc0cf95 100644
--- a/src/frontend/src/instance.rs
+++ b/src/frontend/src/instance.rs
@@ -375,7 +375,7 @@ impl Instance {
                 .entry(db_string)
                 .or_default();
             names.iter().for_each(|name| {
-                cache.insert(name.to_string(), false);
+                cache.insert((*name).clone(), false);
             });
             return Ok(false);
         }
@@ -411,13 +411,13 @@ impl Instance {
             ensure!(!(has_prom && has_legacy), OtlpMetricModeIncompatibleSnafu);
             let flag = has_legacy;
             names.iter().for_each(|name| {
-                cache.insert(name.to_string(), flag);
+                cache.insert((*name).clone(), flag);
             });
             Ok(flag)
         } else {
             // no table info, use new mode
             names.iter().for_each(|name| {
-                cache.insert(name.to_string(), false);
+                cache.insert((*name).clone(), false);
             });
             Ok(false)
         }
@@ -448,7 +448,7 @@ fn fast_legacy_check(
         // set cache for all names
         names.iter().for_each(|name| {
             if !cache.contains_key(*name) {
-                cache.insert(name.to_string(), flag);
+                cache.insert((*name).clone(), flag);
             }
         });
         Ok(Some(flag))
@@ -736,8 +736,8 @@ impl PrometheusHandler for Instance {
         interceptor.pre_execute(query, Some(&plan), query_ctx.clone())?;
 
         // Take the EvalStmt from the original QueryStatement and use it to create the CatalogQueryStatement.
-        let query_statement = if let QueryStatement::Promql(eval_stmt) = stmt {
-            CatalogQueryStatement::Promql(eval_stmt)
+        let query_statement = if let QueryStatement::Promql(eval_stmt, alias) = stmt {
+            CatalogQueryStatement::Promql(eval_stmt, alias)
         } else {
             // It should not happen since the query is already parsed successfully.
             return UnexpectedResultSnafu {
diff --git a/src/frontend/src/instance/grpc.rs b/src/frontend/src/instance/grpc.rs
index 0dc14419f2..9eeb57ce01 100644
--- a/src/frontend/src/instance/grpc.rs
+++ b/src/frontend/src/instance/grpc.rs
@@ -135,6 +135,7 @@ impl GrpcQueryHandler for Instance {
                             end: promql.end,
                             step: promql.step,
                             lookback: promql.lookback,
+                            alias: None,
                         };
                         let mut result =
                             SqlQueryHandler::do_promql_query(self, &prom_query, ctx.clone()).await;
diff --git a/src/frontend/src/instance/influxdb.rs b/src/frontend/src/instance/influxdb.rs
index 01c526aba9..1b8e0c9f46 100644
--- a/src/frontend/src/instance/influxdb.rs
+++ b/src/frontend/src/instance/influxdb.rs
@@ -12,16 +12,23 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use api::v1::value::ValueData;
+use api::v1::{ColumnDataType, RowInsertRequests, SemanticType};
 use async_trait::async_trait;
 use auth::{PermissionChecker, PermissionCheckerRef, PermissionReq};
+use catalog::CatalogManagerRef;
 use client::Output;
 use common_error::ext::BoxedError;
-use servers::error::{AuthSnafu, Error, OtherSnafu};
+use common_time::Timestamp;
+use common_time::timestamp::TimeUnit;
+use servers::error::{
+    AuthSnafu, CatalogSnafu, Error, OtherSnafu, TimestampOverflowSnafu, UnexpectedResultSnafu,
+};
 use servers::influxdb::InfluxdbRequest;
 use servers::interceptor::{LineProtocolInterceptor, LineProtocolInterceptorRef};
 use servers::query_handler::InfluxdbLineProtocolHandler;
 use session::context::QueryContextRef;
-use snafu::ResultExt;
+use snafu::{OptionExt, ResultExt};
 
 use crate::instance::Instance;
 
@@ -42,6 +49,12 @@ impl InfluxdbLineProtocolHandler for Instance {
         interceptor_ref.pre_execute(&request.lines, ctx.clone())?;
 
         let requests = request.try_into()?;
+
+        let aligner = InfluxdbLineTimestampAligner {
+            catalog_manager: self.catalog_manager(),
+        };
+        let requests = aligner.align_timestamps(requests, &ctx).await?;
+
         let requests = interceptor_ref
             .post_lines_conversion(requests, ctx.clone())
             .await?;
@@ -64,3 +77,109 @@ impl InfluxdbLineProtocolHandler for Instance {
             .context(servers::error::ExecuteGrpcQuerySnafu)
     }
 }
+
+/// Align the timestamp precisions in Influxdb lines (after they are converted to the GRPC row
+/// inserts) to the time index columns' time units of the created tables (if there are any).
+struct InfluxdbLineTimestampAligner<'a> {
+    catalog_manager: &'a CatalogManagerRef,
+}
+
+impl InfluxdbLineTimestampAligner<'_> {
+    async fn align_timestamps(
+        &self,
+        requests: RowInsertRequests,
+        query_context: &QueryContextRef,
+    ) -> servers::error::Result<RowInsertRequests> {
+        let mut inserts = requests.inserts;
+        for insert in inserts.iter_mut() {
+            let Some(rows) = &mut insert.rows else {
+                continue;
+            };
+
+            let Some(target_time_unit) = self
+                .catalog_manager
+                .table(
+                    query_context.current_catalog(),
+                    &query_context.current_schema(),
+                    &insert.table_name,
+                    Some(query_context),
+                )
+                .await
+                .context(CatalogSnafu)?
+                .map(|x| x.schema())
+                .and_then(|schema| {
+                    schema.timestamp_column().map(|col| {
+                        col.data_type
+                            .as_timestamp()
+                            .expect("Time index column is not of timestamp type?!")
+                            .unit()
+                    })
+                })
+            else {
+                continue;
+            };
+
+            let target_timestamp_type = match target_time_unit {
+                TimeUnit::Second => ColumnDataType::TimestampSecond,
+                TimeUnit::Millisecond => ColumnDataType::TimestampMillisecond,
+                TimeUnit::Microsecond => ColumnDataType::TimestampMicrosecond,
+                TimeUnit::Nanosecond => ColumnDataType::TimestampNanosecond,
+            };
+            let Some(to_be_aligned) = rows.schema.iter().enumerate().find_map(|(i, x)| {
+                if x.semantic_type() == SemanticType::Timestamp
+                    && x.datatype() != target_timestamp_type
+                {
+                    Some(i)
+                } else {
+                    None
+                }
+            }) else {
+                continue;
+            };
+
+            // Indexing safety: `to_be_aligned` is guaranteed to be a valid index because it's got
+            // from "enumerate" the schema vector above.
+            rows.schema[to_be_aligned].datatype = target_timestamp_type as i32;
+
+            for row in rows.rows.iter_mut() {
+                let Some(time_value) = row
+                    .values
+                    .get_mut(to_be_aligned)
+                    .and_then(|x| x.value_data.as_mut())
+                else {
+                    continue;
+                };
+                *time_value = align_time_unit(time_value, target_time_unit)?;
+            }
+        }
+        Ok(RowInsertRequests { inserts })
+    }
+}
+
+fn align_time_unit(value: &ValueData, target: TimeUnit) -> servers::error::Result<ValueData> {
+    let timestamp = match value {
+        ValueData::TimestampSecondValue(x) => Timestamp::new_second(*x),
+        ValueData::TimestampMillisecondValue(x) => Timestamp::new_millisecond(*x),
+        ValueData::TimestampMicrosecondValue(x) => Timestamp::new_microsecond(*x),
+        ValueData::TimestampNanosecondValue(x) => Timestamp::new_nanosecond(*x),
+        _ => {
+            return UnexpectedResultSnafu {
+                reason: format!("Timestamp value '{:?}' is not of timestamp type!", value),
+            }
+            .fail();
+        }
+    };
+
+    let timestamp = timestamp
+        .convert_to(target)
+        .with_context(|| TimestampOverflowSnafu {
+            error: format!("{:?} convert to {}", timestamp, target),
+        })?;
+
+    Ok(match target {
+        TimeUnit::Second => ValueData::TimestampSecondValue(timestamp.value()),
+        TimeUnit::Millisecond => ValueData::TimestampMillisecondValue(timestamp.value()),
+        TimeUnit::Microsecond => ValueData::TimestampMicrosecondValue(timestamp.value()),
+        TimeUnit::Nanosecond => ValueData::TimestampNanosecondValue(timestamp.value()),
+    })
+}
diff --git a/src/frontend/src/instance/otlp.rs b/src/frontend/src/instance/otlp.rs
index 7e4a867730..f0b152e08d 100644
--- a/src/frontend/src/instance/otlp.rs
+++ b/src/frontend/src/instance/otlp.rs
@@ -106,7 +106,7 @@ impl OpenTelemetryProtocolHandler for Instance {
                 .extension(PHYSICAL_TABLE_PARAM)
                 .unwrap_or(GREPTIME_PHYSICAL_TABLE)
                 .to_string();
-            self.handle_metric_row_inserts(requests, ctx, physical_table.to_string())
+            self.handle_metric_row_inserts(requests, ctx, physical_table.clone())
                 .await
                 .map_err(BoxedError::new)
                 .context(error::ExecuteGrpcQuerySnafu)
diff --git a/src/frontend/src/instance/prom_store.rs b/src/frontend/src/instance/prom_store.rs
index 5c70b484dd..e9c9499372 100644
--- a/src/frontend/src/instance/prom_store.rs
+++ b/src/frontend/src/instance/prom_store.rs
@@ -192,7 +192,7 @@ impl PromStoreProtocolHandler for Instance {
                 .extension(PHYSICAL_TABLE_PARAM)
                 .unwrap_or(GREPTIME_PHYSICAL_TABLE)
                 .to_string();
-            self.handle_metric_row_inserts(request, ctx.clone(), physical_table.to_string())
+            self.handle_metric_row_inserts(request, ctx.clone(), physical_table.clone())
                 .await
                 .map_err(BoxedError::new)
                 .context(error::ExecuteGrpcQuerySnafu)?
diff --git a/src/frontend/src/limiter.rs b/src/frontend/src/limiter.rs
index 7b5eb7bf59..8c728c42c7 100644
--- a/src/frontend/src/limiter.rs
+++ b/src/frontend/src/limiter.rs
@@ -87,7 +87,7 @@ impl Limiter {
         for insert in &request.inserts {
             for column in &insert.columns {
                 if let Some(values) = &column.values {
-                    size += self.size_of_column_values(values);
+                    size += Self::size_of_column_values(values);
                 }
             }
         }
@@ -104,7 +104,7 @@ impl Limiter {
                 for row in &rows.rows {
                     for value in &row.values {
                         if let Some(value) = &value.value_data {
-                            size += self.size_of_value_data(value);
+                            size += Self::size_of_value_data(value);
                         }
                     }
                 }
@@ -113,7 +113,7 @@ impl Limiter {
         size
     }
 
-    fn size_of_column_values(&self, values: &Values) -> usize {
+    fn size_of_column_values(values: &Values) -> usize {
         let mut size: usize = 0;
         size += values.i8_values.len() * size_of::<i32>();
         size += values.i16_values.len() * size_of::<i32>();
@@ -146,10 +146,41 @@ impl Limiter {
         size += values.interval_day_time_values.len() * size_of::<i64>();
         size += values.interval_month_day_nano_values.len() * size_of::<IntervalMonthDayNano>();
         size += values.decimal128_values.len() * size_of::<Decimal128>();
+        size += values
+            .list_values
+            .iter()
+            .map(|v| {
+                v.items
+                    .iter()
+                    .map(|item| {
+                        item.value_data
+                            .as_ref()
+                            .map(Self::size_of_value_data)
+                            .unwrap_or(0)
+                    })
+                    .sum::<usize>()
+            })
+            .sum::<usize>();
+        size += values
+            .struct_values
+            .iter()
+            .map(|v| {
+                v.items
+                    .iter()
+                    .map(|item| {
+                        item.value_data
+                            .as_ref()
+                            .map(Self::size_of_value_data)
+                            .unwrap_or(0)
+                    })
+                    .sum::<usize>()
+            })
+            .sum::<usize>();
+
         size
     }
 
-    fn size_of_value_data(&self, value: &ValueData) -> usize {
+    fn size_of_value_data(value: &ValueData) -> usize {
         match value {
             ValueData::I8Value(_) => size_of::<i32>(),
             ValueData::I16Value(_) => size_of::<i32>(),
@@ -178,6 +209,26 @@ impl Limiter {
             ValueData::IntervalDayTimeValue(_) => size_of::<i64>(),
             ValueData::IntervalMonthDayNanoValue(_) => size_of::<IntervalMonthDayNano>(),
             ValueData::Decimal128Value(_) => size_of::<Decimal128>(),
+            ValueData::ListValue(list_values) => list_values
+                .items
+                .iter()
+                .map(|item| {
+                    item.value_data
+                        .as_ref()
+                        .map(Self::size_of_value_data)
+                        .unwrap_or(0)
+                })
+                .sum(),
+            ValueData::StructValue(struct_values) => struct_values
+                .items
+                .iter()
+                .map(|item| {
+                    item.value_data
+                        .as_ref()
+                        .map(Self::size_of_value_data)
+                        .unwrap_or(0)
+                })
+                .sum(),
         }
     }
 }
diff --git a/src/index/src/bloom_filter/creator.rs b/src/index/src/bloom_filter/creator.rs
index 166b4ebc30..5a9b5a0b36 100644
--- a/src/index/src/bloom_filter/creator.rs
+++ b/src/index/src/bloom_filter/creator.rs
@@ -137,7 +137,10 @@ impl BloomFilterCreator {
             self.global_memory_usage
                 .fetch_add(mem_diff, Ordering::Relaxed);
 
-            if self.accumulated_row_count % self.rows_per_segment == 0 {
+            if self
+                .accumulated_row_count
+                .is_multiple_of(self.rows_per_segment)
+            {
                 self.finalize_segment().await?;
                 self.finalized_row_count = self.accumulated_row_count;
             }
@@ -163,7 +166,10 @@ impl BloomFilterCreator {
         self.global_memory_usage
             .fetch_add(mem_diff, Ordering::Relaxed);
 
-        if self.accumulated_row_count % self.rows_per_segment == 0 {
+        if self
+            .accumulated_row_count
+            .is_multiple_of(self.rows_per_segment)
+        {
             self.finalize_segment().await?;
             self.finalized_row_count = self.accumulated_row_count;
         }
diff --git a/src/index/src/inverted_index/search/index_apply.rs b/src/index/src/inverted_index/search/index_apply.rs
index 65f9331ebb..a80f102e02 100644
--- a/src/index/src/inverted_index/search/index_apply.rs
+++ b/src/index/src/inverted_index/search/index_apply.rs
@@ -43,6 +43,7 @@ pub struct ApplyOutput {
 pub trait IndexApplier: Send + Sync {
     /// Applies the predefined predicates to the data read by the given index reader, returning
     /// a list of relevant indices (e.g., post IDs, group IDs, row IDs).
+    #[allow(unused_parens)]
     async fn apply<'a>(
         &self,
         context: SearchContext,
diff --git a/src/log-store/src/kafka/client_manager.rs b/src/log-store/src/kafka/client_manager.rs
index de87e6f376..8a19238356 100644
--- a/src/log-store/src/kafka/client_manager.rs
+++ b/src/log-store/src/kafka/client_manager.rs
@@ -214,14 +214,14 @@ mod tests {
 
         // Gets all clients sequentially.
         for (_, topic) in region_topic {
-            let provider = Arc::new(KafkaProvider::new(topic.to_string()));
+            let provider = Arc::new(KafkaProvider::new(topic.clone()));
             manager.get_or_insert(&provider).await.unwrap();
         }
 
         // Ensures all clients exist.
         let client_pool = manager.instances.read().await;
         let all_exist = topics.iter().all(|topic| {
-            let provider = Arc::new(KafkaProvider::new(topic.to_string()));
+            let provider = Arc::new(KafkaProvider::new(topic.clone()));
             client_pool.contains_key(&provider)
         });
         assert!(all_exist);
@@ -259,7 +259,7 @@ mod tests {
         // Ensures all clients exist.
         let client_pool = manager.instances.read().await;
         let all_exist = topics.iter().all(|topic| {
-            let provider = Arc::new(KafkaProvider::new(topic.to_string()));
+            let provider = Arc::new(KafkaProvider::new(topic.clone()));
             client_pool.contains_key(&provider)
         });
         assert!(all_exist);
diff --git a/src/log-store/src/kafka/index/encoder.rs b/src/log-store/src/kafka/index/encoder.rs
index 37d8c8e7ef..b8d9e09bfe 100644
--- a/src/log-store/src/kafka/index/encoder.rs
+++ b/src/log-store/src/kafka/index/encoder.rs
@@ -104,7 +104,7 @@ impl IndexEncoder for JsonIndexEncoder {
         self.buf
             .lock()
             .unwrap()
-            .insert(provider.topic.to_string(), region_index);
+            .insert(provider.topic.clone(), region_index);
     }
 
     fn finish(&self) -> Result<Vec<u8>> {
diff --git a/src/log-store/src/kafka/periodic_offset_fetcher.rs b/src/log-store/src/kafka/periodic_offset_fetcher.rs
index caecfc25b5..4063fb7510 100644
--- a/src/log-store/src/kafka/periodic_offset_fetcher.rs
+++ b/src/log-store/src/kafka/periodic_offset_fetcher.rs
@@ -100,7 +100,7 @@ mod tests {
         fetcher.run().await;
 
         let topic = topics[0].clone();
-        let provider = Arc::new(KafkaProvider::new(topic.to_string()));
+        let provider = Arc::new(KafkaProvider::new(topic.clone()));
         let producer = manager
             .get_or_insert(&provider)
             .await
diff --git a/src/log-store/src/lib.rs b/src/log-store/src/lib.rs
index a119aac390..1151654dbe 100644
--- a/src/log-store/src/lib.rs
+++ b/src/log-store/src/lib.rs
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(let_chains)]
 #![feature(io_error_more)]
 #![feature(assert_matches)]
 
diff --git a/src/log-store/src/raft_engine.rs b/src/log-store/src/raft_engine.rs
index fdd88a49f1..fb9445bfe9 100644
--- a/src/log-store/src/raft_engine.rs
+++ b/src/log-store/src/raft_engine.rs
@@ -23,7 +23,7 @@ use store_api::logstore::entry::{Entry, NaiveEntry};
 use store_api::logstore::provider::Provider;
 use store_api::storage::RegionId;
 
-#[allow(renamed_and_removed_lints)]
+#[allow(renamed_and_removed_lints, mismatched_lifetime_syntaxes, unused_parens)]
 pub mod protos {
     include!(concat!(env!("OUT_DIR"), concat!("/", "protos/", "mod.rs")));
 }
diff --git a/src/log-store/src/raft_engine/backend.rs b/src/log-store/src/raft_engine/backend.rs
index 398796c2d6..461465cf18 100644
--- a/src/log-store/src/raft_engine/backend.rs
+++ b/src/log-store/src/raft_engine/backend.rs
@@ -71,7 +71,7 @@ fn ensure_dir(dir: &str) -> error::Result<()> {
 impl RaftEngineBackend {
     pub fn try_open_with_cfg(dir: String, config: &KvBackendConfig) -> error::Result<Self> {
         let cfg = Config {
-            dir: dir.to_string(),
+            dir: dir.clone(),
             purge_threshold: ReadableSize(config.purge_threshold.0),
             recovery_mode: RecoveryMode::TolerateTailCorruption,
             batch_compression_threshold: ReadableSize::kb(8),
diff --git a/src/meta-client/src/client/ask_leader.rs b/src/meta-client/src/client/ask_leader.rs
index ed7062234a..95d7851b95 100644
--- a/src/meta-client/src/client/ask_leader.rs
+++ b/src/meta-client/src/client/ask_leader.rs
@@ -106,7 +106,7 @@ impl AskLeader {
             let mut client = self.create_asker(addr)?;
             let tx_clone = tx.clone();
             let req = req.clone();
-            let addr = addr.to_string();
+            let addr = addr.clone();
             tokio::spawn(async move {
                 match client.ask_leader(req).await {
                     Ok(res) => {
diff --git a/src/meta-client/src/error.rs b/src/meta-client/src/error.rs
index ad803fc74a..302d95a0e5 100644
--- a/src/meta-client/src/error.rs
+++ b/src/meta-client/src/error.rs
@@ -16,7 +16,7 @@ use common_error::define_from_tonic_status;
 use common_error::ext::ErrorExt;
 use common_error::status_code::StatusCode;
 use common_macro::stack_trace_debug;
-use snafu::{Location, Snafu, location};
+use snafu::{Location, Snafu};
 
 #[derive(Snafu)]
 #[snafu(visibility(pub))]
diff --git a/src/meta-srv/src/events/region_migration_event.rs b/src/meta-srv/src/events/region_migration_event.rs
index 192231812c..3fc8500599 100644
--- a/src/meta-srv/src/events/region_migration_event.rs
+++ b/src/meta-srv/src/events/region_migration_event.rs
@@ -142,9 +142,9 @@ impl Event for RegionMigrationEvent {
                 ValueData::U32Value(self.region_number).into(),
                 ValueData::StringValue(self.trigger_reason.to_string()).into(),
                 ValueData::U64Value(self.src_node_id).into(),
-                ValueData::StringValue(self.src_peer_addr.to_string()).into(),
+                ValueData::StringValue(self.src_peer_addr.clone()).into(),
                 ValueData::U64Value(self.dst_node_id).into(),
-                ValueData::StringValue(self.dst_peer_addr.to_string()).into(),
+                ValueData::StringValue(self.dst_peer_addr.clone()).into(),
             ],
         })
     }
diff --git a/src/meta-srv/src/handler/persist_stats_handler.rs b/src/meta-srv/src/handler/persist_stats_handler.rs
index f4563640dd..1dc81f49eb 100644
--- a/src/meta-srv/src/handler/persist_stats_handler.rs
+++ b/src/meta-srv/src/handler/persist_stats_handler.rs
@@ -90,7 +90,7 @@ fn compute_persist_region_stat(
     datanode_id: DatanodeId,
     timestamp_millis: i64,
     persisted_region_stat: Option<PersistedRegionStat>,
-) -> PersistRegionStat {
+) -> PersistRegionStat<'_> {
     let write_bytes_delta = persisted_region_stat
         .and_then(|persisted_region_stat| {
             region_stat
diff --git a/src/meta-srv/src/key/datanode.rs b/src/meta-srv/src/key/datanode.rs
index 056cfa95b9..1557366b26 100644
--- a/src/meta-srv/src/key/datanode.rs
+++ b/src/meta-srv/src/key/datanode.rs
@@ -26,13 +26,11 @@ use crate::error::Result;
 pub(crate) const DATANODE_LEASE_PREFIX: &str = "__meta_datanode_lease";
 const INACTIVE_REGION_PREFIX: &str = "__meta_inactive_region";
 
-const DATANODE_STAT_PREFIX: &str = "__meta_datanode_stat";
-
 lazy_static! {
     pub(crate) static ref DATANODE_LEASE_KEY_PATTERN: Regex =
         Regex::new(&format!("^{DATANODE_LEASE_PREFIX}-([0-9]+)-([0-9]+)$")).unwrap();
     static ref DATANODE_STAT_KEY_PATTERN: Regex =
-        Regex::new(&format!("^{DATANODE_STAT_PREFIX}-([0-9]+)-([0-9]+)$")).unwrap();
+        Regex::new("^__meta_datanode_stat-([0-9]+)-([0-9]+)$").unwrap();
     static ref INACTIVE_REGION_KEY_PATTERN: Regex = Regex::new(&format!(
         "^{INACTIVE_REGION_PREFIX}-([0-9]+)-([0-9]+)-([0-9]+)$"
     ))
diff --git a/src/meta-srv/src/lib.rs b/src/meta-srv/src/lib.rs
index c2a3de9544..71d57ca83f 100644
--- a/src/meta-srv/src/lib.rs
+++ b/src/meta-srv/src/lib.rs
@@ -12,11 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(result_flattening)]
 #![feature(assert_matches)]
 #![feature(hash_set_entry)]
-#![feature(let_chains)]
-#![feature(duration_constructors_lite)]
 #![feature(duration_constructors)]
 #![feature(string_from_utf8_lossy_owned)]
 
diff --git a/src/meta-srv/src/metasrv/builder.rs b/src/meta-srv/src/metasrv/builder.rs
index d55e2bb7bf..9cc0b8cc72 100644
--- a/src/meta-srv/src/metasrv/builder.rs
+++ b/src/meta-srv/src/metasrv/builder.rs
@@ -192,8 +192,8 @@ impl MetasrvBuilder {
         let in_memory = in_memory.unwrap_or_else(|| Arc::new(MemoryKvBackend::new()));
 
         let state = Arc::new(RwLock::new(match election {
-            None => State::leader(options.grpc.server_addr.to_string(), true),
-            Some(_) => State::follower(options.grpc.server_addr.to_string()),
+            None => State::leader(options.grpc.server_addr.clone(), true),
+            Some(_) => State::follower(options.grpc.server_addr.clone()),
         }));
 
         let leader_cached_kv_backend = Arc::new(LeaderCachedKvBackend::new(
diff --git a/src/meta-srv/src/procedure/region_migration/test_util.rs b/src/meta-srv/src/procedure/region_migration/test_util.rs
index 1c927ca25f..a44c3a20c6 100644
--- a/src/meta-srv/src/procedure/region_migration/test_util.rs
+++ b/src/meta-srv/src/procedure/region_migration/test_util.rs
@@ -127,12 +127,12 @@ impl TestingEnv {
             volatile_ctx: Default::default(),
             in_memory_key: Arc::new(MemoryKvBackend::default()),
             mailbox: self.mailbox_ctx.mailbox().clone(),
-            server_addr: self.server_addr.to_string(),
+            server_addr: self.server_addr.clone(),
             region_failure_detector_controller: Arc::new(NoopRegionFailureDetectorControl),
             cache_invalidator: Arc::new(MetasrvCacheInvalidator::new(
                 self.mailbox_ctx.mailbox().clone(),
                 MetasrvInfo {
-                    server_addr: self.server_addr.to_string(),
+                    server_addr: self.server_addr.clone(),
                 },
             )),
         }
diff --git a/src/meta-srv/src/procedure/region_migration/update_metadata/upgrade_candidate_region.rs b/src/meta-srv/src/procedure/region_migration/update_metadata/upgrade_candidate_region.rs
index 54948ab0c8..7352336d86 100644
--- a/src/meta-srv/src/procedure/region_migration/update_metadata/upgrade_candidate_region.rs
+++ b/src/meta-srv/src/procedure/region_migration/update_metadata/upgrade_candidate_region.rs
@@ -161,8 +161,8 @@ impl UpdateMetadata {
             .update_table_route(
                 region_id.table_id(),
                 RegionInfo {
-                    engine: engine.to_string(),
-                    region_storage_path: region_storage_path.to_string(),
+                    engine: engine.clone(),
+                    region_storage_path: region_storage_path.clone(),
                     region_options: region_options.clone(),
                     region_wal_options: region_wal_options.clone(),
                 },
diff --git a/src/meta-srv/src/region/failure_detector.rs b/src/meta-srv/src/region/failure_detector.rs
index 697db5c43b..58a7a44ffb 100644
--- a/src/meta-srv/src/region/failure_detector.rs
+++ b/src/meta-srv/src/region/failure_detector.rs
@@ -74,7 +74,7 @@ impl RegionFailureDetector {
     }
 
     /// Returns a [FailureDetectorEntry] iterator.
-    pub(crate) fn iter(&self) -> impl Iterator<Item = FailureDetectorEntry> + '_ {
+    pub(crate) fn iter(&self) -> impl Iterator<Item = FailureDetectorEntry<'_>> + '_ {
         self.detectors
             .iter()
             .map(move |e| FailureDetectorEntry { e })
diff --git a/src/meta-srv/src/service/cluster.rs b/src/meta-srv/src/service/cluster.rs
index f10d2fded0..392268ff6d 100644
--- a/src/meta-srv/src/service/cluster.rs
+++ b/src/meta-srv/src/service/cluster.rs
@@ -17,7 +17,6 @@ use api::v1::meta::{
     MetasrvPeersRequest, MetasrvPeersResponse, RangeRequest as PbRangeRequest,
     RangeResponse as PbRangeResponse, cluster_server,
 };
-use common_telemetry::warn;
 use snafu::ResultExt;
 use tonic::Request;
 
diff --git a/src/meta-srv/src/service/procedure.rs b/src/meta-srv/src/service/procedure.rs
index d3cffbc86c..dde3fb6a37 100644
--- a/src/meta-srv/src/service/procedure.rs
+++ b/src/meta-srv/src/service/procedure.rs
@@ -25,7 +25,6 @@ use api::v1::meta::{
 use common_meta::procedure_executor::ExecutorContext;
 use common_meta::rpc::ddl::{DdlTask, SubmitDdlTaskRequest};
 use common_meta::rpc::procedure;
-use common_telemetry::warn;
 use snafu::{OptionExt, ResultExt};
 use table::table_reference::TableReference;
 use tonic::Request;
diff --git a/src/meta-srv/src/state.rs b/src/meta-srv/src/state.rs
index a28305c4ce..4d062c0b2e 100644
--- a/src/meta-srv/src/state.rs
+++ b/src/meta-srv/src/state.rs
@@ -94,7 +94,7 @@ pub fn become_leader(enable_leader_cache: bool) -> impl FnOnce(&State) -> State
     move |prev| match prev {
         State::Leader(leader) => State::Leader(LeaderState { ..leader.clone() }),
         State::Follower(follower) => State::Leader(LeaderState {
-            server_addr: follower.server_addr.to_string(),
+            server_addr: follower.server_addr.clone(),
             enable_leader_cache,
         }),
     }
@@ -103,7 +103,7 @@ pub fn become_leader(enable_leader_cache: bool) -> impl FnOnce(&State) -> State
 pub fn become_follower() -> impl FnOnce(&State) -> State {
     move |prev| match prev {
         State::Leader(leader) => State::Follower(FollowerState {
-            server_addr: leader.server_addr.to_string(),
+            server_addr: leader.server_addr.clone(),
         }),
         State::Follower(follower) => State::Follower(FollowerState { ..follower.clone() }),
     }
diff --git a/src/meta-srv/src/utils/postgres.rs b/src/meta-srv/src/utils/postgres.rs
index ebccd068c4..e7dfd59383 100644
--- a/src/meta-srv/src/utils/postgres.rs
+++ b/src/meta-srv/src/utils/postgres.rs
@@ -54,7 +54,7 @@ pub async fn create_postgres_pool(
     let postgres_url = store_addrs.first().context(error::InvalidArgumentsSnafu {
         err_msg: "empty store addrs",
     })?;
-    cfg.url = Some(postgres_url.to_string());
+    cfg.url = Some(postgres_url.clone());
 
     let pool = if let Some(tls_config) = tls_config {
         let pg_tls_config = convert_tls_option(&tls_config);
diff --git a/src/metric-engine/src/engine/create.rs b/src/metric-engine/src/engine/create.rs
index 7f579023b2..c506c0e2b4 100644
--- a/src/metric-engine/src/engine/create.rs
+++ b/src/metric-engine/src/engine/create.rs
@@ -298,7 +298,7 @@ impl MetricEngineInner {
             .collect::<HashMap<_, _>>();
         let logical_regions = requests
             .iter()
-            .map(|(region_id, _)| (*region_id))
+            .map(|(region_id, _)| *region_id)
             .collect::<Vec<_>>();
         let logical_region_columns = requests.iter().map(|(region_id, request)| {
             (
@@ -398,9 +398,9 @@ impl MetricEngineInner {
                     }
                 ),
                 SemanticType::Field => {
-                    if field_col.is_some() {
+                    if let Some(field_col) = field_col {
                         MultipleFieldColumnSnafu {
-                            previous: field_col.unwrap().column_schema.name.clone(),
+                            previous: field_col.column_schema.name.clone(),
                             current: col.column_schema.name.clone(),
                         }
                         .fail()?;
@@ -609,7 +609,7 @@ pub(crate) fn region_options_for_metadata_region(
     metadata_region_options.insert(TTL_KEY.to_string(), FOREVER.to_string());
 
     if let Some(wal_options) = original.get(WAL_OPTIONS_KEY) {
-        metadata_region_options.insert(WAL_OPTIONS_KEY.to_string(), wal_options.to_string());
+        metadata_region_options.insert(WAL_OPTIONS_KEY.to_string(), wal_options.clone());
     }
 
     metadata_region_options
diff --git a/src/metric-engine/src/engine/create/extract_new_columns.rs b/src/metric-engine/src/engine/create/extract_new_columns.rs
index 84cdf5dc19..b3eabd5706 100644
--- a/src/metric-engine/src/engine/create/extract_new_columns.rs
+++ b/src/metric-engine/src/engine/create/extract_new_columns.rs
@@ -37,7 +37,7 @@ pub fn extract_new_columns<'a>(
                 ensure!(
                     col.semantic_type != SemanticType::Field,
                     AddingFieldColumnSnafu {
-                        name: col.column_schema.name.to_string(),
+                        name: col.column_schema.name.clone(),
                     }
                 );
                 new_column_names.insert(&col.column_schema.name);
diff --git a/src/metric-engine/src/lib.rs b/src/metric-engine/src/lib.rs
index 7722f3acd1..30daa80b91 100644
--- a/src/metric-engine/src/lib.rs
+++ b/src/metric-engine/src/lib.rs
@@ -50,7 +50,6 @@
 //!              └─────────────────────┘
 //! ```
 
-#![feature(let_chains)]
 #![feature(assert_matches)]
 
 pub mod config;
diff --git a/src/metric-engine/src/metadata_region.rs b/src/metric-engine/src/metadata_region.rs
index d909f54694..d2d53306ba 100644
--- a/src/metric-engine/src/metadata_region.rs
+++ b/src/metric-engine/src/metadata_region.rs
@@ -431,7 +431,7 @@ impl MetadataRegion {
             if !k.starts_with(prefix) {
                 break;
             }
-            result.insert(k.to_string(), v.to_string());
+            result.insert(k.clone(), v.clone());
         }
         Ok(result)
     }
@@ -530,7 +530,7 @@ impl MetadataRegion {
             .map(|key| {
                 row(vec![
                     ValueData::TimestampMillisecondValue(0),
-                    ValueData::StringValue(key.to_string()),
+                    ValueData::StringValue(key.clone()),
                 ])
             })
             .collect();
diff --git a/src/metric-engine/src/row_modifier.rs b/src/metric-engine/src/row_modifier.rs
index 4adcc2e777..4759a76215 100644
--- a/src/metric-engine/src/row_modifier.rs
+++ b/src/metric-engine/src/row_modifier.rs
@@ -82,11 +82,11 @@ impl RowModifier {
             let internal_columns = [
                 (
                     ReservedColumnId::table_id(),
-                    api::helper::pb_value_to_value_ref(&table_id, &None),
+                    api::helper::pb_value_to_value_ref(&table_id, None),
                 ),
                 (
                     ReservedColumnId::tsid(),
-                    api::helper::pb_value_to_value_ref(&tsid, &None),
+                    api::helper::pb_value_to_value_ref(&tsid, None),
                 ),
             ];
             self.codec
@@ -278,7 +278,7 @@ impl RowsIter {
     }
 
     /// Returns the iterator of rows.
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = RowIter> {
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = RowIter<'_>> {
         self.rows.rows.iter_mut().map(|row| RowIter {
             row,
             index: &self.index,
@@ -315,7 +315,7 @@ impl RowIter<'_> {
     }
 
     /// Returns the primary keys.
-    pub fn primary_keys(&self) -> impl Iterator<Item = (ColumnId, ValueRef)> {
+    pub fn primary_keys(&self) -> impl Iterator<Item = (ColumnId, ValueRef<'_>)> {
         self.index.indices[..self.index.num_primary_key_column]
             .iter()
             .map(|idx| {
@@ -323,7 +323,7 @@ impl RowIter<'_> {
                     idx.column_id,
                     api::helper::pb_value_to_value_ref(
                         &self.row.values[idx.index],
-                        &self.schema[idx.index].datatype_extension,
+                        self.schema[idx.index].datatype_extension.as_ref(),
                     ),
                 )
             })
diff --git a/src/mito-codec/benches/bench_sparse_encoding.rs b/src/mito-codec/benches/bench_sparse_encoding.rs
index c65a480293..5ad8964c0c 100644
--- a/src/mito-codec/benches/bench_sparse_encoding.rs
+++ b/src/mito-codec/benches/bench_sparse_encoding.rs
@@ -46,7 +46,7 @@ fn encode_sparse(c: &mut Criterion) {
         b.iter(|| {
             let mut buffer = Vec::new();
             codec
-                .encode_to_vec(internal_columns.into_iter(), &mut buffer)
+                .encode_to_vec(internal_columns.clone().into_iter(), &mut buffer)
                 .unwrap();
             codec
                 .encode_to_vec(
diff --git a/src/mito-codec/src/index.rs b/src/mito-codec/src/index.rs
index b6ab84f06c..e95f1a789f 100644
--- a/src/mito-codec/src/index.rs
+++ b/src/mito-codec/src/index.rs
@@ -160,7 +160,7 @@ mod tests {
 
     #[test]
     fn test_decode_primary_key_basic() {
-        let tag_columns = vec![
+        let tag_columns = [
             ColumnMetadata {
                 column_schema: ColumnSchema::new("tag0", ConcreteDataType::string_datatype(), true),
                 semantic_type: api::v1::SemanticType::Tag,
diff --git a/src/mito-codec/src/key_values.rs b/src/mito-codec/src/key_values.rs
index 9d26eeb56b..ffe27d522c 100644
--- a/src/mito-codec/src/key_values.rs
+++ b/src/mito-codec/src/key_values.rs
@@ -56,7 +56,7 @@ impl KeyValues {
     }
 
     /// Returns a key value iterator.
-    pub fn iter(&self) -> impl Iterator<Item = KeyValue> {
+    pub fn iter(&self) -> impl Iterator<Item = KeyValue<'_>> {
         let rows = self.mutation.rows.as_ref().unwrap();
         let schema = &rows.schema;
         rows.rows.iter().enumerate().map(|(idx, row)| {
@@ -130,7 +130,7 @@ impl<'a> KeyValuesRef<'a> {
     }
 
     /// Returns a key value iterator.
-    pub fn iter(&self) -> impl Iterator<Item = KeyValue> {
+    pub fn iter(&self) -> impl Iterator<Item = KeyValue<'_>> {
         let rows = self.mutation.rows.as_ref().unwrap();
         let schema = &rows.schema;
         rows.rows.iter().enumerate().map(|(idx, row)| {
@@ -199,38 +199,38 @@ impl KeyValue<'_> {
     }
 
     /// Get primary key columns.
-    pub fn primary_keys(&self) -> impl Iterator<Item = ValueRef> {
+    pub fn primary_keys(&self) -> impl Iterator<Item = ValueRef<'_>> {
         self.helper.indices[..self.helper.num_primary_key_column]
             .iter()
             .map(|idx| match idx {
                 Some(i) => api::helper::pb_value_to_value_ref(
                     &self.row.values[*i],
-                    &self.schema[*i].datatype_extension,
+                    self.schema[*i].datatype_extension.as_ref(),
                 ),
                 None => ValueRef::Null,
             })
     }
 
     /// Get field columns.
-    pub fn fields(&self) -> impl Iterator<Item = ValueRef> {
+    pub fn fields(&self) -> impl Iterator<Item = ValueRef<'_>> {
         self.helper.indices[self.helper.num_primary_key_column + 1..]
             .iter()
             .map(|idx| match idx {
                 Some(i) => api::helper::pb_value_to_value_ref(
                     &self.row.values[*i],
-                    &self.schema[*i].datatype_extension,
+                    self.schema[*i].datatype_extension.as_ref(),
                 ),
                 None => ValueRef::Null,
             })
     }
 
     /// Get timestamp.
-    pub fn timestamp(&self) -> ValueRef {
+    pub fn timestamp(&self) -> ValueRef<'_> {
         // Timestamp is primitive, we clone it.
         let index = self.helper.indices[self.helper.num_primary_key_column].unwrap();
         api::helper::pb_value_to_value_ref(
             &self.row.values[index],
-            &self.schema[index].datatype_extension,
+            self.schema[index].datatype_extension.as_ref(),
         )
     }
 
diff --git a/src/mito-codec/src/row_converter/dense.rs b/src/mito-codec/src/row_converter/dense.rs
index 07ca67260f..cd4d74666e 100644
--- a/src/mito-codec/src/row_converter/dense.rs
+++ b/src/mito-codec/src/row_converter/dense.rs
@@ -516,7 +516,7 @@ impl PrimaryKeyCodec for DensePrimaryKeyCodec {
         values: &[(ColumnId, ValueRef)],
         buffer: &mut Vec<u8>,
     ) -> Result<()> {
-        let iter = values.iter().map(|(_, v)| *v);
+        let iter = values.iter().map(|(_, v)| v.clone());
         self.encode_dense(iter, buffer)
     }
 
diff --git a/src/mito-codec/src/row_converter/sparse.rs b/src/mito-codec/src/row_converter/sparse.rs
index a104bb8abc..edc26db8f0 100644
--- a/src/mito-codec/src/row_converter/sparse.rs
+++ b/src/mito-codec/src/row_converter/sparse.rs
@@ -310,7 +310,7 @@ impl PrimaryKeyCodec for SparsePrimaryKeyCodec {
         values: &[(ColumnId, ValueRef)],
         buffer: &mut Vec<u8>,
     ) -> Result<()> {
-        self.encode_to_vec(values.iter().map(|v| (v.0, v.1)), buffer)
+        self.encode_to_vec(values.iter().map(|v| (v.0, v.1.clone())), buffer)
     }
 
     fn estimated_size(&self) -> Option<usize> {
@@ -678,7 +678,12 @@ mod tests {
                 .has_column(&buffer, &mut offsets_map, column_id)
                 .unwrap();
             let value = codec.decode_value_at(&buffer, offset, column_id).unwrap();
-            let expected_value = row.iter().find(|(id, _)| *id == column_id).unwrap().1;
+            let expected_value = row
+                .iter()
+                .find(|(id, _)| *id == column_id)
+                .unwrap()
+                .1
+                .clone();
             assert_eq!(value.as_value_ref(), expected_value);
         }
     }
diff --git a/src/mito2/src/compaction/compactor.rs b/src/mito2/src/compaction/compactor.rs
index 8de26b6570..e0c9ef410b 100644
--- a/src/mito2/src/compaction/compactor.rs
+++ b/src/mito2/src/compaction/compactor.rs
@@ -130,8 +130,8 @@ pub async fn open_compaction_region(
         if let Some(name) = name {
             object_store_manager
                 .find(name)
-                .context(ObjectStoreNotFoundSnafu {
-                    object_store: name.to_string(),
+                .with_context(|| ObjectStoreNotFoundSnafu {
+                    object_store: name.clone(),
                 })?
         } else {
             object_store_manager.default_object_store()
diff --git a/src/mito2/src/engine/basic_test.rs b/src/mito2/src/engine/basic_test.rs
index 5b82f20807..2a5d0fbf87 100644
--- a/src/mito2/src/engine/basic_test.rs
+++ b/src/mito2/src/engine/basic_test.rs
@@ -143,7 +143,7 @@ async fn test_region_replay(factory: Option<LogStoreFactory>) {
         options.insert(
             WAL_OPTIONS_KEY.to_string(),
             serde_json::to_string(&WalOptions::Kafka(KafkaWalOptions {
-                topic: topic.to_string(),
+                topic: topic.clone(),
             }))
             .unwrap(),
         );
diff --git a/src/mito2/src/engine/batch_open_test.rs b/src/mito2/src/engine/batch_open_test.rs
index 0862cf3940..17eead987c 100644
--- a/src/mito2/src/engine/batch_open_test.rs
+++ b/src/mito2/src/engine/batch_open_test.rs
@@ -109,7 +109,7 @@ async fn test_batch_open(factory: Option<LogStoreFactory>) {
         options.insert(
             WAL_OPTIONS_KEY.to_string(),
             serde_json::to_string(&WalOptions::Kafka(KafkaWalOptions {
-                topic: topic.to_string(),
+                topic: topic.clone(),
             }))
             .unwrap(),
         );
@@ -175,7 +175,7 @@ async fn test_batch_open_err(factory: Option<LogStoreFactory>) {
         options.insert(
             WAL_OPTIONS_KEY.to_string(),
             serde_json::to_string(&WalOptions::Kafka(KafkaWalOptions {
-                topic: topic.to_string(),
+                topic: topic.clone(),
             }))
             .unwrap(),
         );
@@ -188,7 +188,7 @@ async fn test_batch_open_err(factory: Option<LogStoreFactory>) {
                 RegionId::new(1, id),
                 RegionOpenRequest {
                     engine: String::new(),
-                    table_dir: table_dir.to_string(),
+                    table_dir: table_dir.clone(),
                     options: options.clone(),
                     skip_wal_replay: false,
                     path_type: PathType::Bare,
diff --git a/src/mito2/src/engine/catchup_test.rs b/src/mito2/src/engine/catchup_test.rs
index 5c3d0cbe2d..57e5551775 100644
--- a/src/mito2/src/engine/catchup_test.rs
+++ b/src/mito2/src/engine/catchup_test.rs
@@ -82,7 +82,7 @@ async fn test_catchup_with_last_entry_id(factory: Option<LogStoreFactory>) {
         options.insert(
             WAL_OPTIONS_KEY.to_string(),
             serde_json::to_string(&WalOptions::Kafka(KafkaWalOptions {
-                topic: topic.to_string(),
+                topic: topic.clone(),
             }))
             .unwrap(),
         );
@@ -202,7 +202,7 @@ async fn test_catchup_with_incorrect_last_entry_id(factory: Option<LogStoreFacto
         options.insert(
             WAL_OPTIONS_KEY.to_string(),
             serde_json::to_string(&WalOptions::Kafka(KafkaWalOptions {
-                topic: topic.to_string(),
+                topic: topic.clone(),
             }))
             .unwrap(),
         );
@@ -305,7 +305,7 @@ async fn test_catchup_without_last_entry_id(factory: Option<LogStoreFactory>) {
         options.insert(
             WAL_OPTIONS_KEY.to_string(),
             serde_json::to_string(&WalOptions::Kafka(KafkaWalOptions {
-                topic: topic.to_string(),
+                topic: topic.clone(),
             }))
             .unwrap(),
         );
@@ -407,7 +407,7 @@ async fn test_catchup_with_manifest_update(factory: Option<LogStoreFactory>) {
         options.insert(
             WAL_OPTIONS_KEY.to_string(),
             serde_json::to_string(&WalOptions::Kafka(KafkaWalOptions {
-                topic: topic.to_string(),
+                topic: topic.clone(),
             }))
             .unwrap(),
         );
diff --git a/src/mito2/src/engine/flush_test.rs b/src/mito2/src/engine/flush_test.rs
index f9cc2ada0a..39808b91bc 100644
--- a/src/mito2/src/engine/flush_test.rs
+++ b/src/mito2/src/engine/flush_test.rs
@@ -340,7 +340,7 @@ async fn test_flush_reopen_region(factory: Option<LogStoreFactory>) {
         options.insert(
             WAL_OPTIONS_KEY.to_string(),
             serde_json::to_string(&WalOptions::Kafka(KafkaWalOptions {
-                topic: topic.to_string(),
+                topic: topic.clone(),
             }))
             .unwrap(),
         );
diff --git a/src/mito2/src/engine/open_test.rs b/src/mito2/src/engine/open_test.rs
index d0a73e7209..0a4ef67e1f 100644
--- a/src/mito2/src/engine/open_test.rs
+++ b/src/mito2/src/engine/open_test.rs
@@ -305,7 +305,7 @@ async fn test_open_region_skip_wal_replay() {
             region_id,
             RegionRequest::Open(RegionOpenRequest {
                 engine: String::new(),
-                table_dir: table_dir.to_string(),
+                table_dir: table_dir.clone(),
                 path_type: PathType::Bare,
                 options: Default::default(),
                 skip_wal_replay: true,
diff --git a/src/mito2/src/error.rs b/src/mito2/src/error.rs
index 2c3d739262..46ad4a97b2 100644
--- a/src/mito2/src/error.rs
+++ b/src/mito2/src/error.rs
@@ -25,6 +25,7 @@ use common_time::timestamp::TimeUnit;
 use datatypes::arrow::error::ArrowError;
 use datatypes::prelude::ConcreteDataType;
 use object_store::ErrorKind;
+use partition::error::Error as PartitionError;
 use prost::DecodeError;
 use snafu::{Location, Snafu};
 use store_api::ManifestVersion;
@@ -217,6 +218,57 @@ pub enum Error {
         location: Location,
     },
 
+    #[snafu(display("Old manifest missing for region {}", region_id))]
+    MissingOldManifest {
+        region_id: RegionId,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display("New manifest missing for region {}", region_id))]
+    MissingNewManifest {
+        region_id: RegionId,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display("File consistency check failed for file {}: {}", file_id, reason))]
+    InconsistentFile {
+        file_id: FileId,
+        reason: String,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display("Files lost during remapping: old={}, new={}", old_count, new_count))]
+    FilesLost {
+        old_count: usize,
+        new_count: usize,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display("No old manifests provided (need at least one for template)"))]
+    NoOldManifests {
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display("Partition expression missing for region {}", region_id))]
+    MissingPartitionExpr {
+        region_id: RegionId,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display("Failed to serialize partition expression: {}", source))]
+    SerializePartitionExpr {
+        #[snafu(source)]
+        source: PartitionError,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
     #[snafu(display(
         "Failed to convert ConcreteDataType to ColumnDataType, reason: {}",
         reason
@@ -1096,12 +1148,14 @@ impl ErrorExt for Error {
             | Utf8 { .. }
             | NewRecordBatch { .. }
             | RegionCorrupted { .. }
+            | InconsistentFile { .. }
             | CreateDefault { .. }
             | InvalidParquet { .. }
             | OperateAbortedIndex { .. }
             | IndexEncodeNull { .. }
             | NoCheckpoint { .. }
             | NoManifests { .. }
+            | FilesLost { .. }
             | InstallManifestTo { .. }
             | Unexpected { .. }
             | SerializeColumnMetadata { .. } => StatusCode::Unexpected,
@@ -1119,7 +1173,12 @@ impl ErrorExt for Error {
             | InvalidWalReadRequest { .. }
             | PartitionOutOfRange { .. }
             | ParseJobId { .. }
-            | DurationOutOfRange { .. } => StatusCode::InvalidArguments,
+            | DurationOutOfRange { .. }
+            | MissingOldManifest { .. }
+            | MissingNewManifest { .. }
+            | NoOldManifests { .. }
+            | MissingPartitionExpr { .. }
+            | SerializePartitionExpr { .. } => StatusCode::InvalidArguments,
 
             RegionMetadataNotFound { .. }
             | Join { .. }
diff --git a/src/mito2/src/lib.rs b/src/mito2/src/lib.rs
index 69b0dc9996..45ce635148 100644
--- a/src/mito2/src/lib.rs
+++ b/src/mito2/src/lib.rs
@@ -16,9 +16,7 @@
 //!
 //! Mito is the a region engine to store timeseries data.
 
-#![feature(let_chains)]
 #![feature(assert_matches)]
-#![feature(result_flattening)]
 #![feature(int_roundings)]
 #![feature(debug_closure_helpers)]
 #![feature(duration_constructors)]
@@ -43,6 +41,7 @@ mod metrics;
 pub mod read;
 pub mod region;
 mod region_write_ctx;
+pub mod remap_manifest;
 pub mod request;
 pub mod schedule;
 pub mod sst;
diff --git a/src/mito2/src/manifest/action.rs b/src/mito2/src/manifest/action.rs
index e0d81bc305..8d3e943bf5 100644
--- a/src/mito2/src/manifest/action.rs
+++ b/src/mito2/src/manifest/action.rs
@@ -869,13 +869,6 @@ mod tests {
             pub flushed_sequence: Option<SequenceNumber>,
         }
 
-        /// Last data truncated in the region.
-        #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
-        pub struct RegionTruncateV1 {
-            pub region_id: RegionId,
-            pub kind: TruncateKind,
-        }
-
         let json = serde_json::to_string(&RegionEditV1 {
             files_to_add: vec![],
             files_to_remove: vec![],
diff --git a/src/mito2/src/memtable.rs b/src/mito2/src/memtable.rs
index 2bcfc83545..7aacffa34b 100644
--- a/src/mito2/src/memtable.rs
+++ b/src/mito2/src/memtable.rs
@@ -64,19 +64,14 @@ pub use time_partition::filter_record_batch;
 pub type MemtableId = u32;
 
 /// Config for memtables.
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum MemtableConfig {
     PartitionTree(PartitionTreeConfig),
+    #[default]
     TimeSeries,
 }
 
-impl Default for MemtableConfig {
-    fn default() -> Self {
-        Self::TimeSeries
-    }
-}
-
 #[derive(Debug, Default, Clone)]
 pub struct MemtableStats {
     /// The estimated bytes allocated by this memtable from heap.
diff --git a/src/mito2/src/memtable/builder.rs b/src/mito2/src/memtable/builder.rs
index 6c66d8b3c0..bd1c73e2d7 100644
--- a/src/mito2/src/memtable/builder.rs
+++ b/src/mito2/src/memtable/builder.rs
@@ -54,7 +54,7 @@ impl FieldBuilder {
                 }
                 Ok(())
             }
-            FieldBuilder::Other(b) => b.try_push_value_ref(value),
+            FieldBuilder::Other(b) => b.try_push_value_ref(&value),
         }
     }
 
diff --git a/src/mito2/src/memtable/bulk.rs b/src/mito2/src/memtable/bulk.rs
index 31896751de..3b9533c0e4 100644
--- a/src/mito2/src/memtable/bulk.rs
+++ b/src/mito2/src/memtable/bulk.rs
@@ -1157,7 +1157,7 @@ mod tests {
         let memtable =
             BulkMemtable::new(999, metadata.clone(), None, None, false, MergeMode::LastRow);
 
-        let test_data = vec![
+        let test_data = [
             (
                 "key_a",
                 1u32,
diff --git a/src/mito2/src/memtable/bulk/part.rs b/src/mito2/src/memtable/bulk/part.rs
index a3718b66a3..d8b9d4b176 100644
--- a/src/mito2/src/memtable/bulk/part.rs
+++ b/src/mito2/src/memtable/bulk/part.rs
@@ -262,7 +262,7 @@ impl PrimaryKeyColumnBuilder {
                 }
             }
             PrimaryKeyColumnBuilder::Vector(builder) => {
-                builder.push_value_ref(value);
+                builder.push_value_ref(&value);
             }
         }
         Ok(())
@@ -785,11 +785,11 @@ fn mutations_to_record_batch(
                 .encode_to_vec(row.primary_keys(), &mut pk_buffer)
                 .context(EncodeSnafu)?;
             pk_builder.append_value(pk_buffer.as_bytes());
-            ts_vector.push_value_ref(row.timestamp());
+            ts_vector.push_value_ref(&row.timestamp());
             sequence_builder.append_value(row.sequence());
             op_type_builder.append_value(row.op_type() as u8);
             for (builder, field) in field_builders.iter_mut().zip(row.fields()) {
-                builder.push_value_ref(field);
+                builder.push_value_ref(&field);
             }
         }
     }
diff --git a/src/mito2/src/memtable/partition_tree/data.rs b/src/mito2/src/memtable/partition_tree/data.rs
index 34141046b7..a6d40bdcbf 100644
--- a/src/mito2/src/memtable/partition_tree/data.rs
+++ b/src/mito2/src/memtable/partition_tree/data.rs
@@ -219,7 +219,7 @@ impl DataBuffer {
 
     /// Writes a row to data buffer.
     pub fn write_row(&mut self, pk_index: PkIndex, kv: &KeyValue) {
-        self.ts_builder.push_value_ref(kv.timestamp());
+        self.ts_builder.push_value_ref(&kv.timestamp());
         self.pk_index_builder.push(Some(pk_index));
         self.sequence_builder.push(Some(kv.sequence()));
         self.op_type_builder.push(Some(kv.op_type() as u8));
@@ -229,7 +229,7 @@ impl DataBuffer {
         for (idx, field) in kv.fields().enumerate() {
             self.field_builders[idx]
                 .get_or_create_builder(self.ts_builder.len())
-                .push_value_ref(field);
+                .push_value_ref(&field);
         }
     }
 
@@ -550,7 +550,7 @@ impl DataBufferReader {
     /// Returns current data batch.
     /// # Panics
     /// If Current reader is exhausted.
-    pub(crate) fn current_data_batch(&self) -> DataBatch {
+    pub(crate) fn current_data_batch(&self) -> DataBatch<'_> {
         let range = self.current_range.unwrap();
         DataBatch {
             rb: &self.batch,
@@ -881,7 +881,7 @@ impl DataPartReader {
     /// Returns current data batch of reader.
     /// # Panics
     /// If reader is exhausted.
-    pub(crate) fn current_data_batch(&self) -> DataBatch {
+    pub(crate) fn current_data_batch(&self) -> DataBatch<'_> {
         let range = self.current_range.unwrap();
         DataBatch {
             rb: self.current_batch.as_ref().unwrap(),
@@ -1041,7 +1041,7 @@ impl Drop for DataPartsReader {
 }
 
 impl DataPartsReader {
-    pub(crate) fn current_data_batch(&self) -> DataBatch {
+    pub(crate) fn current_data_batch(&self) -> DataBatch<'_> {
         let batch = self.merger.current_node().current_data_batch();
         batch.slice(0, self.merger.current_rows())
     }
diff --git a/src/mito2/src/memtable/partition_tree/dedup.rs b/src/mito2/src/memtable/partition_tree/dedup.rs
index 320016fa29..a010a1eaf5 100644
--- a/src/mito2/src/memtable/partition_tree/dedup.rs
+++ b/src/mito2/src/memtable/partition_tree/dedup.rs
@@ -100,7 +100,7 @@ impl<T: DataBatchSource> DataBatchSource for DedupReader<T> {
         self.inner.current_key()
     }
 
-    fn current_data_batch(&self) -> DataBatch {
+    fn current_data_batch(&self) -> DataBatch<'_> {
         let range = self.current_batch_range.as_ref().unwrap();
         let data_batch = self.inner.current_data_batch();
         data_batch.slice(range.start, range.len())
@@ -139,7 +139,7 @@ mod tests {
             None
         }
 
-        fn current_data_batch(&self) -> DataBatch {
+        fn current_data_batch(&self) -> DataBatch<'_> {
             self.0.current_data_batch()
         }
     }
diff --git a/src/mito2/src/memtable/partition_tree/merger.rs b/src/mito2/src/memtable/partition_tree/merger.rs
index ed5ab78f15..5a74934bdc 100644
--- a/src/mito2/src/memtable/partition_tree/merger.rs
+++ b/src/mito2/src/memtable/partition_tree/merger.rs
@@ -167,7 +167,7 @@ pub(crate) enum DataSource {
 }
 
 impl DataSource {
-    fn current_data_batch(&self) -> DataBatch {
+    fn current_data_batch(&self) -> DataBatch<'_> {
         match self {
             DataSource::Buffer(buffer) => buffer.current_data_batch(),
             DataSource::Part(p) => p.current_data_batch(),
@@ -207,7 +207,7 @@ impl DataNode {
         }
     }
 
-    pub(crate) fn current_data_batch(&self) -> DataBatch {
+    pub(crate) fn current_data_batch(&self) -> DataBatch<'_> {
         let range = self.current_range();
         let batch = self.source.current_data_batch();
         batch.slice(range.start, range.len())
diff --git a/src/mito2/src/memtable/partition_tree/shard.rs b/src/mito2/src/memtable/partition_tree/shard.rs
index f1f2be9d01..162f937a7c 100644
--- a/src/mito2/src/memtable/partition_tree/shard.rs
+++ b/src/mito2/src/memtable/partition_tree/shard.rs
@@ -134,7 +134,7 @@ pub trait DataBatchSource {
     /// Returns the data part.
     /// # Panics
     /// If source is not valid.
-    fn current_data_batch(&self) -> DataBatch;
+    fn current_data_batch(&self) -> DataBatch<'_>;
 }
 
 pub type BoxedDataBatchSource = Box<dyn DataBatchSource + Send>;
@@ -223,7 +223,7 @@ impl ShardReader {
         }
     }
 
-    fn current_data_batch(&self) -> DataBatch {
+    fn current_data_batch(&self) -> DataBatch<'_> {
         self.parts_reader.current_data_batch()
     }
 
@@ -305,7 +305,7 @@ impl DataBatchSource for ShardMerger {
         self.merger.current_node().current_key()
     }
 
-    fn current_data_batch(&self) -> DataBatch {
+    fn current_data_batch(&self) -> DataBatch<'_> {
         let batch = self.merger.current_node().current_data_batch();
         batch.slice(0, self.merger.current_rows())
     }
@@ -345,7 +345,7 @@ impl ShardSource {
         }
     }
 
-    fn current_data_batch(&self) -> DataBatch {
+    fn current_data_batch(&self) -> DataBatch<'_> {
         match self {
             ShardSource::Builder(r) => r.current_data_batch(),
             ShardSource::Shard(r) => r.current_data_batch(),
@@ -371,7 +371,7 @@ impl ShardNode {
         self.source.current_key()
     }
 
-    fn current_data_batch(&self) -> DataBatch {
+    fn current_data_batch(&self) -> DataBatch<'_> {
         self.source.current_data_batch()
     }
 }
diff --git a/src/mito2/src/memtable/partition_tree/shard_builder.rs b/src/mito2/src/memtable/partition_tree/shard_builder.rs
index 63a2d895bc..26de85767d 100644
--- a/src/mito2/src/memtable/partition_tree/shard_builder.rs
+++ b/src/mito2/src/memtable/partition_tree/shard_builder.rs
@@ -262,7 +262,7 @@ impl ShardBuilderReader {
         }
     }
 
-    pub fn current_data_batch(&self) -> DataBatch {
+    pub fn current_data_batch(&self) -> DataBatch<'_> {
         self.data_reader.current_data_batch()
     }
 
diff --git a/src/mito2/src/memtable/simple_bulk_memtable.rs b/src/mito2/src/memtable/simple_bulk_memtable.rs
index 8ce2018a5d..1270557ac6 100644
--- a/src/mito2/src/memtable/simple_bulk_memtable.rs
+++ b/src/mito2/src/memtable/simple_bulk_memtable.rs
@@ -849,7 +849,7 @@ mod tests {
             schema,
             vec![
                 Arc::new(StringArray::from_iter_values(
-                    ["a".repeat(string_len as usize).to_string()].into_iter(),
+                    ["a".repeat(string_len as usize).clone()].into_iter(),
                 )) as ArrayRef,
                 Arc::new(TimestampMillisecondArray::from_iter_values(
                     [ts].into_iter(),
diff --git a/src/mito2/src/read/dedup.rs b/src/mito2/src/read/dedup.rs
index 6ff4d53ba4..c3db629f84 100644
--- a/src/mito2/src/read/dedup.rs
+++ b/src/mito2/src/read/dedup.rs
@@ -355,7 +355,7 @@ impl LastFieldsBuilder {
             // Builds last fields.
             for (builder, value) in self.builders.iter_mut().zip(&self.last_fields) {
                 // Safety: Vectors of the batch has the same type.
-                builder.push_value_ref(value.as_value_ref());
+                builder.push_value_ref(&value.as_value_ref());
             }
             let fields = self
                 .builders
diff --git a/src/mito2/src/read/projection.rs b/src/mito2/src/read/projection.rs
index adc0290c23..d7171e7f60 100644
--- a/src/mito2/src/read/projection.rs
+++ b/src/mito2/src/read/projection.rs
@@ -394,7 +394,7 @@ fn new_repeated_vector(
 ) -> common_recordbatch::error::Result<VectorRef> {
     let mut mutable_vector = data_type.create_mutable_vector(1);
     mutable_vector
-        .try_push_value_ref(value.as_value_ref())
+        .try_push_value_ref(&value.as_value_ref())
         .map_err(BoxedError::new)
         .context(ExternalSnafu)?;
     // This requires an additional allocation.
diff --git a/src/mito2/src/region/opener.rs b/src/mito2/src/region/opener.rs
index dcebd65b98..4b9fd32e6b 100644
--- a/src/mito2/src/region/opener.rs
+++ b/src/mito2/src/region/opener.rs
@@ -375,7 +375,7 @@ impl RegionOpener {
                         region: "`kafka`",
                     }
                 );
-                Ok(Provider::kafka_provider(options.topic.to_string()))
+                Ok(Provider::kafka_provider(options.topic.clone()))
             }
             WalOptions::Noop => Ok(Provider::noop_provider()),
         }
@@ -579,7 +579,7 @@ pub fn get_object_store(
         Ok(object_store_manager
             .find(name)
             .with_context(|| ObjectStoreNotFoundSnafu {
-                object_store: name.to_string(),
+                object_store: name.clone(),
             })?
             .clone())
     } else {
diff --git a/src/mito2/src/region/options.rs b/src/mito2/src/region/options.rs
index 1c075bf6b4..4d08a613ea 100644
--- a/src/mito2/src/region/options.rs
+++ b/src/mito2/src/region/options.rs
@@ -402,9 +402,9 @@ fn options_map_to_value(options: &HashMap<String, String>) -> Value {
         .map(|(key, value)| {
             // Only convert the key to lowercase.
             if value.eq_ignore_ascii_case("null") {
-                (key.to_string(), Value::Null)
+                (key.clone(), Value::Null)
             } else {
-                (key.to_string(), Value::from(value.to_string()))
+                (key.clone(), Value::from(value.clone()))
             }
         })
         .collect();
diff --git a/src/mito2/src/remap_manifest.rs b/src/mito2/src/remap_manifest.rs
new file mode 100644
index 0000000000..ee0e690960
--- /dev/null
+++ b/src/mito2/src/remap_manifest.rs
@@ -0,0 +1,738 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
+use partition::expr::PartitionExpr;
+use snafu::{OptionExt, ResultExt, ensure};
+use store_api::storage::RegionId;
+
+use crate::error;
+pub use crate::error::{Error, Result};
+use crate::manifest::action::{RegionManifest, RemovedFilesRecord};
+use crate::sst::file::FileMeta;
+
+/// Remaps file references from old region manifests to new region manifests.
+pub struct RemapManifest {
+    /// Old region manifests indexed by region ID
+    old_manifests: HashMap<RegionId, RegionManifest>,
+    /// New partition expressions indexed by region ID
+    new_partition_exprs: HashMap<RegionId, PartitionExpr>,
+    /// For each old region, which new regions should receive its files
+    region_mapping: HashMap<RegionId, Vec<RegionId>>,
+    /// Newly generated manifests for target regions
+    new_manifests: HashMap<RegionId, RegionManifest>,
+}
+
+impl RemapManifest {
+    pub fn new(
+        old_manifests: HashMap<RegionId, RegionManifest>,
+        new_partition_exprs: HashMap<RegionId, PartitionExpr>,
+        region_mapping: HashMap<RegionId, Vec<RegionId>>,
+    ) -> Self {
+        Self {
+            old_manifests,
+            new_partition_exprs,
+            region_mapping,
+            new_manifests: HashMap::new(),
+        }
+    }
+
+    /// Remaps manifests from old regions to new regions.
+    ///
+    /// Main entry point. It copies files from old regions to new regions based on
+    /// partition expression overlaps.
+    pub fn remap_manifests(&mut self) -> Result<RemapResult> {
+        // initialize new manifests
+        self.initialize_new_manifests()?;
+
+        // remap files
+        self.do_remap()?;
+
+        // merge and set metadata for all new manifests
+        self.finalize_manifests()?;
+
+        // validate and compute statistics
+        let stats = self.compute_stats();
+        self.validate_result(&stats)?;
+
+        let new_manifests = std::mem::take(&mut self.new_manifests);
+
+        Ok(RemapResult {
+            new_manifests,
+            stats,
+        })
+    }
+
+    /// Initializes empty manifests for all new regions.
+    fn initialize_new_manifests(&mut self) -> Result<()> {
+        let mut new_manifests = HashMap::new();
+
+        // Get any old manifest as template (they all share the same table schema)
+        let template_manifest = self
+            .old_manifests
+            .values()
+            .next()
+            .context(error::NoOldManifestsSnafu)?;
+        let template_metadata = (*template_manifest.metadata).clone();
+
+        // Create empty manifest for each new region
+        for region_id in self.new_partition_exprs.keys() {
+            // Derive region metadata from any old manifest as template
+            let mut new_metadata = template_metadata.clone();
+
+            new_metadata.region_id = *region_id;
+            let new_partition_expr = self
+                .new_partition_exprs
+                .get(region_id)
+                .context(error::MissingPartitionExprSnafu {
+                    region_id: *region_id,
+                })?
+                .as_json_str()
+                .context(error::SerializePartitionExprSnafu)?;
+            new_metadata.partition_expr = Some(new_partition_expr);
+
+            let manifest = RegionManifest {
+                metadata: Arc::new(new_metadata),
+                files: HashMap::new(),
+                removed_files: RemovedFilesRecord::default(),
+                flushed_entry_id: 0,
+                flushed_sequence: 0,
+                committed_sequence: None,
+                manifest_version: 0,
+                truncated_entry_id: None,
+                compaction_time_window: None,
+            };
+
+            new_manifests.insert(*region_id, manifest);
+        }
+
+        self.new_manifests = new_manifests;
+
+        Ok(())
+    }
+
+    /// Remaps files from old regions to new regions according to the region mapping.
+    fn do_remap(&mut self) -> Result<()> {
+        // For each old region and its target new regions
+        for (&from_region_id, target_region_ids) in &self.region_mapping {
+            // Get old manifest
+            let from_manifest = self.old_manifests.get(&from_region_id).context(
+                error::MissingOldManifestSnafu {
+                    region_id: from_region_id,
+                },
+            )?;
+
+            // Copy files to all target new regions
+            for &to_region_id in target_region_ids {
+                let target_manifest = self.new_manifests.get_mut(&to_region_id).context(
+                    error::MissingNewManifestSnafu {
+                        region_id: to_region_id,
+                    },
+                )?;
+
+                Self::copy_files_to_region(from_manifest, target_manifest)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Copies files from a source region to a target region.
+    fn copy_files_to_region(
+        source_manifest: &RegionManifest,
+        target_manifest: &mut RegionManifest,
+    ) -> Result<()> {
+        for (file_id, file_meta) in &source_manifest.files {
+            let file_meta_clone = file_meta.clone();
+
+            // Insert or merge into target manifest
+            // Same file might be added from multiple overlapping old regions
+            use std::collections::hash_map::Entry;
+            match target_manifest.files.entry(*file_id) {
+                Entry::Vacant(e) => {
+                    e.insert(file_meta_clone);
+                }
+                Entry::Occupied(e) => {
+                    // File already exists - verify it's the same physical file
+                    #[cfg(debug_assertions)]
+                    Self::verify_file_consistency(e.get(), &file_meta_clone)?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Verifies that two file metadata entries are consistent.
+    #[cfg(debug_assertions)]
+    fn verify_file_consistency(existing: &FileMeta, new: &FileMeta) -> Result<()> {
+        // When the same file appears from multiple overlapping old regions,
+        // verify they are actually the same physical file with identical metadata
+
+        ensure!(
+            existing.region_id == new.region_id,
+            error::InconsistentFileSnafu {
+                file_id: existing.file_id,
+                reason: "region_id mismatch",
+            }
+        );
+
+        ensure!(
+            existing.file_id == new.file_id,
+            error::InconsistentFileSnafu {
+                file_id: existing.file_id,
+                reason: "file_id mismatch",
+            }
+        );
+
+        ensure!(
+            existing.time_range == new.time_range,
+            error::InconsistentFileSnafu {
+                file_id: existing.file_id,
+                reason: "time_range mismatch",
+            }
+        );
+
+        ensure!(
+            existing.level == new.level,
+            error::InconsistentFileSnafu {
+                file_id: existing.file_id,
+                reason: "level mismatch",
+            }
+        );
+
+        ensure!(
+            existing.file_size == new.file_size,
+            error::InconsistentFileSnafu {
+                file_id: existing.file_id,
+                reason: "file_size mismatch",
+            }
+        );
+
+        ensure!(
+            existing.partition_expr == new.partition_expr,
+            error::InconsistentFileSnafu {
+                file_id: existing.file_id,
+                reason: "partition_expr mismatch",
+            }
+        );
+
+        Ok(())
+    }
+
+    /// Finalizes manifests by merging metadata from source regions.
+    fn finalize_manifests(&mut self) -> Result<()> {
+        for (region_id, manifest) in self.new_manifests.iter_mut() {
+            if let Some(previous_manifest) = self.old_manifests.get(region_id) {
+                manifest.flushed_entry_id = previous_manifest.flushed_entry_id;
+                manifest.flushed_sequence = previous_manifest.flushed_sequence;
+                manifest.manifest_version = previous_manifest.manifest_version;
+                manifest.truncated_entry_id = previous_manifest.truncated_entry_id;
+                manifest.compaction_time_window = previous_manifest.compaction_time_window;
+                manifest.committed_sequence = previous_manifest.committed_sequence;
+            } else {
+                // new region
+                manifest.flushed_entry_id = 0;
+                manifest.flushed_sequence = 0;
+                manifest.manifest_version = 0;
+                manifest.truncated_entry_id = None;
+                manifest.compaction_time_window = None;
+                manifest.committed_sequence = None;
+            }
+
+            // removed_files are tracked by old manifests, don't copy
+            manifest.removed_files = RemovedFilesRecord::default();
+        }
+
+        Ok(())
+    }
+
+    /// Computes statistics about the remapping.
+    fn compute_stats(&self) -> RemapStats {
+        let mut files_per_region = HashMap::with_capacity(self.new_manifests.len());
+        let mut total_file_refs = 0;
+        let mut empty_regions = Vec::new();
+        let mut all_files = HashSet::new();
+
+        for (&region_id, manifest) in &self.new_manifests {
+            let file_count = manifest.files.len();
+            files_per_region.insert(region_id, file_count);
+            total_file_refs += file_count;
+
+            if file_count == 0 {
+                empty_regions.push(region_id);
+            }
+
+            for file_id in manifest.files.keys() {
+                all_files.insert(*file_id);
+            }
+        }
+
+        RemapStats {
+            files_per_region,
+            total_file_refs,
+            empty_regions,
+            unique_files: all_files.len(),
+        }
+    }
+
+    /// Validates the remapping result.
+    fn validate_result(&self, stats: &RemapStats) -> Result<()> {
+        // all new regions have manifests
+        for region_id in self.new_partition_exprs.keys() {
+            ensure!(
+                self.new_manifests.contains_key(region_id),
+                error::MissingNewManifestSnafu {
+                    region_id: *region_id
+                }
+            );
+        }
+
+        // no unique files were lost
+        // Count unique files in old manifests (files may be duplicated across regions)
+        let mut old_unique_files = HashSet::new();
+        for manifest in self.old_manifests.values() {
+            for file_id in manifest.files.keys() {
+                old_unique_files.insert(*file_id);
+            }
+        }
+
+        ensure!(
+            stats.unique_files >= old_unique_files.len(),
+            error::FilesLostSnafu {
+                old_count: old_unique_files.len(),
+                new_count: stats.unique_files,
+            }
+        );
+
+        // 3. Log warning about empty regions (not an error)
+        if !stats.empty_regions.is_empty() {
+            common_telemetry::warn!(
+                "Repartition resulted in {} empty regions: {:?}, new partition exprs: {:?}",
+                stats.empty_regions.len(),
+                stats.empty_regions,
+                self.new_partition_exprs.keys().collect::<Vec<_>>()
+            );
+        }
+
+        Ok(())
+    }
+}
+
+/// Result of manifest remapping, including new manifests and statistics.
+#[derive(Debug)]
+pub struct RemapResult {
+    /// New manifests for all new regions
+    pub new_manifests: HashMap<RegionId, RegionManifest>,
+    /// Statistics about the remapping
+    pub stats: RemapStats,
+}
+
+/// Statistical information about the manifest remapping.
+#[derive(Debug)]
+pub struct RemapStats {
+    /// Number of files per region in new manifests
+    pub files_per_region: HashMap<RegionId, usize>,
+    /// Total number of file references created across all new regions
+    pub total_file_refs: usize,
+    /// Regions that received no files (potentially empty after repartition)
+    pub empty_regions: Vec<RegionId>,
+    /// Total number of unique files processed
+    pub unique_files: usize,
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::num::NonZeroU64;
+    use std::sync::Arc;
+    use std::time::Duration;
+
+    use api::v1::SemanticType;
+    use datatypes::prelude::ConcreteDataType;
+    use datatypes::schema::ColumnSchema;
+    use datatypes::value::Value;
+    use partition::expr::{PartitionExpr, col};
+    use smallvec::SmallVec;
+    use store_api::metadata::{ColumnMetadata, RegionMetadataBuilder, RegionMetadataRef};
+    use store_api::storage::{FileId, RegionId, SequenceNumber};
+
+    use super::*;
+    use crate::manifest::action::RegionManifest;
+    use crate::sst::file::{FileMeta, FileTimeRange};
+    use crate::wal::EntryId;
+
+    /// Helper to create a basic region metadata for testing.
+    fn create_region_metadata(region_id: RegionId) -> RegionMetadataRef {
+        let mut builder = RegionMetadataBuilder::new(region_id);
+        builder
+            .push_column_metadata(ColumnMetadata {
+                column_schema: ColumnSchema::new(
+                    "ts",
+                    ConcreteDataType::timestamp_millisecond_datatype(),
+                    false,
+                ),
+                semantic_type: SemanticType::Timestamp,
+                column_id: 1,
+            })
+            .push_column_metadata(ColumnMetadata {
+                column_schema: ColumnSchema::new("pk", ConcreteDataType::int64_datatype(), false),
+                semantic_type: SemanticType::Tag,
+                column_id: 2,
+            })
+            .push_column_metadata(ColumnMetadata {
+                column_schema: ColumnSchema::new(
+                    "val",
+                    ConcreteDataType::float64_datatype(),
+                    false,
+                ),
+                semantic_type: SemanticType::Field,
+                column_id: 3,
+            })
+            .primary_key(vec![2]);
+        Arc::new(builder.build().unwrap())
+    }
+
+    /// Helper to create a FileMeta for testing.
+    fn create_file_meta(
+        region_id: RegionId,
+        file_id: FileId,
+        partition_expr: Option<PartitionExpr>,
+    ) -> FileMeta {
+        FileMeta {
+            region_id,
+            file_id,
+            time_range: FileTimeRange::default(),
+            level: 0,
+            file_size: 1024,
+            available_indexes: SmallVec::new(),
+            index_file_size: 0,
+            num_rows: 100,
+            num_row_groups: 1,
+            sequence: NonZeroU64::new(1),
+            partition_expr,
+        }
+    }
+
+    /// Helper to create a manifest with specified number of files.
+    fn create_manifest(
+        region_id: RegionId,
+        num_files: usize,
+        partition_expr: Option<PartitionExpr>,
+        flushed_entry_id: EntryId,
+        flushed_sequence: SequenceNumber,
+    ) -> RegionManifest {
+        let mut files = HashMap::new();
+        for _ in 0..num_files {
+            let file_id = FileId::random();
+            let file_meta = create_file_meta(region_id, file_id, partition_expr.clone());
+            files.insert(file_id, file_meta);
+        }
+
+        RegionManifest {
+            metadata: create_region_metadata(region_id),
+            files,
+            removed_files: RemovedFilesRecord::default(),
+            flushed_entry_id,
+            flushed_sequence,
+            manifest_version: 1,
+            truncated_entry_id: None,
+            compaction_time_window: None,
+            committed_sequence: None,
+        }
+    }
+
+    /// Helper to create partition expression: col >= start AND col < end
+    fn range_expr(col_name: &str, start: i64, end: i64) -> PartitionExpr {
+        col(col_name)
+            .gt_eq(Value::Int64(start))
+            .and(col(col_name).lt(Value::Int64(end)))
+    }
+
+    #[test]
+    fn test_simple_split() {
+        // One region [0, 100) splits into two regions: [0, 50) and [50, 100)
+        let old_region_id = RegionId::new(1, 1);
+        let new_region_id_1 = RegionId::new(1, 2);
+        let new_region_id_2 = RegionId::new(1, 3);
+
+        let old_expr = range_expr("x", 0, 100);
+        let new_expr_1 = range_expr("x", 0, 50);
+        let new_expr_2 = range_expr("x", 50, 100);
+
+        let old_manifest = create_manifest(old_region_id, 10, Some(old_expr.clone()), 100, 200);
+
+        let mut old_manifests = HashMap::new();
+        old_manifests.insert(old_region_id, old_manifest);
+
+        let mut new_partition_exprs = HashMap::new();
+        new_partition_exprs.insert(new_region_id_1, new_expr_1);
+        new_partition_exprs.insert(new_region_id_2, new_expr_2);
+
+        // Direct mapping: old region -> both new regions
+        let mut region_mapping = HashMap::new();
+        region_mapping.insert(old_region_id, vec![new_region_id_1, new_region_id_2]);
+
+        let mut remapper = RemapManifest::new(old_manifests, new_partition_exprs, region_mapping);
+
+        let result = remapper.remap_manifests().unwrap();
+
+        // Both new regions should have all 10 files
+        assert_eq!(result.new_manifests.len(), 2);
+        assert_eq!(result.new_manifests[&new_region_id_1].files.len(), 10);
+        assert_eq!(result.new_manifests[&new_region_id_2].files.len(), 10);
+        assert_eq!(result.stats.total_file_refs, 20);
+        assert_eq!(result.stats.unique_files, 10);
+        assert!(result.stats.empty_regions.is_empty());
+
+        // Verify FileMeta is immutable - region_id stays as old_region_id
+        for file_meta in result.new_manifests[&new_region_id_1].files.values() {
+            assert_eq!(file_meta.region_id, old_region_id);
+        }
+        for file_meta in result.new_manifests[&new_region_id_2].files.values() {
+            assert_eq!(file_meta.region_id, old_region_id);
+        }
+    }
+
+    #[test]
+    fn test_simple_merge() {
+        // Two regions [0, 50) and [50, 100) merge into one region [0, 100)
+        let old_region_id_1 = RegionId::new(1, 1);
+        let old_region_id_2 = RegionId::new(1, 2);
+        let new_region_id = RegionId::new(1, 3);
+
+        let old_expr_1 = range_expr("x", 0, 50);
+        let old_expr_2 = range_expr("x", 50, 100);
+        let new_expr = range_expr("x", 0, 100);
+
+        let manifest_1 = create_manifest(old_region_id_1, 5, Some(old_expr_1.clone()), 100, 200);
+        let manifest_2 = create_manifest(old_region_id_2, 5, Some(old_expr_2.clone()), 150, 250);
+
+        let mut old_manifests = HashMap::new();
+        old_manifests.insert(old_region_id_1, manifest_1);
+        old_manifests.insert(old_region_id_2, manifest_2);
+
+        let mut new_partition_exprs = HashMap::new();
+        new_partition_exprs.insert(new_region_id, new_expr);
+
+        // Direct mapping: both old regions -> same new region
+        let mut region_mapping = HashMap::new();
+        region_mapping.insert(old_region_id_1, vec![new_region_id]);
+        region_mapping.insert(old_region_id_2, vec![new_region_id]);
+
+        let mut remapper = RemapManifest::new(old_manifests, new_partition_exprs, region_mapping);
+
+        let result = remapper.remap_manifests().unwrap();
+
+        // New region should have all 10 files
+        assert_eq!(result.new_manifests.len(), 1);
+        assert_eq!(result.new_manifests[&new_region_id].files.len(), 10);
+        assert_eq!(result.stats.total_file_refs, 10);
+        assert_eq!(result.stats.unique_files, 10);
+        assert!(result.stats.empty_regions.is_empty());
+
+        // Verify metadata falls back to defaults when no prior manifest exists for the region
+        let new_manifest = &result.new_manifests[&new_region_id];
+        assert_eq!(new_manifest.flushed_entry_id, 0);
+        assert_eq!(new_manifest.flushed_sequence, 0);
+        assert_eq!(new_manifest.manifest_version, 0);
+        assert_eq!(new_manifest.truncated_entry_id, None);
+        assert_eq!(new_manifest.compaction_time_window, None);
+    }
+
+    #[test]
+    fn test_metadata_preserved_for_existing_region() {
+        // Test that metadata is preserved when a previous manifest exists for the same region id
+        let old_region_id_1 = RegionId::new(1, 1);
+        let old_region_id_2 = RegionId::new(1, 2);
+        let old_region_id_3 = RegionId::new(1, 3);
+        let new_region_id = RegionId::new(1, 4);
+
+        let new_expr = range_expr("x", 0, 100);
+
+        let mut manifest_1 = create_manifest(old_region_id_1, 2, None, 10, 20);
+        manifest_1.truncated_entry_id = Some(5);
+        manifest_1.compaction_time_window = Some(Duration::from_secs(3600));
+
+        let mut manifest_2 = create_manifest(old_region_id_2, 2, None, 25, 15); // Higher entry_id, lower sequence
+        manifest_2.truncated_entry_id = Some(20);
+        manifest_2.compaction_time_window = Some(Duration::from_secs(7200)); // Larger window
+
+        let manifest_3 = create_manifest(old_region_id_3, 2, None, 15, 30); // Lower entry_id, higher sequence
+        let mut previous_manifest = create_manifest(new_region_id, 0, None, 200, 300);
+        previous_manifest.truncated_entry_id = Some(40);
+        previous_manifest.compaction_time_window = Some(Duration::from_secs(1800));
+        previous_manifest.manifest_version = 7;
+        let expected_flushed_entry_id = previous_manifest.flushed_entry_id;
+        let expected_flushed_sequence = previous_manifest.flushed_sequence;
+        let expected_truncated_entry_id = previous_manifest.truncated_entry_id;
+        let expected_compaction_window = previous_manifest.compaction_time_window;
+        let expected_manifest_version = previous_manifest.manifest_version;
+
+        let mut old_manifests = HashMap::new();
+        old_manifests.insert(old_region_id_1, manifest_1);
+        old_manifests.insert(old_region_id_2, manifest_2);
+        old_manifests.insert(old_region_id_3, manifest_3);
+        old_manifests.insert(new_region_id, previous_manifest);
+
+        let mut new_partition_exprs = HashMap::new();
+        new_partition_exprs.insert(new_region_id, new_expr);
+
+        // Direct mapping: all old regions -> same new region
+        let mut region_mapping = HashMap::new();
+        region_mapping.insert(old_region_id_1, vec![new_region_id]);
+        region_mapping.insert(old_region_id_2, vec![new_region_id]);
+        region_mapping.insert(old_region_id_3, vec![new_region_id]);
+
+        let mut remapper = RemapManifest::new(old_manifests, new_partition_exprs, region_mapping);
+
+        let result = remapper.remap_manifests().unwrap();
+
+        let new_manifest = &result.new_manifests[&new_region_id];
+        // Should reuse metadata from previous manifest of the same region id
+        assert_eq!(new_manifest.flushed_entry_id, expected_flushed_entry_id);
+        assert_eq!(new_manifest.flushed_sequence, expected_flushed_sequence);
+        assert_eq!(new_manifest.truncated_entry_id, expected_truncated_entry_id);
+        assert_eq!(
+            new_manifest.compaction_time_window,
+            expected_compaction_window
+        );
+        assert_eq!(new_manifest.manifest_version, expected_manifest_version);
+    }
+
+    #[test]
+    fn test_file_consistency_check() {
+        // Test that duplicate files are verified for consistency
+        let old_region_id_1 = RegionId::new(1, 1);
+        let old_region_id_2 = RegionId::new(1, 2);
+        let new_region_id = RegionId::new(1, 3);
+
+        let new_expr = range_expr("x", 0, 100);
+
+        // Create manifests with same file (overlapping regions)
+        let shared_file_id = FileId::random();
+        let file_meta = create_file_meta(old_region_id_1, shared_file_id, None);
+
+        let mut manifest_1 = create_manifest(old_region_id_1, 0, None, 100, 200);
+        manifest_1.files.insert(shared_file_id, file_meta.clone());
+
+        let mut manifest_2 = create_manifest(old_region_id_2, 0, None, 100, 200);
+        manifest_2.files.insert(shared_file_id, file_meta);
+
+        let mut old_manifests = HashMap::new();
+        old_manifests.insert(old_region_id_1, manifest_1);
+        old_manifests.insert(old_region_id_2, manifest_2);
+
+        let mut new_partition_exprs = HashMap::new();
+        new_partition_exprs.insert(new_region_id, new_expr);
+
+        // Direct mapping: both old regions -> same new region
+        let mut region_mapping = HashMap::new();
+        region_mapping.insert(old_region_id_1, vec![new_region_id]);
+        region_mapping.insert(old_region_id_2, vec![new_region_id]);
+
+        let mut remapper = RemapManifest::new(old_manifests, new_partition_exprs, region_mapping);
+
+        let result = remapper.remap_manifests().unwrap();
+
+        // Should succeed - same file is consistent
+        assert_eq!(result.new_manifests[&new_region_id].files.len(), 1);
+        assert_eq!(result.stats.total_file_refs, 1);
+        assert_eq!(result.stats.unique_files, 1);
+    }
+
+    #[test]
+    fn test_empty_regions() {
+        // Test that empty regions are detected and logged (but not an error)
+        let old_region_id = RegionId::new(1, 1);
+        let new_region_id_1 = RegionId::new(1, 2);
+        let new_region_id_2 = RegionId::new(1, 3);
+
+        let old_expr = range_expr("x", 0, 50);
+        let new_expr_1 = range_expr("x", 0, 50);
+        let new_expr_2 = range_expr("x", 100, 200); // No overlap with old region
+
+        let old_manifest = create_manifest(old_region_id, 5, Some(old_expr.clone()), 100, 200);
+
+        let mut old_manifests = HashMap::new();
+        old_manifests.insert(old_region_id, old_manifest);
+
+        let mut new_partition_exprs = HashMap::new();
+        new_partition_exprs.insert(new_region_id_1, new_expr_1);
+        new_partition_exprs.insert(new_region_id_2, new_expr_2);
+
+        // Direct mapping: old region -> new region 1 only (region 2 is isolated)
+        let mut region_mapping = HashMap::new();
+        region_mapping.insert(old_region_id, vec![new_region_id_1]);
+
+        let mut remapper = RemapManifest::new(old_manifests, new_partition_exprs, region_mapping);
+
+        let result = remapper.remap_manifests().unwrap();
+
+        // Region 2 should be empty
+        assert_eq!(result.new_manifests[&new_region_id_1].files.len(), 5);
+        assert_eq!(result.new_manifests[&new_region_id_2].files.len(), 0);
+        assert_eq!(result.stats.empty_regions, vec![new_region_id_2]);
+    }
+
+    #[test]
+    fn test_n_to_m_complex_repartition() {
+        // Test complex N-to-M transition: 2 old regions -> 3 new regions
+        let old_region_1 = RegionId::new(1, 1);
+        let old_region_2 = RegionId::new(1, 2);
+        let new_region_1 = RegionId::new(1, 3);
+        let new_region_2 = RegionId::new(1, 4);
+        let new_region_3 = RegionId::new(1, 5);
+
+        // Old: [0, 100), [100, 200)
+        // New: [0, 50), [50, 150), [150, 250)
+        let old_expr_1 = range_expr("u", 0, 100);
+        let old_expr_2 = range_expr("u", 100, 200);
+        let new_expr_1 = range_expr("u", 0, 50);
+        let new_expr_2 = range_expr("u", 50, 150);
+        let new_expr_3 = range_expr("u", 150, 250);
+
+        let manifest_1 = create_manifest(old_region_1, 3, Some(old_expr_1.clone()), 100, 200);
+        let manifest_2 = create_manifest(old_region_2, 4, Some(old_expr_2.clone()), 150, 250);
+
+        let mut old_manifests = HashMap::new();
+        old_manifests.insert(old_region_1, manifest_1);
+        old_manifests.insert(old_region_2, manifest_2);
+
+        let mut new_partition_exprs = HashMap::new();
+        new_partition_exprs.insert(new_region_1, new_expr_1);
+        new_partition_exprs.insert(new_region_2, new_expr_2);
+        new_partition_exprs.insert(new_region_3, new_expr_3);
+
+        // Direct mapping:
+        // old region 1 -> new regions 1, 2
+        // old region 2 -> new regions 2, 3
+        let mut region_mapping = HashMap::new();
+        region_mapping.insert(old_region_1, vec![new_region_1, new_region_2]);
+        region_mapping.insert(old_region_2, vec![new_region_2, new_region_3]);
+
+        let mut remapper = RemapManifest::new(old_manifests, new_partition_exprs, region_mapping);
+
+        let result = remapper.remap_manifests().unwrap();
+
+        assert_eq!(result.new_manifests.len(), 3);
+        assert_eq!(result.new_manifests[&new_region_1].files.len(), 3);
+        assert_eq!(result.new_manifests[&new_region_2].files.len(), 7); // 3 + 4
+        assert_eq!(result.new_manifests[&new_region_3].files.len(), 4);
+        assert_eq!(result.stats.total_file_refs, 14); // 3 + 7 + 4
+        assert_eq!(result.stats.unique_files, 7); // 3 + 4 unique
+    }
+}
diff --git a/src/mito2/src/request.rs b/src/mito2/src/request.rs
index 6ec797e2dc..d7748fd077 100644
--- a/src/mito2/src/request.rs
+++ b/src/mito2/src/request.rs
@@ -182,7 +182,7 @@ impl WriteRequest {
                 ensure!(
                     is_column_type_value_eq(
                         input_col.datatype,
-                        input_col.datatype_extension,
+                        input_col.datatype_extension.clone(),
                         &column.column_schema.data_type
                     ),
                     InvalidRequestSnafu {
@@ -411,13 +411,7 @@ impl WriteRequest {
         };
 
         // Convert default value into proto's value.
-        to_proto_value(default_value).with_context(|| InvalidRequestSnafu {
-            region_id: self.region_id,
-            reason: format!(
-                "no protobuf type for default value of column {} ({:?})",
-                column.column_schema.name, column.column_schema.data_type
-            ),
-        })
+        Ok(to_proto_value(default_value))
     }
 }
 
diff --git a/src/mito2/src/sst/index/fulltext_index/applier/builder.rs b/src/mito2/src/sst/index/fulltext_index/applier/builder.rs
index 225a5c5307..ea4d0063f9 100644
--- a/src/mito2/src/sst/index/fulltext_index/applier/builder.rs
+++ b/src/mito2/src/sst/index/fulltext_index/applier/builder.rs
@@ -211,7 +211,7 @@ impl<'a> FulltextIndexApplierBuilder<'a> {
             return None;
         };
 
-        Some((column.column_id, FulltextQuery(query.to_string())))
+        Some((column.column_id, FulltextQuery(query.clone())))
     }
 
     fn expr_to_term(
@@ -256,7 +256,7 @@ impl<'a> FulltextIndexApplierBuilder<'a> {
             column.column_id,
             FulltextTerm {
                 col_lowered: lowered,
-                term: term.to_string(),
+                term: term.clone(),
             },
         ))
     }
diff --git a/src/mito2/src/sst/index/fulltext_index/creator.rs b/src/mito2/src/sst/index/fulltext_index/creator.rs
index 57e677b915..5a7c92dd46 100644
--- a/src/mito2/src/sst/index/fulltext_index/creator.rs
+++ b/src/mito2/src/sst/index/fulltext_index/creator.rs
@@ -540,15 +540,15 @@ mod tests {
 
         for (text_english_case_sensitive, text_english_case_insensitive, text_chinese) in rows {
             match text_english_case_sensitive {
-                Some(s) => vec_english_sensitive.push_value_ref((*s).into()),
+                Some(s) => vec_english_sensitive.push_value_ref(&(*s).into()),
                 None => vec_english_sensitive.push_null(),
             }
             match text_english_case_insensitive {
-                Some(s) => vec_english_insensitive.push_value_ref((*s).into()),
+                Some(s) => vec_english_insensitive.push_value_ref(&(*s).into()),
                 None => vec_english_insensitive.push_null(),
             }
             match text_chinese {
-                Some(s) => vec_chinese.push_value_ref((*s).into()),
+                Some(s) => vec_chinese.push_value_ref(&(*s).into()),
                 None => vec_chinese.push_null(),
             }
         }
diff --git a/src/mito2/src/sst/parquet/flat_format.rs b/src/mito2/src/sst/parquet/flat_format.rs
index dda150485e..2dc30bb364 100644
--- a/src/mito2/src/sst/parquet/flat_format.rs
+++ b/src/mito2/src/sst/parquet/flat_format.rs
@@ -669,14 +669,14 @@ impl FlatConvertFormat {
                     match decoded {
                         CompositeValues::Dense(dense) => {
                             if pk_index < dense.len() {
-                                builder.push_value_ref(dense[pk_index].1.as_value_ref());
+                                builder.push_value_ref(&dense[pk_index].1.as_value_ref());
                             } else {
                                 builder.push_null();
                             }
                         }
                         CompositeValues::Sparse(sparse) => {
                             let value = sparse.get_or_null(column_id);
-                            builder.push_value_ref(value.as_value_ref());
+                            builder.push_value_ref(&value.as_value_ref());
                         }
                     };
                 }
diff --git a/src/mito2/src/sst/parquet/format.rs b/src/mito2/src/sst/parquet/format.rs
index 4297071e4d..f6b9c4272b 100644
--- a/src/mito2/src/sst/parquet/format.rs
+++ b/src/mito2/src/sst/parquet/format.rs
@@ -747,7 +747,7 @@ impl PrimaryKeyReadFormat {
         for value_opt in values {
             match value_opt {
                 // Safety: We use the same data type to create the converter.
-                Some(v) => builder.push_value_ref(v.as_value_ref()),
+                Some(v) => builder.push_value_ref(&v.as_value_ref()),
                 None => builder.push_null(),
             }
         }
diff --git a/src/mito2/src/test_util.rs b/src/mito2/src/test_util.rs
index 7c1e1dbac6..443377170a 100644
--- a/src/mito2/src/test_util.rs
+++ b/src/mito2/src/test_util.rs
@@ -813,7 +813,7 @@ impl CreateRequestBuilder {
         let mut options = self.options.clone();
         if let Some(topic) = &self.kafka_topic {
             let wal_options = WalOptions::Kafka(KafkaWalOptions {
-                topic: topic.to_string(),
+                topic: topic.clone(),
             });
             options.insert(
                 WAL_OPTIONS_KEY.to_string(),
@@ -821,7 +821,7 @@ impl CreateRequestBuilder {
             );
         }
         RegionCreateRequest {
-            engine: self.engine.to_string(),
+            engine: self.engine.clone(),
             column_metadatas,
             primary_key: self.primary_key.clone().unwrap_or(primary_key),
             options,
diff --git a/src/mito2/src/worker/handle_open.rs b/src/mito2/src/worker/handle_open.rs
index aa9423b526..4d71289c08 100644
--- a/src/mito2/src/worker/handle_open.rs
+++ b/src/mito2/src/worker/handle_open.rs
@@ -43,8 +43,8 @@ impl<S: LogStore> RegionWorkerLoop<S> {
         let object_store = if let Some(storage_name) = request.options.get(STORAGE_KEY) {
             self.object_store_manager
                 .find(storage_name)
-                .context(ObjectStoreNotFoundSnafu {
-                    object_store: storage_name.to_string(),
+                .with_context(|| ObjectStoreNotFoundSnafu {
+                    object_store: storage_name.clone(),
                 })?
         } else {
             self.object_store_manager.default_object_store()
diff --git a/src/object-store/src/layers/lru_cache/read_cache.rs b/src/object-store/src/layers/lru_cache/read_cache.rs
index 017cb9fb3b..721ee74483 100644
--- a/src/object-store/src/layers/lru_cache/read_cache.rs
+++ b/src/object-store/src/layers/lru_cache/read_cache.rs
@@ -181,7 +181,7 @@ impl<C: Access> ReadCache<C> {
             OBJECT_STORE_LRU_CACHE_BYTES.add(size as i64);
 
             self.mem_cache
-                .insert(read_key.to_string(), ReadResult::Success(size as u32))
+                .insert(read_key.clone(), ReadResult::Success(size as u32))
                 .await;
         }
 
diff --git a/src/operator/src/expr_helper.rs b/src/operator/src/expr_helper.rs
index 8658a7fdb2..b3a503a499 100644
--- a/src/operator/src/expr_helper.rs
+++ b/src/operator/src/expr_helper.rs
@@ -194,7 +194,7 @@ pub(crate) async fn create_external_expr(
         create_if_not_exists: create.if_not_exists,
         table_options,
         table_id: None,
-        engine: create.engine.to_string(),
+        engine: create.engine.clone(),
     };
 
     Ok(expr)
@@ -234,7 +234,7 @@ pub fn create_to_expr(
         create_if_not_exists: create.if_not_exists,
         table_options,
         table_id: None,
-        engine: create.engine.to_string(),
+        engine: create.engine.clone(),
     };
 
     validate_create_expr(&expr)?;
@@ -604,7 +604,7 @@ pub fn find_time_index(constraints: &[TableConstraint]) -> Result<String> {
             err_msg: "must have one and only one TimeIndex columns",
         }
     );
-    Ok(time_index.first().unwrap().to_string())
+    Ok(time_index[0].clone())
 }
 
 fn columns_to_expr(
@@ -748,12 +748,12 @@ pub(crate) fn to_alter_table_expr(
         }
         AlterTableOperation::DropColumn { name } => AlterTableKind::DropColumns(DropColumns {
             drop_columns: vec![DropColumn {
-                name: name.value.to_string(),
+                name: name.value.clone(),
             }],
         }),
         AlterTableOperation::RenameTable { new_table_name } => {
             AlterTableKind::RenameTable(RenameTable {
-                new_table_name: new_table_name.to_string(),
+                new_table_name: new_table_name.clone(),
             })
         }
         AlterTableOperation::SetTableOptions { options } => {
diff --git a/src/operator/src/insert.rs b/src/operator/src/insert.rs
index 44f6233aa1..cb63b07772 100644
--- a/src/operator/src/insert.rs
+++ b/src/operator/src/insert.rs
@@ -306,7 +306,7 @@ impl Inserter {
             .create_or_alter_tables_on_demand(
                 &mut requests,
                 &ctx,
-                AutoCreateTableType::Logical(physical_table.to_string()),
+                AutoCreateTableType::Logical(physical_table.clone()),
                 statement_executor,
                 true,
                 true,
@@ -881,8 +881,8 @@ impl Inserter {
 
         Ok(Some(AlterTableExpr {
             catalog_name: catalog_name.to_string(),
-            schema_name: schema_name.to_string(),
-            table_name: table_name.to_string(),
+            schema_name: schema_name.clone(),
+            table_name: table_name.clone(),
             kind: Some(Kind::AddColumns(add_columns)),
         }))
     }
@@ -1010,7 +1010,7 @@ pub fn fill_table_options_for_create(
         AutoCreateTableType::Logical(physical_table) => {
             table_options.insert(
                 LOGICAL_TABLE_METADATA_KEY.to_string(),
-                physical_table.to_string(),
+                physical_table.clone(),
             );
         }
         AutoCreateTableType::Physical => {
diff --git a/src/operator/src/lib.rs b/src/operator/src/lib.rs
index 8c69a1e616..783501c6f0 100644
--- a/src/operator/src/lib.rs
+++ b/src/operator/src/lib.rs
@@ -14,7 +14,6 @@
 
 #![feature(assert_matches)]
 #![feature(if_let_guard)]
-#![feature(let_chains)]
 
 mod bulk_insert;
 pub mod delete;
diff --git a/src/operator/src/req_convert/common.rs b/src/operator/src/req_convert/common.rs
index 9221d6522e..37529d55c6 100644
--- a/src/operator/src/req_convert/common.rs
+++ b/src/operator/src/req_convert/common.rs
@@ -112,7 +112,7 @@ fn validate_rows(rows: &Option<Rows>) -> Result<()> {
 
     for (col_idx, schema) in rows.schema.iter().enumerate() {
         let column_type =
-            ColumnDataTypeWrapper::try_new(schema.datatype, schema.datatype_extension)
+            ColumnDataTypeWrapper::try_new(schema.datatype, schema.datatype_extension.clone())
                 .context(ColumnDataTypeSnafu)?
                 .into();
 
@@ -172,7 +172,7 @@ pub fn columns_to_rows(columns: Vec<Column>, row_count: u32) -> Result<Rows> {
             column_name: column.column_name.clone(),
             datatype: column.datatype,
             semantic_type: column.semantic_type,
-            datatype_extension: column.datatype_extension,
+            datatype_extension: column.datatype_extension.clone(),
             options: column.options.clone(),
         };
         schema.push(column_schema);
@@ -292,6 +292,8 @@ fn push_column_to_rows(column: Column, rows: &mut [Row]) -> Result<()> {
         ),
         (Decimal128, Decimal128Value, decimal128_values),
         (Vector, BinaryValue, binary_values),
+        (List, ListValue, list_values),
+        (Struct, StructValue, struct_values),
     );
 
     Ok(())
@@ -352,7 +354,7 @@ fn semantic_type(table_info: &TableInfo, column: &str) -> Result<SemanticType> {
     let time_index_column = &table_schema
         .timestamp_column()
         .with_context(|| table::error::MissingTimeIndexColumnSnafu {
-            table_name: table_info.name.to_string(),
+            table_name: table_info.name.clone(),
         })
         .context(MissingTimeIndexColumnSnafu)?
         .name;
diff --git a/src/operator/src/req_convert/insert.rs b/src/operator/src/req_convert/insert.rs
index 88d402b0ac..f9bf83d926 100644
--- a/src/operator/src/req_convert/insert.rs
+++ b/src/operator/src/req_convert/insert.rs
@@ -36,7 +36,7 @@ fn semantic_type(table_info: &TableInfo, column: &str) -> Result<SemanticType> {
     let time_index_column = &table_schema
         .timestamp_column()
         .with_context(|| table::error::MissingTimeIndexColumnSnafu {
-            table_name: table_info.name.to_string(),
+            table_name: table_info.name.clone(),
         })
         .context(MissingTimeIndexColumnSnafu)?
         .name;
diff --git a/src/operator/src/req_convert/insert/fill_impure_default.rs b/src/operator/src/req_convert/insert/fill_impure_default.rs
index cf1e1565a8..0de49611d9 100644
--- a/src/operator/src/req_convert/insert/fill_impure_default.rs
+++ b/src/operator/src/req_convert/insert/fill_impure_default.rs
@@ -38,7 +38,7 @@ pub fn find_all_impure_columns(table_info: &TableInfo) -> Vec<ColumnSchema> {
 
 /// Fill impure default values in the request
 pub struct ImpureDefaultFiller {
-    impure_columns: HashMap<String, (api::v1::ColumnSchema, Option<api::v1::Value>)>,
+    impure_columns: HashMap<String, (api::v1::ColumnSchema, api::v1::Value)>,
 }
 
 impl ImpureDefaultFiller {
@@ -100,7 +100,7 @@ impl ImpureDefaultFiller {
             .iter()
             .filter_map(|(name, (schema, val))| {
                 if !impure_columns_in_reqs.contains(name) {
-                    Some((schema.clone(), val.clone().unwrap_or_default()))
+                    Some((schema.clone(), val.clone()))
                 } else {
                     None
                 }
diff --git a/src/operator/src/statement.rs b/src/operator/src/statement.rs
index 2d361e48a7..47a8994985 100644
--- a/src/operator/src/statement.rs
+++ b/src/operator/src/statement.rs
@@ -174,7 +174,7 @@ impl StatementExecutor {
     ) -> Result<Output> {
         match stmt {
             QueryStatement::Sql(stmt) => self.execute_sql(stmt, query_ctx).await,
-            QueryStatement::Promql(_) => self.plan_exec(stmt, query_ctx).await,
+            QueryStatement::Promql(_, _) => self.plan_exec(stmt, query_ctx).await,
         }
     }
 
diff --git a/src/operator/src/statement/admin.rs b/src/operator/src/statement/admin.rs
index d512ebef64..f97e9e552e 100644
--- a/src/operator/src/statement/admin.rs
+++ b/src/operator/src/statement/admin.rs
@@ -280,7 +280,7 @@ fn values_to_vectors_by_valid_types(
 fn value_to_vector(value: Value) -> VectorRef {
     let data_type = value.data_type();
     let mut mutable_vector = data_type.create_mutable_vector(1);
-    mutable_vector.push_value_ref(value.as_value_ref());
+    mutable_vector.push_value_ref(&value.as_value_ref());
 
     mutable_vector.to_vector()
 }
diff --git a/src/operator/src/statement/copy_table_from.rs b/src/operator/src/statement/copy_table_from.rs
index 3a6a9d15c6..da120ff1bf 100644
--- a/src/operator/src/statement/copy_table_from.rs
+++ b/src/operator/src/statement/copy_table_from.rs
@@ -116,7 +116,7 @@ impl StatementExecutor {
             Source::Dir
         };
 
-        let lister = Lister::new(object_store.clone(), source.clone(), dir.to_string(), regex);
+        let lister = Lister::new(object_store.clone(), source.clone(), dir.clone(), regex);
 
         let entries = lister.list().await.context(error::ListObjectsSnafu)?;
         debug!("Copy from dir: {dir:?}, {source:?}, entries: {entries:?}");
@@ -430,7 +430,7 @@ impl StatementExecutor {
             let fields = projected_table_schema
                 .fields()
                 .iter()
-                .map(|f| f.name().to_string())
+                .map(|f| f.name().clone())
                 .collect::<Vec<_>>();
 
             // TODO(hl): make this configurable through options.
@@ -453,9 +453,9 @@ impl StatementExecutor {
 
                 pending.push(self.inserter.handle_table_insert(
                     InsertRequest {
-                        catalog_name: req.catalog_name.to_string(),
-                        schema_name: req.schema_name.to_string(),
-                        table_name: req.table_name.to_string(),
+                        catalog_name: req.catalog_name.clone(),
+                        schema_name: req.schema_name.clone(),
+                        table_name: req.table_name.clone(),
                         columns_values,
                     },
                     query_ctx.clone(),
diff --git a/src/operator/src/statement/cursor.rs b/src/operator/src/statement/cursor.rs
index f5d07da9f9..2d9889cdd3 100644
--- a/src/operator/src/statement/cursor.rs
+++ b/src/operator/src/statement/cursor.rs
@@ -36,7 +36,7 @@ impl StatementExecutor {
 
         if query_ctx.get_cursor(&cursor_name).is_some() {
             error::CursorExistsSnafu {
-                name: cursor_name.to_string(),
+                name: cursor_name.clone(),
             }
             .fail()?;
         }
diff --git a/src/operator/src/statement/ddl.rs b/src/operator/src/statement/ddl.rs
index 96cb230418..8bd454a71d 100644
--- a/src/operator/src/statement/ddl.rs
+++ b/src/operator/src/statement/ddl.rs
@@ -1014,7 +1014,7 @@ impl StatementExecutor {
             let schema = if expr.schema_name.is_empty() {
                 query_context.current_schema()
             } else {
-                expr.schema_name.to_string()
+                expr.schema_name.clone()
             };
             let table_name = &expr.table_name;
             let table = self
@@ -1446,9 +1446,9 @@ impl StatementExecutor {
         let request = SubmitDdlTaskRequest {
             query_context,
             task: DdlTask::new_drop_table(
-                table_name.catalog_name.to_string(),
-                table_name.schema_name.to_string(),
-                table_name.table_name.to_string(),
+                table_name.catalog_name.clone(),
+                table_name.schema_name.clone(),
+                table_name.table_name.clone(),
                 table_id,
                 drop_if_exists,
             ),
@@ -1504,9 +1504,9 @@ impl StatementExecutor {
         let request = SubmitDdlTaskRequest {
             query_context,
             task: DdlTask::new_truncate_table(
-                table_name.catalog_name.to_string(),
-                table_name.schema_name.to_string(),
-                table_name.table_name.to_string(),
+                table_name.catalog_name.clone(),
+                table_name.schema_name.clone(),
+                table_name.table_name.clone(),
                 table_id,
                 time_ranges,
             ),
@@ -1784,7 +1784,7 @@ fn find_partition_entries(
                 .unwrap();
             let column_name = &column.name;
             let data_type = ConcreteDataType::from(
-                ColumnDataTypeWrapper::try_new(column.data_type, column.datatype_extension)
+                ColumnDataTypeWrapper::try_new(column.data_type, column.datatype_extension.clone())
                     .context(ColumnDataTypeSnafu)?,
             );
             Ok((column_name, data_type))
diff --git a/src/operator/src/statement/tql.rs b/src/operator/src/statement/tql.rs
index cc4adc7ca8..03ad3f4976 100644
--- a/src/operator/src/statement/tql.rs
+++ b/src/operator/src/statement/tql.rs
@@ -42,6 +42,7 @@ impl StatementExecutor {
                     lookback: eval
                         .lookback
                         .unwrap_or_else(|| DEFAULT_LOOKBACK_STRING.to_string()),
+                    alias: eval.alias,
                 };
                 QueryLanguageParser::parse_promql(&promql, query_ctx).context(ParseQuerySnafu)?
             }
@@ -82,6 +83,7 @@ impl StatementExecutor {
                     lookback: analyze
                         .lookback
                         .unwrap_or_else(|| DEFAULT_LOOKBACK_STRING.to_string()),
+                    alias: analyze.alias,
                 };
                 let analyze_node_name = if analyze.is_verbose {
                     ANALYZE_VERBOSE_NODE_NAME
diff --git a/src/partition/src/lib.rs b/src/partition/src/lib.rs
index 41aa55a785..896f675922 100644
--- a/src/partition/src/lib.rs
+++ b/src/partition/src/lib.rs
@@ -13,8 +13,7 @@
 // limitations under the License.
 
 #![feature(assert_matches)]
-#![feature(let_chains)]
-//! Structs and traits for partitioning rule.   
+//! Structs and traits for partitioning rule.
 
 pub mod checker;
 pub mod collider;
@@ -22,7 +21,9 @@ pub mod error;
 pub mod expr;
 pub mod manager;
 pub mod multi_dim;
+pub mod overlap;
 pub mod partition;
 pub mod splitter;
+pub mod subtask;
 
 pub use crate::partition::{PartitionRule, PartitionRuleRef};
diff --git a/src/partition/src/overlap.rs b/src/partition/src/overlap.rs
new file mode 100644
index 0000000000..5d9af3cabf
--- /dev/null
+++ b/src/partition/src/overlap.rs
@@ -0,0 +1,334 @@
+// 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.
+
+//! Rule overlap and association utilities.
+//!
+//! This module provides pure functions to determine overlap relationships between
+//! partition expressions and to associate rule sets.
+
+use std::cmp::Ordering;
+use std::ops::Bound;
+
+use datatypes::value::OrderedF64;
+
+use crate::collider::{AtomicExpr, Collider, GluonOp, NucleonExpr};
+use crate::error::Result;
+use crate::expr::PartitionExpr;
+
+/// Check if two atomic expressions can be both satisfied, i.e., whether they
+/// overlap on all common columns.
+pub fn atomic_exprs_overlap(lhs: &AtomicExpr, rhs: &AtomicExpr) -> bool {
+    // Merge-walk over columns since nucleons are sorted by (column, op, value)
+    let mut lhs_index = 0;
+    let mut rhs_index = 0;
+
+    while lhs_index < lhs.nucleons.len() && rhs_index < rhs.nucleons.len() {
+        let lhs_col = lhs.nucleons[lhs_index].column();
+        let rhs_col = rhs.nucleons[rhs_index].column();
+
+        match lhs_col.cmp(rhs_col) {
+            Ordering::Equal => {
+                // advance to the next column boundaries in both atomics
+                let mut lhs_next = lhs_index;
+                let mut rhs_next = rhs_index;
+                while lhs_next < lhs.nucleons.len() && lhs.nucleons[lhs_next].column() == lhs_col {
+                    lhs_next += 1;
+                }
+                while rhs_next < rhs.nucleons.len() && rhs.nucleons[rhs_next].column() == rhs_col {
+                    rhs_next += 1;
+                }
+
+                let lhs_range = nucleons_to_range(&lhs.nucleons[lhs_index..lhs_next]);
+                let rhs_range = nucleons_to_range(&rhs.nucleons[rhs_index..rhs_next]);
+
+                if !lhs_range.overlaps_with(&rhs_range) {
+                    return false;
+                }
+
+                lhs_index = lhs_next;
+                rhs_index = rhs_next;
+            }
+            Ordering::Less => {
+                // column appears only in `lhs`, skip all nucleons for this column
+                let col = lhs_col;
+                while lhs_index < lhs.nucleons.len() && lhs.nucleons[lhs_index].column() == col {
+                    lhs_index += 1;
+                }
+            }
+            Ordering::Greater => {
+                // column appears only in `rhs`, skip all nucleons for this column
+                let col = rhs_col;
+                while rhs_index < rhs.nucleons.len() && rhs.nucleons[rhs_index].column() == col {
+                    rhs_index += 1;
+                }
+            }
+        }
+    }
+
+    true
+}
+
+/// Pairwise overlap check between two expression lists.
+///
+/// Returns true if two [`PartitionExpr`]s are overlapping (any pair of atomics overlaps).
+fn expr_pair_overlap(lhs: &PartitionExpr, rhs: &PartitionExpr) -> Result<bool> {
+    let binding = [lhs.clone(), rhs.clone()];
+    let collider = Collider::new(&binding)?;
+    // Split atomic exprs by source index
+    let mut lhs_atoms = Vec::new();
+    let mut rhs_atoms = Vec::new();
+    for atomic in collider.atomic_exprs.iter() {
+        if atomic.source_expr_index == 0 {
+            lhs_atoms.push(atomic);
+        } else {
+            rhs_atoms.push(atomic);
+        }
+    }
+    for lhs_atomic in &lhs_atoms {
+        for rhs_atomic in &rhs_atoms {
+            if atomic_exprs_overlap(lhs_atomic, rhs_atomic) {
+                return Ok(true);
+            }
+        }
+    }
+    Ok(false)
+}
+
+/// Associates each expression in `from_exprs` with indices of overlapping expressions in `to_exprs`.
+///
+/// Output vector length equals `from_exprs.len()`, and each inner vector contains indices into
+/// `to_exprs` that overlap with the corresponding `from_exprs[i]`.
+pub fn associate_from_to(
+    from_exprs: &[PartitionExpr],
+    to_exprs: &[PartitionExpr],
+) -> Result<Vec<Vec<usize>>> {
+    let mut result = Vec::with_capacity(from_exprs.len());
+    for from in from_exprs.iter() {
+        let mut targets = Vec::new();
+        for (i, to) in to_exprs.iter().enumerate() {
+            if expr_pair_overlap(from, to)? {
+                targets.push(i);
+            }
+        }
+        result.push(targets);
+    }
+    Ok(result)
+}
+
+/// Represents a value range derived from a group of nucleons for the same column
+#[derive(Debug, Clone)]
+struct ValueRange {
+    lower: Bound<OrderedF64>,
+    upper: Bound<OrderedF64>,
+}
+
+impl ValueRange {
+    fn new() -> Self {
+        Self {
+            lower: Bound::Unbounded,
+            upper: Bound::Unbounded,
+        }
+    }
+
+    fn update_lower(&mut self, new_lower: Bound<OrderedF64>) {
+        match (&self.lower, &new_lower) {
+            (Bound::Unbounded, _) => self.lower = new_lower,
+            (_, Bound::Unbounded) => {}
+            (Bound::Included(cur), Bound::Included(new))
+            | (Bound::Excluded(cur), Bound::Included(new))
+            | (Bound::Included(cur), Bound::Excluded(new))
+            | (Bound::Excluded(cur), Bound::Excluded(new)) => {
+                if new > cur {
+                    self.lower = new_lower;
+                }
+            }
+        }
+    }
+
+    fn update_upper(&mut self, new_upper: Bound<OrderedF64>) {
+        match (&self.upper, &new_upper) {
+            (Bound::Unbounded, _) => self.upper = new_upper,
+            (_, Bound::Unbounded) => {}
+            (Bound::Included(cur), Bound::Included(new))
+            | (Bound::Excluded(cur), Bound::Included(new))
+            | (Bound::Included(cur), Bound::Excluded(new))
+            | (Bound::Excluded(cur), Bound::Excluded(new)) => {
+                if new < cur {
+                    self.upper = new_upper;
+                }
+            }
+        }
+    }
+
+    fn overlaps_with(&self, other: &Self) -> bool {
+        fn no_overlap(upper: &Bound<OrderedF64>, lower: &Bound<OrderedF64>) -> bool {
+            match (upper, lower) {
+                (Bound::Unbounded, _) | (_, Bound::Unbounded) => false,
+                // u], [l
+                (Bound::Included(u), Bound::Included(l)) => u < l,
+                // u], (l) or u), [l or u), (l)
+                (Bound::Included(u), Bound::Excluded(l))
+                | (Bound::Excluded(u), Bound::Included(l))
+                | (Bound::Excluded(u), Bound::Excluded(l)) => u <= l,
+            }
+        }
+
+        if no_overlap(&self.upper, &other.lower) || no_overlap(&other.upper, &self.lower) {
+            return false;
+        }
+        true
+    }
+}
+
+/// Convert nucleons for the same column into a ValueRange
+fn nucleons_to_range(nucleons: &[NucleonExpr]) -> ValueRange {
+    use GluonOp::*;
+
+    let mut range = ValueRange::new();
+    for n in nucleons {
+        let v = n.value();
+        match n.op() {
+            Eq => {
+                range.lower = Bound::Included(v);
+                range.upper = Bound::Included(v);
+                break;
+            }
+            Lt => range.update_upper(Bound::Excluded(v)),
+            LtEq => range.update_upper(Bound::Included(v)),
+            Gt => range.update_lower(Bound::Excluded(v)),
+            GtEq => range.update_lower(Bound::Included(v)),
+            NotEq => continue, // handled elsewhere as separate atomics
+        }
+    }
+    range
+}
+
+#[cfg(test)]
+mod tests {
+    use datatypes::value::Value;
+
+    use super::*;
+    use crate::expr::{Operand, PartitionExpr, RestrictedOp, col};
+
+    #[test]
+    fn test_pair_overlap_simple() {
+        let a = col("user_id")
+            .gt_eq(Value::Int64(0))
+            .and(col("user_id").lt(Value::Int64(100)));
+        let b = col("user_id").eq(Value::Int64(50));
+        assert!(expr_pair_overlap(&a, &b).unwrap());
+
+        let c = col("user_id")
+            .gt_eq(Value::Int64(100))
+            .and(col("user_id").lt(Value::Int64(200)));
+        assert!(!expr_pair_overlap(&a, &c).unwrap());
+    }
+
+    #[test]
+    fn test_associate_from_to() {
+        // from: [ [0,100), [100,200) ]
+        let from = vec![
+            col("user_id")
+                .gt_eq(Value::Int64(0))
+                .and(col("user_id").lt(Value::Int64(100))),
+            col("user_id")
+                .gt_eq(Value::Int64(100))
+                .and(col("user_id").lt(Value::Int64(200))),
+        ];
+        // to: [ [0,150), [150,300) ]
+        let to = vec![
+            col("user_id")
+                .gt_eq(Value::Int64(0))
+                .and(col("user_id").lt(Value::Int64(150))),
+            col("user_id")
+                .gt_eq(Value::Int64(150))
+                .and(col("user_id").lt(Value::Int64(300))),
+        ];
+        let assoc = associate_from_to(&from, &to).unwrap();
+        assert_eq!(assoc.len(), 2);
+        // [0,100) overlaps only with [0,150)
+        assert_eq!(assoc[0], vec![0]);
+        // [100,200) overlaps both [0,150) and [150,300)
+        assert_eq!(assoc[1], vec![0, 1]);
+    }
+
+    #[test]
+    fn test_expr_with_or() {
+        // a: (user_id = 10 OR user_id = 20)
+        let a = PartitionExpr::new(
+            Operand::Expr(col("user_id").eq(Value::Int64(10))),
+            RestrictedOp::Or,
+            Operand::Expr(col("user_id").eq(Value::Int64(20))),
+        );
+        let b = col("user_id")
+            .gt_eq(Value::Int64(15))
+            .and(col("user_id").lt_eq(Value::Int64(25)));
+        assert!(expr_pair_overlap(&a, &b).unwrap());
+    }
+
+    #[test]
+    fn test_adjacent_ranges_non_overlap() {
+        // [0, 100) vs [100, 200) -> no overlap
+        let from = vec![
+            col("k")
+                .gt_eq(Value::Int64(0))
+                .and(col("k").lt(Value::Int64(100))),
+        ];
+        let to = vec![
+            col("k")
+                .gt_eq(Value::Int64(100))
+                .and(col("k").lt(Value::Int64(200))),
+        ];
+        let assoc = associate_from_to(&from, &to).unwrap();
+        assert_eq!(assoc[0], Vec::<usize>::new());
+    }
+
+    #[test]
+    fn test_multi_column_conflict_no_overlap() {
+        // Left: a in [0,10) AND b >= 5
+        let left = col("a")
+            .gt_eq(Value::Int64(0))
+            .and(col("a").lt(Value::Int64(10)))
+            .and(col("b").gt_eq(Value::Int64(5)));
+        // Right: a = 9 AND b < 5 -> conflict on b
+        let right = col("a")
+            .eq(Value::Int64(9))
+            .and(col("b").lt(Value::Int64(5)));
+        assert!(!expr_pair_overlap(&left, &right).unwrap());
+    }
+
+    #[test]
+    fn test_disjoint_columns_overlap() {
+        // Different columns don't constrain each other => satisfiable together
+        let from = vec![col("a").eq(Value::Int64(1))];
+        let to = vec![col("b").eq(Value::Int64(2))];
+        let assoc = associate_from_to(&from, &to).unwrap();
+        assert_eq!(assoc[0], vec![0]);
+    }
+
+    #[test]
+    fn test_boundary_inclusive_exclusive() {
+        // Left: a <= 10 AND a >= 10 => a = 10
+        let left = col("a")
+            .lt_eq(Value::Int64(10))
+            .and(col("a").gt_eq(Value::Int64(10)));
+        // Right: a = 10 -> overlap
+        let right_eq = col("a").eq(Value::Int64(10));
+        assert!(expr_pair_overlap(&left, &right_eq).unwrap());
+
+        // Left: a < 10, Right: a = 10 -> no overlap
+        let left_lt = col("a").lt(Value::Int64(10));
+        assert!(!expr_pair_overlap(&left_lt, &right_eq).unwrap());
+    }
+}
diff --git a/src/partition/src/splitter.rs b/src/partition/src/splitter.rs
index 28bad396a3..fa19b74ad3 100644
--- a/src/partition/src/splitter.rs
+++ b/src/partition/src/splitter.rs
@@ -119,7 +119,7 @@ impl<'a> SplitReadRowHelper<'a> {
                     idx.as_ref().map_or(Value::Null, |idx| {
                         helper::pb_value_to_value_ref(
                             &row.values[*idx],
-                            &self.schema[*idx].datatype_extension,
+                            self.schema[*idx].datatype_extension.as_ref(),
                         )
                         .into()
                     })
diff --git a/src/partition/src/subtask.rs b/src/partition/src/subtask.rs
new file mode 100644
index 0000000000..e74e9872f5
--- /dev/null
+++ b/src/partition/src/subtask.rs
@@ -0,0 +1,306 @@
+// 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::VecDeque;
+
+use crate::error::Result;
+use crate::expr::PartitionExpr;
+use crate::overlap::associate_from_to;
+
+/// Indices are into the original input arrays (array of [`PartitionExpr`]). A connected component.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RepartitionSubtask {
+    pub from_expr_indices: Vec<usize>,
+    pub to_expr_indices: Vec<usize>,
+    /// For each `from_expr_indices[k]`, the corresponding vector contains global
+    /// `to_expr_indices` that overlap with it (indices into the original `to_exprs`).
+    pub transition_map: Vec<Vec<usize>>,
+}
+
+/// Create independent subtasks out of given FROM/TO partition expressions.
+pub fn create_subtasks(
+    from_exprs: &[PartitionExpr],
+    to_exprs: &[PartitionExpr],
+) -> Result<Vec<RepartitionSubtask>> {
+    // FROM -> TO
+    let assoc = associate_from_to(from_exprs, to_exprs)?;
+    if !assoc.iter().any(|v| !v.is_empty()) {
+        return Ok(vec![]);
+    }
+
+    // TO -> FROM
+    let mut rev = vec![Vec::new(); to_exprs.len()];
+    for (li, rights) in assoc.iter().enumerate() {
+        for &r in rights {
+            rev[r].push(li);
+        }
+    }
+
+    // FROM(left), TO(right). Undirected
+    let mut visited_left = vec![false; from_exprs.len()];
+    let mut visited_right = vec![false; to_exprs.len()];
+    let mut subtasks = Vec::new();
+
+    for li in 0..from_exprs.len() {
+        if assoc[li].is_empty() || visited_left[li] {
+            continue;
+        }
+
+        #[derive(Copy, Clone)]
+        enum Node {
+            Left(usize),
+            Right(usize),
+        }
+        let mut left_set = Vec::new();
+        let mut right_set = Vec::new();
+        let mut queue = VecDeque::new();
+
+        visited_left[li] = true;
+        queue.push_back(Node::Left(li));
+
+        while let Some(node) = queue.pop_front() {
+            match node {
+                Node::Left(left) => {
+                    left_set.push(left);
+                    for &r in &assoc[left] {
+                        if !visited_right[r] {
+                            visited_right[r] = true;
+                            queue.push_back(Node::Right(r));
+                        }
+                    }
+                }
+                Node::Right(right) => {
+                    right_set.push(right);
+                    for &l in &rev[right] {
+                        if !visited_left[l] {
+                            visited_left[l] = true;
+                            queue.push_back(Node::Left(l));
+                        }
+                    }
+                }
+            }
+        }
+
+        left_set.sort_unstable();
+        right_set.sort_unstable();
+
+        let transition_map = left_set
+            .iter()
+            .map(|&i| assoc[i].clone())
+            .collect::<Vec<_>>();
+
+        subtasks.push(RepartitionSubtask {
+            from_expr_indices: left_set,
+            to_expr_indices: right_set,
+            transition_map,
+        });
+    }
+
+    Ok(subtasks)
+}
+
+#[cfg(test)]
+mod tests {
+    use datatypes::value::Value;
+
+    use super::*;
+    use crate::expr::col;
+    #[test]
+    fn test_split_one_to_two() {
+        // Left: [0, 40)
+        let from = vec![
+            col("u")
+                .gt_eq(Value::Int64(0))
+                .and(col("u").lt(Value::Int64(20))),
+        ];
+
+        // Right: [0, 10), [10, 20)
+        let to = vec![
+            col("u")
+                .gt_eq(Value::Int64(0))
+                .and(col("u").lt(Value::Int64(10))),
+            col("u")
+                .gt_eq(Value::Int64(10))
+                .and(col("u").lt(Value::Int64(20))),
+        ];
+
+        let subtasks = create_subtasks(&from, &to).unwrap();
+        assert_eq!(subtasks.len(), 1);
+        assert_eq!(subtasks[0].from_expr_indices, vec![0]);
+        assert_eq!(subtasks[0].to_expr_indices, vec![0, 1]);
+        assert_eq!(subtasks[0].transition_map[0], vec![0, 1]);
+    }
+
+    #[test]
+    fn test_merge_two_to_one() {
+        // Left: [0, 10), [10, 20)
+        let from = vec![
+            col("u")
+                .gt_eq(Value::Int64(0))
+                .and(col("u").lt(Value::Int64(10))),
+            col("u")
+                .gt_eq(Value::Int64(10))
+                .and(col("u").lt(Value::Int64(20))),
+        ];
+        // Right: [0, 40)
+        let to = vec![
+            col("u")
+                .gt_eq(Value::Int64(0))
+                .and(col("u").lt(Value::Int64(20))),
+        ];
+
+        let subtasks = create_subtasks(&from, &to).unwrap();
+        assert_eq!(subtasks.len(), 1);
+        assert_eq!(subtasks[0].from_expr_indices, vec![0, 1]);
+        assert_eq!(subtasks[0].to_expr_indices, vec![0]);
+        assert_eq!(subtasks[0].transition_map[0], vec![0]);
+        assert_eq!(subtasks[0].transition_map[1], vec![0]);
+    }
+
+    #[test]
+    fn test_create_subtasks_disconnected() {
+        // Left: A:[0,10), B:[20,30)
+        let from = vec![
+            col("x")
+                .gt_eq(Value::Int64(0))
+                .and(col("x").lt(Value::Int64(10))),
+            col("x")
+                .gt_eq(Value::Int64(20))
+                .and(col("x").lt(Value::Int64(30))),
+        ];
+        // Right: C:[5,15), D:[40,50)
+        let to = vec![
+            col("x")
+                .gt_eq(Value::Int64(5))
+                .and(col("x").lt(Value::Int64(15))),
+            col("x")
+                .gt_eq(Value::Int64(40))
+                .and(col("x").lt(Value::Int64(50))),
+        ];
+
+        let subtasks = create_subtasks(&from, &to).unwrap();
+
+        // Expect two components: {A,C} and {B} has no edges so filtered out
+        // Note: nodes with no edges are excluded by construction
+        assert_eq!(subtasks.len(), 1);
+        assert_eq!(subtasks[0].from_expr_indices, vec![0]);
+        assert_eq!(subtasks[0].to_expr_indices, vec![0]);
+        assert_eq!(subtasks[0].transition_map, vec![vec![0]]);
+    }
+
+    #[test]
+    fn test_create_subtasks_multi() {
+        // Left: [0,100), [100,200)
+        let from = vec![
+            col("u")
+                .gt_eq(Value::Int64(0))
+                .and(col("u").lt(Value::Int64(100))),
+            col("u")
+                .gt_eq(Value::Int64(100))
+                .and(col("u").lt(Value::Int64(200))),
+        ];
+        // Right: [0,50), [50,150), [150,250)
+        let to = vec![
+            col("u")
+                .gt_eq(Value::Int64(0))
+                .and(col("u").lt(Value::Int64(50))),
+            col("u")
+                .gt_eq(Value::Int64(50))
+                .and(col("u").lt(Value::Int64(150))),
+            col("u")
+                .gt_eq(Value::Int64(150))
+                .and(col("u").lt(Value::Int64(250))),
+        ];
+
+        let subtasks = create_subtasks(&from, &to).unwrap();
+        // All connected into a single component
+        assert_eq!(subtasks.len(), 1);
+        assert_eq!(subtasks[0].from_expr_indices, vec![0, 1]);
+        assert_eq!(subtasks[0].to_expr_indices, vec![0, 1, 2]);
+        // [0,100) -> [0,50), [50,150)
+        // [100,200) -> [50,150), [150,250)
+        assert_eq!(subtasks[0].transition_map[0], vec![0, 1]);
+        assert_eq!(subtasks[0].transition_map[1], vec![1, 2]);
+    }
+
+    #[test]
+    fn test_two_components() {
+        // Left: A:[0,10), B:[20,30)
+        let from = vec![
+            col("x")
+                .gt_eq(Value::Int64(0))
+                .and(col("x").lt(Value::Int64(10))),
+            col("x")
+                .gt_eq(Value::Int64(20))
+                .and(col("x").lt(Value::Int64(30))),
+        ];
+        // Right: C:[5,7), D:[22,28)
+        let to = vec![
+            col("x")
+                .gt_eq(Value::Int64(5))
+                .and(col("x").lt(Value::Int64(7))),
+            col("x")
+                .gt_eq(Value::Int64(22))
+                .and(col("x").lt(Value::Int64(28))),
+        ];
+        let mut subtasks = create_subtasks(&from, &to).unwrap();
+        // Deterministic order: left indices sorted, so components may appear in order of discovery.
+        assert_eq!(subtasks.len(), 2);
+        // Sort for stable assertion by smallest left index
+        subtasks.sort_by_key(|s| s.from_expr_indices[0]);
+        assert_eq!(subtasks[0].from_expr_indices, vec![0]);
+        assert_eq!(subtasks[0].to_expr_indices, vec![0]);
+        assert_eq!(subtasks[0].transition_map, vec![vec![0]]);
+        assert_eq!(subtasks[1].from_expr_indices, vec![1]);
+        assert_eq!(subtasks[1].to_expr_indices, vec![1]);
+        assert_eq!(subtasks[1].transition_map, vec![vec![1]]);
+    }
+
+    #[test]
+    fn test_bridge_single_component() {
+        // Left: [0,10), [10,20)
+        let from = vec![
+            col("u")
+                .gt_eq(Value::Int64(0))
+                .and(col("u").lt(Value::Int64(10))),
+            col("u")
+                .gt_eq(Value::Int64(10))
+                .and(col("u").lt(Value::Int64(20))),
+        ];
+        // Right: [5,15), [15,25)
+        let to = vec![
+            col("u")
+                .gt_eq(Value::Int64(5))
+                .and(col("u").lt(Value::Int64(15))),
+            col("u")
+                .gt_eq(Value::Int64(15))
+                .and(col("u").lt(Value::Int64(25))),
+        ];
+        let subtasks = create_subtasks(&from, &to).unwrap();
+        assert_eq!(subtasks.len(), 1);
+        assert_eq!(subtasks[0].from_expr_indices, vec![0, 1]);
+        assert_eq!(subtasks[0].to_expr_indices, vec![0, 1]);
+        assert_eq!(subtasks[0].transition_map[0], vec![0]);
+        assert_eq!(subtasks[0].transition_map[1], vec![0, 1]);
+    }
+
+    #[test]
+    fn test_all_isolated_no_subtasks() {
+        // No edges at all
+        let from = vec![col("k").lt(Value::Int64(10))];
+        let to = vec![col("k").gt_eq(Value::Int64(10))];
+        let subtasks = create_subtasks(&from, &to).unwrap();
+        assert!(subtasks.is_empty());
+    }
+}
diff --git a/src/pipeline/src/etl.rs b/src/pipeline/src/etl.rs
index 1c7336dc7b..2fe2a7ba53 100644
--- a/src/pipeline/src/etl.rs
+++ b/src/pipeline/src/etl.rs
@@ -312,7 +312,7 @@ impl Pipeline {
 
                 // Create pipeline context with the found timestamp
                 let def = crate::PipelineDefinition::GreptimeIdentityPipeline(Some(
-                    IdentityTimeIndex::Epoch(ts_name.to_string(), *time_unit, false),
+                    IdentityTimeIndex::Epoch(ts_name.clone(), *time_unit, false),
                 ));
                 let n_ctx =
                     PipelineContext::new(&def, pipeline_ctx.pipeline_param, pipeline_ctx.channel);
@@ -505,7 +505,7 @@ transform:
             .unwrap();
 
         assert_eq!(schema_info.schema.len(), result.0.values.len());
-        let test = vec![
+        let test = [
             (
                 ColumnDataType::String as i32,
                 Some(ValueData::StringValue("129.37.245.88".into())),
diff --git a/src/pipeline/src/etl/value.rs b/src/pipeline/src/etl/value.rs
index b69fc7af81..2f5560b456 100644
--- a/src/pipeline/src/etl/value.rs
+++ b/src/pipeline/src/etl/value.rs
@@ -176,7 +176,7 @@ pub fn yaml_to_vrl_value(v: &yaml_rust::Yaml) -> Result<VrlValue> {
                 .context(ValueParseFloatSnafu { ty: "float64", v })?;
             NotNan::new(f).map(VrlValue::Float).context(FloatIsNanSnafu)
         }
-        yaml_rust::Yaml::String(v) => Ok(VrlValue::Bytes(Bytes::from(v.to_string()))),
+        yaml_rust::Yaml::String(v) => Ok(VrlValue::Bytes(Bytes::from(v.clone()))),
         yaml_rust::Yaml::Array(arr) => {
             let mut values = vec![];
             for v in arr {
diff --git a/src/pipeline/src/manager/table.rs b/src/pipeline/src/manager/table.rs
index 649e00b3cb..ad9a8c4ac5 100644
--- a/src/pipeline/src/manager/table.rs
+++ b/src/pipeline/src/manager/table.rs
@@ -190,8 +190,8 @@ impl PipelineTable {
 
     fn query_ctx(table_info: &TableInfo) -> QueryContextRef {
         QueryContextBuilder::default()
-            .current_catalog(table_info.catalog_name.to_string())
-            .current_schema(table_info.schema_name.to_string())
+            .current_catalog(table_info.catalog_name.clone())
+            .current_schema(table_info.schema_name.clone())
             .build()
             .into()
     }
diff --git a/src/promql/src/extension_plan/histogram_fold.rs b/src/promql/src/extension_plan/histogram_fold.rs
index 0937142560..4742bf49d4 100644
--- a/src/promql/src/extension_plan/histogram_fold.rs
+++ b/src/promql/src/extension_plan/histogram_fold.rs
@@ -567,7 +567,7 @@ impl HistogramFoldStream {
             // "sample" normal columns
             for normal_index in &self.normal_indices {
                 let val = batch.column(*normal_index).get(cursor);
-                self.output_buffer[*normal_index].push_value_ref(val.as_value_ref());
+                self.output_buffer[*normal_index].push_value_ref(&val.as_value_ref());
             }
             // "fold" `le` and field columns
             let le_array = batch.column(self.le_column_index);
@@ -594,7 +594,7 @@ impl HistogramFoldStream {
             }
             // ignore invalid data
             let result = Self::evaluate_row(self.quantile, &bucket, &counters).unwrap_or(f64::NAN);
-            self.output_buffer[self.field_column_index].push_value_ref(ValueRef::from(result));
+            self.output_buffer[self.field_column_index].push_value_ref(&ValueRef::from(result));
             cursor += bucket_num;
             remaining_rows -= bucket_num;
             self.output_buffered_rows += 1;
diff --git a/src/promql/src/lib.rs b/src/promql/src/lib.rs
index 42dbdb23a9..2de1c6508e 100644
--- a/src/promql/src/lib.rs
+++ b/src/promql/src/lib.rs
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(let_chains)]
 #![feature(map_try_insert)]
 
 pub mod error;
diff --git a/src/query/src/datafusion.rs b/src/query/src/datafusion.rs
index 867cc30b54..ab27666c01 100644
--- a/src/query/src/datafusion.rs
+++ b/src/query/src/datafusion.rs
@@ -192,7 +192,7 @@ impl DatafusionQueryEngine {
             .timestamp_column()
             .map(|x| &x.name)
             .with_context(|| MissingTimestampColumnSnafu {
-                table_name: table_name.to_string(),
+                table_name: table_name.clone(),
             })?;
 
         let table_info = table.table_info();
diff --git a/src/query/src/datafusion/error.rs b/src/query/src/datafusion/error.rs
index c4f0575f76..c6952c6e4b 100644
--- a/src/query/src/datafusion/error.rs
+++ b/src/query/src/datafusion/error.rs
@@ -33,13 +33,6 @@ pub enum InnerError {
         location: Location,
     },
 
-    #[snafu(display("Fail to convert arrow schema"))]
-    ConvertSchema {
-        #[snafu(implicit)]
-        location: Location,
-        source: datatypes::error::Error,
-    },
-
     #[snafu(display("Failed to convert DataFusion's recordbatch stream"))]
     ConvertDfRecordBatchStream {
         #[snafu(implicit)]
@@ -55,7 +48,6 @@ impl ErrorExt for InnerError {
         match self {
             // TODO(yingwen): Further categorize datafusion error.
             Datafusion { .. } => StatusCode::EngineExecuteQuery,
-            ConvertSchema { .. } => StatusCode::Unexpected,
             ConvertDfRecordBatchStream { source, .. } => source.status_code(),
         }
     }
diff --git a/src/query/src/dist_plan/planner.rs b/src/query/src/dist_plan/planner.rs
index 4b8a42b84b..6c7eba6b1e 100644
--- a/src/query/src/dist_plan/planner.rs
+++ b/src/query/src/dist_plan/planner.rs
@@ -214,11 +214,8 @@ impl DistExtensionPlanner {
         let all_regions = table_info.region_ids();
 
         // Extract partition columns
-        let partition_columns: Vec<String> = table_info
-            .meta
-            .partition_column_names()
-            .map(|s| s.to_string())
-            .collect();
+        let partition_columns: Vec<String> =
+            table_info.meta.partition_column_names().cloned().collect();
         if partition_columns.is_empty() {
             return Ok(all_regions);
         }
diff --git a/src/query/src/dist_plan/region_pruner.rs b/src/query/src/dist_plan/region_pruner.rs
index 80a4a78998..3304bf23df 100644
--- a/src/query/src/dist_plan/region_pruner.rs
+++ b/src/query/src/dist_plan/region_pruner.rs
@@ -14,17 +14,14 @@
 
 //! [`ConstraintPruner`] prunes partition info based on given expressions.
 
-use std::cmp::Ordering;
-use std::ops::Bound;
-
-use GluonOp::*;
 use ahash::{HashMap, HashSet};
 use common_telemetry::debug;
 use datatypes::prelude::ConcreteDataType;
-use datatypes::value::{OrderedF64, OrderedFloat, Value};
-use partition::collider::{AtomicExpr, Collider, GluonOp, NucleonExpr};
+use datatypes::value::{OrderedFloat, Value};
+use partition::collider::{AtomicExpr, Collider};
 use partition::expr::{Operand, PartitionExpr};
 use partition::manager::PartitionInfo;
+use partition::overlap::atomic_exprs_overlap;
 use store_api::storage::RegionId;
 
 use crate::error::Result;
@@ -109,13 +106,9 @@ impl ConstraintPruner {
     }
 
     fn atomic_sets_overlap(query_atomics: &[&AtomicExpr], partition_atomic: &AtomicExpr) -> bool {
-        for query_atomic in query_atomics {
-            if Self::atomic_constraint_satisfied(query_atomic, partition_atomic) {
-                return true;
-            }
-        }
-
-        false
+        query_atomics
+            .iter()
+            .any(|qa| atomic_exprs_overlap(qa, partition_atomic))
     }
 
     fn normalize_datatype(
@@ -213,196 +206,8 @@ impl ConstraintPruner {
             _ => false,
         }
     }
-
-    /// Check if a single atomic constraint can be satisfied
-    fn atomic_constraint_satisfied(
-        query_atomic: &AtomicExpr,
-        partition_atomic: &AtomicExpr,
-    ) -> bool {
-        let mut query_index = 0;
-        let mut partition_index = 0;
-
-        while query_index < query_atomic.nucleons.len()
-            && partition_index < partition_atomic.nucleons.len()
-        {
-            let query_col = query_atomic.nucleons[query_index].column();
-            let partition_col = partition_atomic.nucleons[partition_index].column();
-
-            match query_col.cmp(partition_col) {
-                Ordering::Equal => {
-                    let mut query_index_for_next_col = query_index;
-                    let mut partition_index_for_next_col = partition_index;
-
-                    while query_index_for_next_col < query_atomic.nucleons.len()
-                        && query_atomic.nucleons[query_index_for_next_col].column() == query_col
-                    {
-                        query_index_for_next_col += 1;
-                    }
-                    while partition_index_for_next_col < partition_atomic.nucleons.len()
-                        && partition_atomic.nucleons[partition_index_for_next_col].column()
-                            == partition_col
-                    {
-                        partition_index_for_next_col += 1;
-                    }
-
-                    let query_range = Self::nucleons_to_range(
-                        &query_atomic.nucleons[query_index..query_index_for_next_col],
-                    );
-                    let partition_range = Self::nucleons_to_range(
-                        &partition_atomic.nucleons[partition_index..partition_index_for_next_col],
-                    );
-
-                    debug!("Comparing two ranges, {query_range:?} and {partition_range:?}");
-
-                    query_index = query_index_for_next_col;
-                    partition_index = partition_index_for_next_col;
-
-                    if !query_range.overlaps_with(&partition_range) {
-                        return false;
-                    }
-                }
-                Ordering::Less => {
-                    // Query column comes before partition column - skip query column
-                    while query_index < query_atomic.nucleons.len()
-                        && query_atomic.nucleons[query_index].column() == query_col
-                    {
-                        query_index += 1;
-                    }
-                }
-                Ordering::Greater => {
-                    // Partition column comes before query column - skip partition column
-                    while partition_index < partition_atomic.nucleons.len()
-                        && partition_atomic.nucleons[partition_index].column() == partition_col
-                    {
-                        partition_index += 1;
-                    }
-                }
-            }
-        }
-
-        true
-    }
-
-    /// Convert a slice of nucleons (all for the same column) into a ValueRange
-    fn nucleons_to_range(nucleons: &[NucleonExpr]) -> ValueRange {
-        let mut range = ValueRange::new();
-
-        for nucleon in nucleons {
-            let value = nucleon.value();
-            match nucleon.op() {
-                Eq => {
-                    range.lower = Bound::Included(value);
-                    range.upper = Bound::Included(value);
-                    break; // exact value, most restrictive
-                }
-                Lt => {
-                    // upper < value
-                    range.update_upper(Bound::Excluded(value));
-                }
-                LtEq => {
-                    range.update_upper(Bound::Included(value));
-                }
-                Gt => {
-                    range.update_lower(Bound::Excluded(value));
-                }
-                GtEq => {
-                    range.update_lower(Bound::Included(value));
-                }
-                NotEq => {
-                    // handled as two separate atomic exprs elsewhere
-                    continue;
-                }
-            }
-        }
-
-        range
-    }
-}
-
-/// Represents a value range derived from a group of nucleons for the same column
-#[derive(Debug, Clone)]
-struct ValueRange {
-    // lower and upper bounds using standard library Bound semantics
-    lower: Bound<OrderedF64>,
-    upper: Bound<OrderedF64>,
-}
-
-impl ValueRange {
-    fn new() -> Self {
-        Self {
-            lower: Bound::Unbounded,
-            upper: Bound::Unbounded,
-        }
-    }
-
-    // Update lower bound choosing the more restrictive one
-    fn update_lower(&mut self, new_lower: Bound<OrderedF64>) {
-        match (&self.lower, &new_lower) {
-            (Bound::Unbounded, _) => self.lower = new_lower,
-            (_, Bound::Unbounded) => { /* keep existing */ }
-            (Bound::Included(cur), Bound::Included(new))
-            | (Bound::Excluded(cur), Bound::Included(new))
-            | (Bound::Included(cur), Bound::Excluded(new))
-            | (Bound::Excluded(cur), Bound::Excluded(new)) => {
-                if new > cur {
-                    self.lower = new_lower;
-                } else if new == cur {
-                    // prefer Excluded over Included for the same value (more restrictive)
-                    if matches!(new_lower, Bound::Excluded(_))
-                        && matches!(self.lower, Bound::Included(_))
-                    {
-                        self.lower = new_lower;
-                    }
-                }
-            }
-        }
-    }
-
-    // Update upper bound choosing the more restrictive one
-    fn update_upper(&mut self, new_upper: Bound<OrderedF64>) {
-        match (&self.upper, &new_upper) {
-            (Bound::Unbounded, _) => self.upper = new_upper,
-            (_, Bound::Unbounded) => { /* keep existing */ }
-            (Bound::Included(cur), Bound::Included(new))
-            | (Bound::Excluded(cur), Bound::Included(new))
-            | (Bound::Included(cur), Bound::Excluded(new))
-            | (Bound::Excluded(cur), Bound::Excluded(new)) => {
-                if new < cur {
-                    self.upper = new_upper;
-                } else if new == cur {
-                    // prefer Excluded over Included for the same value (more restrictive)
-                    if matches!(new_upper, Bound::Excluded(_))
-                        && matches!(self.upper, Bound::Included(_))
-                    {
-                        self.upper = new_upper;
-                    }
-                }
-            }
-        }
-    }
-
-    /// Check if this range overlaps with another range
-    fn overlaps_with(&self, other: &ValueRange) -> bool {
-        fn no_overlap(upper: &Bound<OrderedF64>, lower: &Bound<OrderedF64>) -> bool {
-            match (upper, lower) {
-                (Bound::Unbounded, _) | (_, Bound::Unbounded) => false,
-                // u], [l
-                (Bound::Included(u), Bound::Included(l)) => u < l,
-                // u], (l
-                (Bound::Included(u), Bound::Excluded(l))
-                // u), [l
-                | (Bound::Excluded(u), Bound::Included(l))
-                // u), (l
-                | (Bound::Excluded(u), Bound::Excluded(l)) => u <= l,
-            }
-        }
-
-        if no_overlap(&self.upper, &other.lower) || no_overlap(&other.upper, &self.lower) {
-            return false;
-        }
-        true
-    }
 }
+// Value range and atomic overlap logic is now refactored into `partition::diff`.
 
 #[cfg(test)]
 mod tests {
diff --git a/src/query/src/lib.rs b/src/query/src/lib.rs
index afe2a0209d..0c6ccaa41f 100644
--- a/src/query/src/lib.rs
+++ b/src/query/src/lib.rs
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(let_chains)]
 #![feature(int_roundings)]
 #![feature(try_blocks)]
 #![feature(stmt_expr_attributes)]
diff --git a/src/query/src/log_query/planner.rs b/src/query/src/log_query/planner.rs
index 133bebb23c..b90de4d48a 100644
--- a/src/query/src/log_query/planner.rs
+++ b/src/query/src/log_query/planner.rs
@@ -327,8 +327,8 @@ impl LogQueryPlanner {
                     .session_state
                     .aggregate_functions()
                     .get(fn_name)
-                    .context(UnknownAggregateFunctionSnafu {
-                        name: fn_name.to_string(),
+                    .with_context(|| UnknownAggregateFunctionSnafu {
+                        name: fn_name.clone(),
                     })?;
                 let args = args
                     .iter()
@@ -675,7 +675,7 @@ mod tests {
                 .build()
                 .unwrap();
             let table_info = TableInfoBuilder::default()
-                .name(table_name.to_string())
+                .name(table_name.clone())
                 .meta(table_meta)
                 .build()
                 .unwrap();
@@ -684,8 +684,8 @@ mod tests {
             catalog_list
                 .register_table_sync(RegisterTableRequest {
                     catalog: DEFAULT_CATALOG_NAME.to_string(),
-                    schema: schema_name.to_string(),
-                    table_name: table_name.to_string(),
+                    schema: schema_name.clone(),
+                    table_name: table_name.clone(),
                     table_id: 1024,
                     table,
                 })
diff --git a/src/query/src/optimizer/constant_term.rs b/src/query/src/optimizer/constant_term.rs
index 2b36328231..f91ea55d3d 100644
--- a/src/query/src/optimizer/constant_term.rs
+++ b/src/query/src/optimizer/constant_term.rs
@@ -192,7 +192,7 @@ impl PhysicalOptimizerRule for MatchesConstantTermOptimizer {
 
                                 let expr = PreCompiledMatchesTermExpr {
                                     text: args[0].clone(),
-                                    term: term.to_string(),
+                                    term: term.clone(),
                                     finder,
                                     probes,
                                 };
diff --git a/src/query/src/parser.rs b/src/query/src/parser.rs
index 826ddfaa50..335045f3ef 100644
--- a/src/query/src/parser.rs
+++ b/src/query/src/parser.rs
@@ -46,7 +46,8 @@ pub const ANALYZE_VERBOSE_NODE_NAME: &str = "ANALYZE VERBOSE";
 #[derive(Debug, Clone)]
 pub enum QueryStatement {
     Sql(Statement),
-    Promql(EvalStmt),
+    // The optional String is the alias name
+    Promql(EvalStmt, Option<String>),
 }
 
 impl QueryStatement {
@@ -56,19 +57,22 @@ impl QueryStatement {
                 operation: "sql post process",
             }
             .fail(),
-            QueryStatement::Promql(eval_stmt) => {
+            QueryStatement::Promql(eval_stmt, alias) => {
                 let node_name = match params.get("name") {
                     Some(name) => name.as_str(),
                     None => "",
                 };
                 let extension_node = Self::create_extension_node(node_name, &eval_stmt.expr);
-                Ok(QueryStatement::Promql(EvalStmt {
-                    expr: Extension(extension_node.unwrap()),
-                    start: eval_stmt.start,
-                    end: eval_stmt.end,
-                    interval: eval_stmt.interval,
-                    lookback_delta: eval_stmt.lookback_delta,
-                }))
+                Ok(QueryStatement::Promql(
+                    EvalStmt {
+                        expr: Extension(extension_node.unwrap()),
+                        start: eval_stmt.start,
+                        end: eval_stmt.end,
+                        interval: eval_stmt.interval,
+                        lookback_delta: eval_stmt.lookback_delta,
+                    },
+                    alias.clone(),
+                ))
             }
         }
     }
@@ -99,6 +103,7 @@ pub struct PromQuery {
     pub end: String,
     pub step: String,
     pub lookback: String,
+    pub alias: Option<String>,
 }
 
 impl Default for PromQuery {
@@ -109,6 +114,7 @@ impl Default for PromQuery {
             end: String::from("0"),
             step: String::from("5m"),
             lookback: String::from(DEFAULT_LOOKBACK_STRING),
+            alias: None,
         }
     }
 }
@@ -185,7 +191,7 @@ impl QueryLanguageParser {
             lookback_delta,
         };
 
-        Ok(QueryStatement::Promql(eval_stmt))
+        Ok(QueryStatement::Promql(eval_stmt, query.alias.clone()))
     }
 
     pub fn parse_promql_timestamp(timestamp: &str) -> Result<SystemTime> {
@@ -341,6 +347,7 @@ mod test {
             end: "2023-02-13T17:14:00Z".to_string(),
             step: "1d".to_string(),
             lookback: "5m".to_string(),
+            alias: Some("my_query".to_string()),
         };
 
         #[cfg(not(windows))]
@@ -355,7 +362,7 @@ mod test {
                 end: SystemTime { tv_sec: 1676308440, tv_nsec: 0 }, \
                 interval: 86400s, \
                 lookback_delta: 300s \
-            })",
+            }, Some(\"my_query\"))",
         );
 
         // Windows has different debug output for SystemTime.
@@ -371,7 +378,7 @@ mod test {
                 end: SystemTime { intervals: 133207820400000000 }, \
                 interval: 86400s, \
                 lookback_delta: 300s \
-            })",
+            }, Some(\"my_query\"))",
         );
 
         let result = QueryLanguageParser::parse_promql(&promql, &QueryContext::arc()).unwrap();
diff --git a/src/query/src/planner.rs b/src/query/src/planner.rs
index b3aaad0a38..e59be28ceb 100644
--- a/src/query/src/planner.rs
+++ b/src/query/src/planner.rs
@@ -20,10 +20,14 @@ use async_trait::async_trait;
 use catalog::table_source::DfTableSourceProvider;
 use common_error::ext::BoxedError;
 use common_telemetry::tracing;
-use datafusion::common::DFSchema;
+use datafusion::common::{DFSchema, plan_err};
 use datafusion::execution::context::SessionState;
 use datafusion::sql::planner::PlannerContext;
-use datafusion_expr::{Expr as DfExpr, LogicalPlan, LogicalPlanBuilder, col};
+use datafusion_common::ToDFSchema;
+use datafusion_expr::{
+    Analyze, Explain, ExplainFormat, Expr as DfExpr, LogicalPlan, LogicalPlanBuilder, PlanType,
+    ToStringifiedPlan, col,
+};
 use datafusion_sql::planner::{ParserOptions, SqlToRel};
 use log_query::LogQuery;
 use promql_parser::parser::EvalStmt;
@@ -31,6 +35,7 @@ use session::context::QueryContextRef;
 use snafu::{ResultExt, ensure};
 use sql::CteContent;
 use sql::ast::Expr as SqlExpr;
+use sql::statements::explain::ExplainStatement;
 use sql::statements::query::Query;
 use sql::statements::statement::Statement;
 use sql::statements::tql::Tql;
@@ -75,12 +80,69 @@ impl DfLogicalPlanner {
         }
     }
 
+    /// Basically the same with `explain_to_plan` in DataFusion, but adapted to Greptime's
+    /// `plan_sql` to support Greptime Statements.
+    async fn explain_to_plan(
+        &self,
+        explain: &ExplainStatement,
+        query_ctx: QueryContextRef,
+    ) -> Result<LogicalPlan> {
+        let plan = self.plan_sql(&explain.statement, query_ctx).await?;
+        if matches!(plan, LogicalPlan::Explain(_)) {
+            return plan_err!("Nested EXPLAINs are not supported").context(PlanSqlSnafu);
+        }
+
+        let verbose = explain.verbose;
+        let analyze = explain.analyze;
+        let format = explain.format.map(|f| f.to_string());
+
+        let plan = Arc::new(plan);
+        let schema = LogicalPlan::explain_schema();
+        let schema = ToDFSchema::to_dfschema_ref(schema)?;
+
+        if verbose && format.is_some() {
+            return plan_err!("EXPLAIN VERBOSE with FORMAT is not supported").context(PlanSqlSnafu);
+        }
+
+        if analyze {
+            // notice format is already set in query context, so can be ignore here
+            Ok(LogicalPlan::Analyze(Analyze {
+                verbose,
+                input: plan,
+                schema,
+            }))
+        } else {
+            let stringified_plans = vec![plan.to_stringified(PlanType::InitialLogicalPlan)];
+
+            // default to configuration value
+            let options = self.session_state.config().options();
+            let format = format.as_ref().unwrap_or(&options.explain.format);
+
+            let format: ExplainFormat = format.parse()?;
+
+            Ok(LogicalPlan::Explain(Explain {
+                verbose,
+                explain_format: format,
+                plan,
+                stringified_plans,
+                schema,
+                logical_optimization_succeeded: false,
+            }))
+        }
+    }
+
     #[tracing::instrument(skip_all)]
+    #[async_recursion::async_recursion]
     async fn plan_sql(&self, stmt: &Statement, query_ctx: QueryContextRef) -> Result<LogicalPlan> {
         let mut planner_context = PlannerContext::new();
         let mut stmt = Cow::Borrowed(stmt);
         let mut is_tql_cte = false;
 
+        // handle explain before normal processing so we can explain Greptime Statements
+        if let Statement::Explain(explain) = stmt.as_ref() {
+            return self.explain_to_plan(explain, query_ctx).await;
+        }
+
         // Check for hybrid CTEs before normal processing
         if self.has_hybrid_ctes(stmt.as_ref()) {
             let stmt_owned = stmt.into_owned();
@@ -101,10 +163,13 @@ impl DfLogicalPlanner {
 
         // TODO(LFC): Remove this when Datafusion supports **both** the syntax and implementation of "explain with format".
         if let datafusion::sql::parser::Statement::Statement(
-            box datafusion::sql::sqlparser::ast::Statement::Explain { format, .. },
+            box datafusion::sql::sqlparser::ast::Statement::Explain { .. },
         ) = &mut df_stmt
         {
-            format.take();
+            UnimplementedSnafu {
+                operation: "EXPLAIN with FORMAT using raw datafusion planner",
+            }
+            .fail()?;
         }
 
         let table_provider = DfTableSourceProvider::new(
@@ -200,7 +265,12 @@ impl DfLogicalPlanner {
     }
 
     #[tracing::instrument(skip_all)]
-    async fn plan_pql(&self, stmt: &EvalStmt, query_ctx: QueryContextRef) -> Result<LogicalPlan> {
+    async fn plan_pql(
+        &self,
+        stmt: &EvalStmt,
+        alias: Option<String>,
+        query_ctx: QueryContextRef,
+    ) -> Result<LogicalPlan> {
         let plan_decoder = Arc::new(DefaultPlanDecoder::new(
             self.session_state.clone(),
             &query_ctx,
@@ -215,7 +285,7 @@ impl DfLogicalPlanner {
                 .sql_parser
                 .enable_ident_normalization,
         );
-        PromPlanner::stmt_to_plan(table_provider, stmt, &self.engine_state)
+        PromPlanner::stmt_to_plan_with_alias(table_provider, stmt, alias, &self.engine_state)
             .await
             .map_err(BoxedError::new)
             .context(QueryPlanSnafu)
@@ -262,7 +332,7 @@ impl DfLogicalPlanner {
                                 cte_name: cte.name.value.clone(),
                                 original: schema_fields
                                     .iter()
-                                    .map(|field| field.name().to_string())
+                                    .map(|field| field.name().clone())
                                     .collect::<Vec<_>>(),
                                 expected: cte
                                     .columns
@@ -323,8 +393,10 @@ impl DfLogicalPlanner {
                         .lookback
                         .clone()
                         .unwrap_or_else(|| DEFAULT_LOOKBACK_STRING.to_string()),
+                    alias: eval.alias.clone(),
                 };
                 let stmt = QueryLanguageParser::parse_promql(&prom_query, &query_ctx)?;
+
                 self.plan(&stmt, query_ctx).await
             }
             Tql::Explain(_) => UnimplementedSnafu {
@@ -345,7 +417,9 @@ impl LogicalPlanner for DfLogicalPlanner {
     async fn plan(&self, stmt: &QueryStatement, query_ctx: QueryContextRef) -> Result<LogicalPlan> {
         match stmt {
             QueryStatement::Sql(stmt) => self.plan_sql(stmt, query_ctx).await,
-            QueryStatement::Promql(stmt) => self.plan_pql(stmt, query_ctx).await,
+            QueryStatement::Promql(stmt, alias) => {
+                self.plan_pql(stmt, alias.clone(), query_ctx).await
+            }
         }
     }
 
diff --git a/src/query/src/promql/planner.rs b/src/query/src/promql/planner.rs
index 856f97ac5f..b65cddc2e2 100644
--- a/src/query/src/promql/planner.rs
+++ b/src/query/src/promql/planner.rs
@@ -196,9 +196,10 @@ pub fn normalize_matcher(mut matcher: Matcher) -> Matcher {
 }
 
 impl PromPlanner {
-    pub async fn stmt_to_plan(
+    pub async fn stmt_to_plan_with_alias(
         table_provider: DfTableSourceProvider,
         stmt: &EvalStmt,
+        alias: Option<String>,
         query_engine_state: &QueryEngineState,
     ) -> Result<LogicalPlan> {
         let mut planner = Self {
@@ -206,9 +207,25 @@ impl PromPlanner {
             ctx: PromPlannerContext::from_eval_stmt(stmt),
         };
 
-        planner
+        let plan = planner
             .prom_expr_to_plan(&stmt.expr, query_engine_state)
-            .await
+            .await?;
+
+        // Apply alias if provided
+        if let Some(alias_name) = alias {
+            planner.apply_alias_projection(plan, alias_name)
+        } else {
+            Ok(plan)
+        }
+    }
+
+    #[cfg(test)]
+    async fn stmt_to_plan(
+        table_provider: DfTableSourceProvider,
+        stmt: &EvalStmt,
+        query_engine_state: &QueryEngineState,
+    ) -> Result<LogicalPlan> {
+        Self::stmt_to_plan_with_alias(table_provider, stmt, None, query_engine_state).await
     }
 
     pub async fn prom_expr_to_plan(
@@ -702,7 +719,7 @@ impl PromPlanner {
         self.ctx.time_index_column = Some(DEFAULT_TIME_INDEX_COLUMN.to_string());
         self.ctx.field_columns = vec![DEFAULT_FIELD_COLUMN.to_string()];
         self.ctx.reset_table_name_and_schema();
-        let literal_expr = df_prelude::lit(val.to_string());
+        let literal_expr = df_prelude::lit(val.clone());
 
         let plan = LogicalPlan::Extension(Extension {
             node: Arc::new(
@@ -1032,7 +1049,7 @@ impl PromPlanner {
                 ensure!(
                     matcher.op == MatchOp::Equal,
                     UnsupportedMatcherOpSnafu {
-                        matcher: matcher.name.to_string(),
+                        matcher: matcher.name.clone(),
                         matcher_op: matcher.op.to_string(),
                     }
                 );
@@ -3144,7 +3161,7 @@ impl PromPlanner {
         // step 1: align schema using project, fill non-exist columns with null
         let left_proj_exprs = all_columns.iter().map(|col| {
             if tags_not_in_left.contains(col) {
-                DfExpr::Literal(ScalarValue::Utf8(None), None).alias(col.to_string())
+                DfExpr::Literal(ScalarValue::Utf8(None), None).alias(col.clone())
             } else {
                 DfExpr::Column(Column::new(None::<String>, col))
             }
@@ -3161,8 +3178,8 @@ impl PromPlanner {
             .iter()
             .find(|(_, f)| f.name() == right_field_col)
             .map(|(q, _)| q)
-            .context(ColumnNotFoundSnafu {
-                col: right_field_col.to_string(),
+            .with_context(|| ColumnNotFoundSnafu {
+                col: right_field_col.clone(),
             })?
             .cloned();
 
@@ -3176,7 +3193,7 @@ impl PromPlanner {
                     right_field_col,
                 ))
             } else if tags_not_in_right.contains(col) {
-                DfExpr::Literal(ScalarValue::Utf8(None), None).alias(col.to_string())
+                DfExpr::Literal(ScalarValue::Utf8(None), None).alias(col.clone())
             } else {
                 DfExpr::Column(Column::new(None::<String>, col))
             }
@@ -3234,7 +3251,7 @@ impl PromPlanner {
         // step 4: update context
         self.ctx.time_index_column = Some(left_time_index_column);
         self.ctx.tag_columns = all_tags.into_iter().collect();
-        self.ctx.field_columns = vec![left_field_col.to_string()];
+        self.ctx.field_columns = vec![left_field_col.clone()];
 
         Ok(result)
     }
@@ -3340,6 +3357,35 @@ impl PromPlanner {
         });
         Ok(fn_expr)
     }
+
+    /// Apply an alias to the query result by adding a projection with the alias name
+    fn apply_alias_projection(
+        &mut self,
+        plan: LogicalPlan,
+        alias_name: String,
+    ) -> Result<LogicalPlan> {
+        let fields_expr = self.create_field_column_exprs()?;
+
+        // TODO(dennis): how to support multi-value aliasing?
+        ensure!(
+            fields_expr.len() == 1,
+            UnsupportedExprSnafu {
+                name: "alias on multi-value result"
+            }
+        );
+
+        let project_fields = fields_expr
+            .into_iter()
+            .map(|expr| expr.alias(&alias_name))
+            .chain(self.create_tag_column_exprs()?)
+            .chain(Some(self.create_time_index_column_expr()?));
+
+        LogicalPlanBuilder::from(plan)
+            .project(project_fields)
+            .context(DataFusionPlanningSnafu)?
+            .build()
+            .context(DataFusionPlanningSnafu)
+    }
 }
 
 #[derive(Default, Debug)]
@@ -3451,7 +3497,7 @@ mod test {
                 .build()
                 .unwrap();
             let table_info = TableInfoBuilder::default()
-                .name(table_name.to_string())
+                .name(table_name.clone())
                 .meta(table_meta)
                 .build()
                 .unwrap();
@@ -3461,8 +3507,8 @@ mod test {
                 catalog_list
                     .register_table_sync(RegisterTableRequest {
                         catalog: DEFAULT_CATALOG_NAME.to_string(),
-                        schema: schema_name.to_string(),
-                        table_name: table_name.to_string(),
+                        schema: schema_name.clone(),
+                        table_name: table_name.clone(),
                         table_id: 1024,
                         table,
                     })
@@ -3515,7 +3561,7 @@ mod test {
                 .build()
                 .unwrap();
             let table_info = TableInfoBuilder::default()
-                .name(table_name.to_string())
+                .name(table_name.clone())
                 .meta(table_meta)
                 .build()
                 .unwrap();
@@ -3525,8 +3571,8 @@ mod test {
                 catalog_list
                     .register_table_sync(RegisterTableRequest {
                         catalog: DEFAULT_CATALOG_NAME.to_string(),
-                        schema: schema_name.to_string(),
-                        table_name: table_name.to_string(),
+                        schema: schema_name.clone(),
+                        table_name: table_name.clone(),
                         table_id: 1024,
                         table,
                     })
@@ -4927,6 +4973,59 @@ Filter: up.field_0 IS NOT NULL [timestamp:Timestamp(Millisecond, None), field_0:
         assert_eq!(plan.display_indent_schema().to_string(), expected);
     }
 
+    #[tokio::test]
+    async fn test_value_alias() {
+        let mut eval_stmt = EvalStmt {
+            expr: PromExpr::NumberLiteral(NumberLiteral { val: 1.0 }),
+            start: UNIX_EPOCH,
+            end: UNIX_EPOCH
+                .checked_add(Duration::from_secs(100_000))
+                .unwrap(),
+            interval: Duration::from_secs(5),
+            lookback_delta: Duration::from_secs(1),
+        };
+        let case = r#"count_values('series', prometheus_tsdb_head_series{ip=~"(10.0.160.237:8080|10.0.160.237:9090)"}) by (ip)"#;
+
+        let prom_expr = parser::parse(case).unwrap();
+        eval_stmt.expr = prom_expr;
+        let table_provider = build_test_table_provider_with_fields(
+            &[
+                (
+                    DEFAULT_SCHEMA_NAME.to_string(),
+                    "prometheus_tsdb_head_series".to_string(),
+                ),
+                (
+                    DEFAULT_SCHEMA_NAME.to_string(),
+                    "http_server_requests_seconds_count".to_string(),
+                ),
+            ],
+            &["ip"],
+        )
+        .await;
+
+        let alias = Some("my_series".to_string());
+        let plan = PromPlanner::stmt_to_plan_with_alias(
+            table_provider,
+            &eval_stmt,
+            alias,
+            &build_query_engine_state(),
+        )
+        .await
+        .unwrap();
+        let expected = r#"
+Projection: count(prometheus_tsdb_head_series.greptime_value) AS my_series, prometheus_tsdb_head_series.ip, prometheus_tsdb_head_series.greptime_timestamp [my_series:Int64, ip:Utf8, greptime_timestamp:Timestamp(Millisecond, None)]
+  Projection: count(prometheus_tsdb_head_series.greptime_value), prometheus_tsdb_head_series.ip, prometheus_tsdb_head_series.greptime_timestamp, series [count(prometheus_tsdb_head_series.greptime_value):Int64, ip:Utf8, greptime_timestamp:Timestamp(Millisecond, None), series:Float64;N]
+    Sort: prometheus_tsdb_head_series.ip ASC NULLS LAST, prometheus_tsdb_head_series.greptime_timestamp ASC NULLS LAST, prometheus_tsdb_head_series.greptime_value ASC NULLS LAST [count(prometheus_tsdb_head_series.greptime_value):Int64, ip:Utf8, greptime_timestamp:Timestamp(Millisecond, None), series:Float64;N, greptime_value:Float64;N]
+      Projection: count(prometheus_tsdb_head_series.greptime_value), prometheus_tsdb_head_series.ip, prometheus_tsdb_head_series.greptime_timestamp, prometheus_tsdb_head_series.greptime_value AS series, prometheus_tsdb_head_series.greptime_value [count(prometheus_tsdb_head_series.greptime_value):Int64, ip:Utf8, greptime_timestamp:Timestamp(Millisecond, None), series:Float64;N, greptime_value:Float64;N]
+        Aggregate: groupBy=[[prometheus_tsdb_head_series.ip, prometheus_tsdb_head_series.greptime_timestamp, prometheus_tsdb_head_series.greptime_value]], aggr=[[count(prometheus_tsdb_head_series.greptime_value)]] [ip:Utf8, greptime_timestamp:Timestamp(Millisecond, None), greptime_value:Float64;N, count(prometheus_tsdb_head_series.greptime_value):Int64]
+          PromInstantManipulate: range=[0..100000000], lookback=[1000], interval=[5000], time index=[greptime_timestamp] [ip:Utf8, greptime_timestamp:Timestamp(Millisecond, None), greptime_value:Float64;N]
+            PromSeriesDivide: tags=["ip"] [ip:Utf8, greptime_timestamp:Timestamp(Millisecond, None), greptime_value:Float64;N]
+              Sort: prometheus_tsdb_head_series.ip ASC NULLS FIRST, prometheus_tsdb_head_series.greptime_timestamp ASC NULLS FIRST [ip:Utf8, greptime_timestamp:Timestamp(Millisecond, None), greptime_value:Float64;N]
+                Filter: prometheus_tsdb_head_series.ip ~ Utf8("^(?:(10.0.160.237:8080|10.0.160.237:9090))$") AND prometheus_tsdb_head_series.greptime_timestamp >= TimestampMillisecond(-1000, None) AND prometheus_tsdb_head_series.greptime_timestamp <= TimestampMillisecond(100001000, None) [ip:Utf8, greptime_timestamp:Timestamp(Millisecond, None), greptime_value:Float64;N]
+                  TableScan: prometheus_tsdb_head_series [ip:Utf8, greptime_timestamp:Timestamp(Millisecond, None), greptime_value:Float64;N]"#;
+        assert_eq!(format!("\n{}", plan.display_indent_schema()), expected);
+    }
+
     #[tokio::test]
     async fn test_quantile_expr() {
         let mut eval_stmt = EvalStmt {
diff --git a/src/query/src/range_select/plan_rewrite.rs b/src/query/src/range_select/plan_rewrite.rs
index ad5d2d3d5b..14eba9bcba 100644
--- a/src/query/src/range_select/plan_rewrite.rs
+++ b/src/query/src/range_select/plan_rewrite.rs
@@ -106,7 +106,7 @@ fn parse_str_expr(args: &[Expr], i: usize) -> DFResult<&str> {
 
 fn parse_expr_to_string(args: &[Expr], i: usize) -> DFResult<String> {
     match args.get(i) {
-        Some(Expr::Literal(ScalarValue::Utf8(Some(str)), _)) => Ok(str.to_string()),
+        Some(Expr::Literal(ScalarValue::Utf8(Some(str)), _)) => Ok(str.clone()),
         Some(expr) => Ok(expr.schema_name().to_string()),
         None => Err(dispose_parse_error(None)),
     }
diff --git a/src/query/src/sql/show_create_table.rs b/src/query/src/sql/show_create_table.rs
index 4981edeef7..5466bb91e6 100644
--- a/src/query/src/sql/show_create_table.rs
+++ b/src/query/src/sql/show_create_table.rs
@@ -62,7 +62,7 @@ fn create_sql_options(table_meta: &TableMeta, schema_options: Option<SchemaOptio
         .iter()
         .filter(|(k, _)| k != &FILE_TABLE_META_KEY)
     {
-        options.insert(k.to_string(), v.to_string());
+        options.insert(k.clone(), v.clone());
     }
     options
 }
@@ -99,7 +99,7 @@ fn create_column(column_schema: &ColumnSchema, quote_style: char) -> Result<Colu
     }
 
     if let Some(c) = column_schema.metadata().get(COMMENT_KEY) {
-        options.push(column_option_def(ColumnOption::Comment(c.to_string())));
+        options.push(column_option_def(ColumnOption::Comment(c.clone())));
     }
 
     if let Some(opt) = column_schema
diff --git a/src/servers/src/elasticsearch.rs b/src/servers/src/elasticsearch.rs
index 3627f19f19..2a99309dfa 100644
--- a/src/servers/src/elasticsearch.rs
+++ b/src/servers/src/elasticsearch.rs
@@ -572,8 +572,8 @@ mod tests {
 
         for (input, index, msg_field, expected) in test_cases {
             let requests = parse_bulk_request(input, &index, &msg_field);
-            if expected.is_ok() {
-                assert_eq!(requests.unwrap(), expected.unwrap());
+            if let Ok(expected) = expected {
+                assert_eq!(requests.unwrap(), expected);
             } else {
                 assert!(requests.is_err());
             }
diff --git a/src/servers/src/grpc/prom_query_gateway.rs b/src/servers/src/grpc/prom_query_gateway.rs
index 755c741ace..35e4c0f712 100644
--- a/src/servers/src/grpc/prom_query_gateway.rs
+++ b/src/servers/src/grpc/prom_query_gateway.rs
@@ -59,6 +59,7 @@ impl PrometheusGateway for PrometheusGatewayService {
                     end: range_query.end,
                     step: range_query.step,
                     lookback: range_query.lookback,
+                    alias: None,
                 }
             }
             Promql::InstantQuery(instant_query) => {
@@ -73,6 +74,7 @@ impl PrometheusGateway for PrometheusGatewayService {
                     end: time,
                     step: String::from("1s"),
                     lookback: instant_query.lookback,
+                    alias: None,
                 }
             }
         };
diff --git a/src/servers/src/http/authorize.rs b/src/servers/src/http/authorize.rs
index 9c0af39e44..3b73482961 100644
--- a/src/servers/src/http/authorize.rs
+++ b/src/servers/src/http/authorize.rs
@@ -247,7 +247,7 @@ impl From<AuthScheme> for api::v1::auth_header::AuthScheme {
             AuthScheme::Basic(username, password) => {
                 api::v1::auth_header::AuthScheme::Basic(Basic {
                     username,
-                    password: password.expose_secret().to_string(),
+                    password: password.expose_secret().clone(),
                 })
             }
         }
diff --git a/src/servers/src/http/event.rs b/src/servers/src/http/event.rs
index 0341232b1f..24bb844dc7 100644
--- a/src/servers/src/http/event.rs
+++ b/src/servers/src/http/event.rs
@@ -496,7 +496,7 @@ async fn dryrun_pipeline_inner(
                                 let mut map = Map::new();
                                 let value_ref = pb_value_to_value_ref(
                                     &v,
-                                    &result_schema[idx].datatype_extension,
+                                    result_schema[idx].datatype_extension.as_ref(),
                                 );
                                 let greptime_value: datatypes::value::Value = value_ref.into();
                                 let serde_json_value =
diff --git a/src/servers/src/http/handler.rs b/src/servers/src/http/handler.rs
index 626dcecf24..69ba93cc5c 100644
--- a/src/servers/src/http/handler.rs
+++ b/src/servers/src/http/handler.rs
@@ -327,6 +327,8 @@ impl From<PromqlQuery> for PromQuery {
             lookback: query
                 .lookback
                 .unwrap_or_else(|| DEFAULT_LOOKBACK_STRING.to_string()),
+            // TODO(dennis): support alias from http params or parse from query.query
+            alias: None,
         }
     }
 }
diff --git a/src/servers/src/http/jaeger.rs b/src/servers/src/http/jaeger.rs
index b7cea134cc..77b598ad1a 100644
--- a/src/servers/src/http/jaeger.rs
+++ b/src/servers/src/http/jaeger.rs
@@ -973,7 +973,7 @@ fn to_keyvalue(key: String, value: JsonValue) -> Option<KeyValue> {
         JsonValue::String(value) => Some(KeyValue {
             key,
             value_type: ValueType::String,
-            value: Value::String(value.to_string()),
+            value: Value::String(value.clone()),
         }),
         JsonValue::Number(value) => Some(KeyValue {
             key,
diff --git a/src/servers/src/http/prometheus.rs b/src/servers/src/http/prometheus.rs
index 1c9f76a0e6..e4c9677a4c 100644
--- a/src/servers/src/http/prometheus.rs
+++ b/src/servers/src/http/prometheus.rs
@@ -245,6 +245,7 @@ pub async fn instant_query(
             .lookback
             .or(form_params.lookback)
             .unwrap_or_else(|| DEFAULT_LOOKBACK_STRING.to_string()),
+        alias: None,
     };
 
     let promql_expr = try_call_return_response!(promql_parser::parser::parse(&prom_query.query));
@@ -356,6 +357,7 @@ pub async fn range_query(
             .lookback
             .or(form_params.lookback)
             .unwrap_or_else(|| DEFAULT_LOOKBACK_STRING.to_string()),
+        alias: None,
     };
 
     let promql_expr = try_call_return_response!(promql_parser::parser::parse(&prom_query.query));
@@ -568,6 +570,7 @@ pub async fn labels_query(
             end: end.clone(),
             step: DEFAULT_LOOKBACK_STRING.to_string(),
             lookback: lookback.clone(),
+            alias: None,
         };
 
         let result = handler.do_query(&prom_query, query_ctx.clone()).await;
@@ -784,7 +787,7 @@ fn record_batches_to_labels_name(
 
             // if a field is not null, record the tag name and return
             names.iter().for_each(|name| {
-                let _ = labels.insert(name.to_string());
+                let _ = labels.insert(name.clone());
             });
             return Ok(());
         }
@@ -811,7 +814,7 @@ pub(crate) fn get_catalog_schema(db: &Option<String>, ctx: &QueryContext) -> (St
     } else {
         (
             ctx.current_catalog().to_string(),
-            ctx.current_schema().to_string(),
+            ctx.current_schema().clone(),
         )
     }
 }
@@ -1091,14 +1094,7 @@ pub async fn label_values_query(
         // Only use and filter matchers.
         let matchers = matchers.matchers;
         let result = handler
-            .query_label_values(
-                name,
-                label_name.to_string(),
-                matchers,
-                start,
-                end,
-                &query_ctx,
-            )
+            .query_label_values(name, label_name.clone(), matchers, start, end, &query_ctx)
             .await;
         if let Some(result) = handle_schema_err!(result) {
             label_values.extend(result.into_iter());
@@ -1243,8 +1239,8 @@ async fn retrieve_field_names(
             .context(CatalogSnafu)?
             .with_context(|| TableNotFoundSnafu {
                 catalog: catalog.to_string(),
-                schema: schema.to_string(),
-                table: table_name.to_string(),
+                schema: schema.clone(),
+                table: table_name.clone(),
             })?;
 
         for column in table.field_columns() {
@@ -1367,6 +1363,7 @@ pub async fn series_query(
             // TODO: find a better value for step
             step: DEFAULT_LOOKBACK_STRING.to_string(),
             lookback: lookback.clone(),
+            alias: None,
         };
         let result = handler.do_query(&prom_query, query_ctx.clone()).await;
 
diff --git a/src/servers/src/lib.rs b/src/servers/src/lib.rs
index 10c474c499..7172934e66 100644
--- a/src/servers/src/lib.rs
+++ b/src/servers/src/lib.rs
@@ -15,7 +15,6 @@
 #![feature(assert_matches)]
 #![feature(try_blocks)]
 #![feature(exclusive_wrapper)]
-#![feature(let_chains)]
 #![feature(if_let_guard)]
 
 use datafusion_expr::LogicalPlan;
diff --git a/src/servers/src/mysql/handler.rs b/src/servers/src/mysql/handler.rs
index ade126c12d..aa57708ab7 100644
--- a/src/servers/src/mysql/handler.rs
+++ b/src/servers/src/mysql/handler.rs
@@ -249,7 +249,7 @@ impl MysqlInstanceShim {
         if params.len() != param_num - 1 {
             self.save_plan(
                 SqlPlan {
-                    query: query.to_string(),
+                    query: query.clone(),
                     statement: Some(statement),
                     plan: None,
                     schema: None,
@@ -263,7 +263,7 @@ impl MysqlInstanceShim {
         } else {
             self.save_plan(
                 SqlPlan {
-                    query: query.to_string(),
+                    query: query.clone(),
                     statement: Some(statement),
                     plan,
                     schema,
@@ -605,7 +605,7 @@ impl<W: AsyncWrite + Send + Sync + Unpin> AsyncMysqlShim<W> for MysqlInstanceShi
     async fn on_init<'a>(&'a mut self, database: &'a str, w: InitWriter<'a, W>) -> Result<()> {
         let (catalog_from_db, schema) = parse_optional_catalog_and_schema_from_db_string(database);
         let catalog = if let Some(catalog) = &catalog_from_db {
-            catalog.to_string()
+            catalog.clone()
         } else {
             self.session.catalog()
         };
diff --git a/src/servers/src/mysql/writer.rs b/src/servers/src/mysql/writer.rs
index 59540e58e7..73545db347 100644
--- a/src/servers/src/mysql/writer.rs
+++ b/src/servers/src/mysql/writer.rs
@@ -237,6 +237,17 @@ impl<'a, W: AsyncWrite + Unpin> MysqlResultWriter<'a, W> {
                         "[{}]",
                         v.items().iter().map(|x| x.to_string()).join(", ")
                     ))?,
+                    Value::Struct(struct_value) => row_writer.write_col(format!(
+                        "{{{}}}",
+                        struct_value
+                            .struct_type()
+                            .fields()
+                            .iter()
+                            .map(|f| f.name())
+                            .zip(struct_value.items().iter())
+                            .map(|(k, v)| format!("{k}: {v}"))
+                            .join(", ")
+                    ))?,
                     Value::Time(v) => row_writer
                         .write_col(v.to_timezone_aware_string(Some(&query_context.timezone())))?,
                     Value::Decimal128(v) => row_writer.write_col(v.to_string())?,
@@ -293,6 +304,7 @@ pub(crate) fn create_mysql_column(
         ConcreteDataType::Json(_) => Ok(ColumnType::MYSQL_TYPE_JSON),
         ConcreteDataType::Vector(_) => Ok(ColumnType::MYSQL_TYPE_BLOB),
         ConcreteDataType::List(_) => Ok(ColumnType::MYSQL_TYPE_VARCHAR),
+        ConcreteDataType::Struct(_) => Ok(ColumnType::MYSQL_TYPE_VARCHAR),
         _ => error::UnsupportedDataTypeSnafu {
             data_type,
             reason: "not implemented",
diff --git a/src/servers/src/opentsdb/codec.rs b/src/servers/src/opentsdb/codec.rs
index a3ab53a3b1..16aa9b6381 100644
--- a/src/servers/src/opentsdb/codec.rs
+++ b/src/servers/src/opentsdb/codec.rs
@@ -154,9 +154,9 @@ impl DataPoint {
 
         for (tagk, tagv) in self.tags.iter() {
             columns.push(Column {
-                column_name: tagk.to_string(),
+                column_name: tagk.clone(),
                 values: Some(column::Values {
-                    string_values: vec![tagv.to_string()],
+                    string_values: vec![tagv.clone()],
                     ..Default::default()
                 }),
                 semantic_type: SemanticType::Tag as i32,
diff --git a/src/servers/src/otlp/metrics.rs b/src/servers/src/otlp/metrics.rs
index be02e71ea2..274a0ba41e 100644
--- a/src/servers/src/otlp/metrics.rs
+++ b/src/servers/src/otlp/metrics.rs
@@ -298,8 +298,7 @@ pub fn normalize_metric_name(metric: &Metric, metric_type: &MetricType) -> Strin
 
     // Metric name cannot start with a digit, so prefix it with "_" in this case
     if let Some((_, first)) = name.char_indices().next()
-        && first >= '0'
-        && first <= '9'
+        && first.is_ascii_digit()
     {
         format!("_{}", name)
     } else {
@@ -343,8 +342,7 @@ pub fn normalize_label_name(name: &str) -> String {
 
     let n = NON_ALPHA_NUM_CHAR.replace_all(name, UNDERSCORE);
     if let Some((_, first)) = n.char_indices().next()
-        && first >= '0'
-        && first <= '9'
+        && first.is_ascii_digit()
     {
         return format!("key_{}", n);
     }
diff --git a/src/servers/src/postgres/handler.rs b/src/servers/src/postgres/handler.rs
index 944d5e688a..f3c1fdeca9 100644
--- a/src/servers/src/postgres/handler.rs
+++ b/src/servers/src/postgres/handler.rs
@@ -110,7 +110,7 @@ where
                 ErrorInfo::new(
                     PgErrorSeverity::Warning.to_string(),
                     PgErrorCode::Ec01000.code(),
-                    warning.to_string(),
+                    warning.clone(),
                 )
                 .into(),
             ))
diff --git a/src/servers/src/postgres/types.rs b/src/servers/src/postgres/types.rs
index d4d6393437..204c349547 100644
--- a/src/servers/src/postgres/types.rs
+++ b/src/servers/src/postgres/types.rs
@@ -28,7 +28,7 @@ use datatypes::arrow::datatypes::DataType as ArrowDataType;
 use datatypes::prelude::{ConcreteDataType, Value};
 use datatypes::schema::Schema;
 use datatypes::types::{IntervalType, TimestampType, json_type_value_to_string};
-use datatypes::value::ListValue;
+use datatypes::value::{ListValue, StructValue};
 use pgwire::api::Type;
 use pgwire::api::portal::{Format, Portal};
 use pgwire::api::results::{DataRowEncoder, FieldInfo};
@@ -62,6 +62,14 @@ pub(super) fn schema_to_pg(origin: &Schema, field_formats: &Format) -> Result<Ve
         .collect::<Result<Vec<FieldInfo>>>()
 }
 
+fn encode_struct(
+    _query_ctx: &QueryContextRef,
+    _struct_value: &StructValue,
+    _builder: &mut DataRowEncoder,
+) -> PgWireResult<()> {
+    todo!("how to encode struct for postgres");
+}
+
 fn encode_array(
     query_ctx: &QueryContextRef,
     value_list: &ListValue,
@@ -428,6 +436,7 @@ pub(super) fn encode_value(
             })),
         },
         Value::List(values) => encode_array(query_ctx, values, builder),
+        Value::Struct(values) => encode_struct(query_ctx, values, builder),
     }
 }
 
@@ -467,10 +476,12 @@ pub(super) fn type_gt_to_pg(origin: &ConcreteDataType) -> Result<Type> {
             &ConcreteDataType::Decimal128(_) => Ok(Type::NUMERIC_ARRAY),
             &ConcreteDataType::Json(_) => Ok(Type::JSON_ARRAY),
             &ConcreteDataType::Duration(_) => Ok(Type::INTERVAL_ARRAY),
+            // TODO(sunng87) we may treat list/array as json directly so we can
+            // support deeply nested data structures
+            &ConcreteDataType::Struct(_) => Ok(Type::RECORD_ARRAY),
             &ConcreteDataType::Dictionary(_)
             | &ConcreteDataType::Vector(_)
-            | &ConcreteDataType::List(_)
-            | &ConcreteDataType::Struct(_) => server_error::UnsupportedDataTypeSnafu {
+            | &ConcreteDataType::List(_) => server_error::UnsupportedDataTypeSnafu {
                 data_type: origin,
                 reason: "not implemented",
             }
@@ -482,11 +493,7 @@ pub(super) fn type_gt_to_pg(origin: &ConcreteDataType) -> Result<Type> {
         }
         .fail(),
         &ConcreteDataType::Duration(_) => Ok(Type::INTERVAL),
-        &ConcreteDataType::Struct(_) => server_error::UnsupportedDataTypeSnafu {
-            data_type: origin,
-            reason: "not implemented",
-        }
-        .fail(),
+        &ConcreteDataType::Struct(_) => Ok(Type::RECORD),
     }
 }
 
diff --git a/src/servers/src/prom_store.rs b/src/servers/src/prom_store.rs
index 95dd6453dc..9738bbc8a0 100644
--- a/src/servers/src/prom_store.rs
+++ b/src/servers/src/prom_store.rs
@@ -66,7 +66,7 @@ pub fn table_name(q: &Query) -> Result<String> {
         .iter()
         .find_map(|m| {
             if m.name == METRIC_NAME_LABEL {
-                Some(m.value.to_string())
+                Some(m.value.clone())
             } else {
                 None
             }
diff --git a/src/servers/src/repeated_field.rs b/src/servers/src/repeated_field.rs
index 701ea19e05..42e22d367a 100644
--- a/src/servers/src/repeated_field.rs
+++ b/src/servers/src/repeated_field.rs
@@ -277,13 +277,13 @@ impl<T> RepeatedField<T> {
 
     /// Immutable data iterator.
     #[inline]
-    pub fn iter(&self) -> slice::Iter<T> {
+    pub fn iter(&self) -> slice::Iter<'_, T> {
         self.as_ref().iter()
     }
 
     /// Mutable data iterator.
     #[inline]
-    pub fn iter_mut(&mut self) -> slice::IterMut<T> {
+    pub fn iter_mut(&mut self) -> slice::IterMut<'_, T> {
         self.as_mut_slice().iter_mut()
     }
 
diff --git a/src/servers/tests/mod.rs b/src/servers/tests/mod.rs
index aeadb74f90..7d6268215c 100644
--- a/src/servers/tests/mod.rs
+++ b/src/servers/tests/mod.rs
@@ -144,6 +144,7 @@ impl GrpcQueryHandler for DummyInstance {
                             end: promql.end,
                             step: promql.step,
                             lookback: promql.lookback,
+                            alias: None,
                         };
                         let mut result =
                             SqlQueryHandler::do_promql_query(self, &prom_query, ctx).await;
diff --git a/src/session/src/context.rs b/src/session/src/context.rs
index 0ba0cdb2f8..c6c6d021a6 100644
--- a/src/session/src/context.rs
+++ b/src/session/src/context.rs
@@ -258,7 +258,7 @@ impl QueryContext {
             });
         QueryContextBuilder::default()
             .current_catalog(catalog)
-            .current_schema(schema.to_string())
+            .current_schema(schema.clone())
             .build()
     }
 
diff --git a/src/session/src/table_name.rs b/src/session/src/table_name.rs
index e5c778c2f9..04bcd836c3 100644
--- a/src/session/src/table_name.rs
+++ b/src/session/src/table_name.rs
@@ -47,7 +47,7 @@ pub fn table_idents_to_full_name(
     match &obj_name.0[..] {
         [table] => Ok((
             query_ctx.current_catalog().to_string(),
-            query_ctx.current_schema().to_string(),
+            query_ctx.current_schema().clone(),
             table.to_string_unquoted(),
         )),
         [schema, table] => Ok((
diff --git a/src/sql/src/lib.rs b/src/sql/src/lib.rs
index bfa56c5e42..b2b151d439 100644
--- a/src/sql/src/lib.rs
+++ b/src/sql/src/lib.rs
@@ -15,7 +15,6 @@
 #![feature(box_patterns)]
 #![feature(assert_matches)]
 #![feature(if_let_guard)]
-#![feature(let_chains)]
 
 pub mod ast;
 pub mod dialect;
diff --git a/src/sql/src/parsers/alter_parser.rs b/src/sql/src/parsers/alter_parser.rs
index ee49b43d2b..bbbcb1d2f6 100644
--- a/src/sql/src/parsers/alter_parser.rs
+++ b/src/sql/src/parsers/alter_parser.rs
@@ -78,7 +78,6 @@ impl ParserContext<'_> {
                         .parse_comma_separated(parse_string_option_names)
                         .context(error::SyntaxSnafu)?
                         .into_iter()
-                        .map(|name| name.to_string())
                         .collect();
                     Ok(AlterDatabase::new(
                         database_name,
@@ -770,7 +769,7 @@ mod tests {
                 );
                 match alter.alter_operation {
                     AlterTableOperation::AddColumns { add_columns } => {
-                        let expected = vec![
+                        let expected = [
                             AddColumn {
                                 column_def: ColumnDef {
                                     name: Ident::new("a"),
@@ -1030,8 +1029,7 @@ mod tests {
         };
 
         assert_eq!(sql, alter.to_string());
-        let res = keys.iter().map(|o| o.to_string()).collect::<Vec<_>>();
-        assert_eq!(expected, &res);
+        assert_eq!(expected, keys);
     }
 
     #[test]
diff --git a/src/sql/src/parsers/create_parser.rs b/src/sql/src/parsers/create_parser.rs
index 06c3792187..30a087088a 100644
--- a/src/sql/src/parsers/create_parser.rs
+++ b/src/sql/src/parsers/create_parser.rs
@@ -208,9 +208,7 @@ impl<'a> ParserContext<'a> {
         for key in options.keys() {
             ensure!(
                 validate_database_option(key),
-                InvalidDatabaseOptionSnafu {
-                    key: key.to_string()
-                }
+                InvalidDatabaseOptionSnafu { key: key.clone() }
             );
         }
         if let Some(append_mode) = options.get("append_mode")
diff --git a/src/sql/src/parsers/create_parser/trigger.rs b/src/sql/src/parsers/create_parser/trigger.rs
index 553a53960d..65ebc7fe1e 100644
--- a/src/sql/src/parsers/create_parser/trigger.rs
+++ b/src/sql/src/parsers/create_parser/trigger.rs
@@ -379,9 +379,7 @@ impl<'a> ParserContext<'a> {
         for key in options.keys() {
             ensure!(
                 validate_webhook_option(key),
-                error::InvalidTriggerWebhookOptionSnafu {
-                    key: key.to_string()
-                }
+                error::InvalidTriggerWebhookOptionSnafu { key: key.clone() }
             );
         }
 
@@ -486,7 +484,7 @@ IF NOT EXISTS cpu_monitor
             "(SELECT host AS host_label, cpu, memory FROM machine_monitor WHERE cpu > 1)"
         );
         assert_eq!(*interval, Duration::from_secs(300));
-        assert_eq!(raw_interval_expr.to_string(), "'5 minute'::INTERVAL");
+        assert_eq!(raw_interval_expr.clone(), "'5 minute'::INTERVAL");
         assert_eq!(create_trigger.labels.len(), 1);
         assert_eq!(
             create_trigger.labels.get("label_name").unwrap(),
diff --git a/src/sql/src/parsers/explain_parser.rs b/src/sql/src/parsers/explain_parser.rs
index e3fd05cad6..c595efc86d 100644
--- a/src/sql/src/parsers/explain_parser.rs
+++ b/src/sql/src/parsers/explain_parser.rs
@@ -13,37 +13,47 @@
 // limitations under the License.
 
 use snafu::ResultExt;
-use sqlparser::ast::DescribeAlias;
+use sqlparser::keywords::Keyword;
 
 use crate::error::{self, Result};
 use crate::parser::ParserContext;
-use crate::statements::explain::Explain;
+use crate::statements::explain::ExplainStatement;
 use crate::statements::statement::Statement;
 
 /// EXPLAIN statement parser implementation
 impl ParserContext<'_> {
+    /// explain that support use our own parser to parse the inner statement
     pub(crate) fn parse_explain(&mut self) -> Result<Statement> {
-        let explain_statement = self
-            .parser
-            .parse_explain(DescribeAlias::Explain)
-            .with_context(|_| error::UnexpectedSnafu {
-                expected: "a query statement",
-                actual: self.peek_token_as_string(),
-            })?;
+        let analyze = self.parser.parse_keyword(Keyword::ANALYZE);
+        let verbose = self.parser.parse_keyword(Keyword::VERBOSE);
+        let format =
+            if self.parser.parse_keyword(Keyword::FORMAT) {
+                Some(self.parser.parse_analyze_format().with_context(|_| {
+                    error::UnexpectedSnafu {
+                        expected: "analyze format",
+                        actual: self.peek_token_as_string(),
+                    }
+                })?)
+            } else {
+                None
+            };
 
-        Ok(Statement::Explain(Box::new(Explain::try_from(
-            explain_statement,
-        )?)))
+        let statement = self.parse_statement()?;
+
+        let explain = ExplainStatement {
+            analyze,
+            verbose,
+            format,
+            statement: Box::new(statement),
+        };
+        Ok(Statement::Explain(Box::new(explain)))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use sqlparser::ast::helpers::attached_token::AttachedToken;
-    use sqlparser::ast::{
-        GroupByExpr, Query as SpQuery, SelectFlavor, Statement as SpStatement,
-        WildcardAdditionalOptions,
-    };
+    use sqlparser::ast::{GroupByExpr, Query as SpQuery, SelectFlavor, WildcardAdditionalOptions};
 
     use super::*;
     use crate::dialect::GreptimeDbDialect;
@@ -97,31 +107,30 @@ mod tests {
             flavor: SelectFlavor::Standard,
         };
 
-        let sp_statement = SpStatement::Query(Box::new(SpQuery {
-            with: None,
-            body: Box::new(sqlparser::ast::SetExpr::Select(Box::new(select))),
-            order_by: None,
-            limit: None,
-            limit_by: vec![],
-            offset: None,
-            fetch: None,
-            locks: vec![],
-            for_clause: None,
-            settings: None,
-            format_clause: None,
-        }));
+        let sp_query = Box::new(
+            SpQuery {
+                with: None,
+                body: Box::new(sqlparser::ast::SetExpr::Select(Box::new(select))),
+                order_by: None,
+                limit: None,
+                limit_by: vec![],
+                offset: None,
+                fetch: None,
+                locks: vec![],
+                for_clause: None,
+                settings: None,
+                format_clause: None,
+            }
+            .try_into()
+            .unwrap(),
+        );
 
-        let explain = Explain::try_from(SpStatement::Explain {
-            describe_alias: DescribeAlias::Explain,
+        let explain = ExplainStatement {
             analyze: false,
             verbose: false,
-            statement: Box::new(sp_statement),
             format: None,
-            query_plan: false,
-            options: None,
-            estimate: false,
-        })
-        .unwrap();
+            statement: Box::new(Statement::Query(sp_query)),
+        };
 
         assert_eq!(stmts[0], Statement::Explain(Box::new(explain)))
     }
diff --git a/src/sql/src/parsers/tql_parser.rs b/src/sql/src/parsers/tql_parser.rs
index e284c19d8c..bb5e858e4a 100644
--- a/src/sql/src/parsers/tql_parser.rs
+++ b/src/sql/src/parsers/tql_parser.rs
@@ -148,8 +148,8 @@ impl ParserContext<'_> {
             _ => ("0".to_string(), "0".to_string(), "5m".to_string(), None),
         };
 
-        let query = Self::parse_tql_query(parser, self.sql).context(ParserSnafu)?;
-        Ok(TqlParameters::new(start, end, step, lookback, query))
+        let (query, alias) = Self::parse_tql_query(parser, self.sql).context(ParserSnafu)?;
+        Ok(TqlParameters::new(start, end, step, lookback, query, alias))
     }
 
     pub fn comma_or_rparen(token: &Token) -> bool {
@@ -250,7 +250,11 @@ impl ParserContext<'_> {
         })
     }
 
-    fn parse_tql_query(parser: &mut Parser, sql: &str) -> std::result::Result<String, ParserError> {
+    /// Parse the TQL query and optional alias from the given [Parser] and SQL string.
+    pub fn parse_tql_query(
+        parser: &mut Parser,
+        sql: &str,
+    ) -> std::result::Result<(String, Option<String>), ParserError> {
         while matches!(parser.peek_token().token, Token::Comma) {
             let _skip_token = parser.next_token();
         }
@@ -262,14 +266,43 @@ impl ParserContext<'_> {
         let start_location = start_tql.span.start;
         // translate the start location to the index in the sql string
         let index = location_to_index(sql, &start_location);
+        assert!(index > 0);
 
-        let query = &sql[index - 1..];
-        while parser.next_token() != Token::EOF {
-            // consume all tokens
-            // TODO(dennis): supports multi TQL statements separated by ';'?
+        let mut token = start_tql;
+        loop {
+            // Find AS keyword, which indicates "<promql> AS <alias"
+            if matches!(&token.token, Token::Word(w) if w.keyword == Keyword::AS) {
+                let query_end_index = location_to_index(sql, &token.span.start);
+                let alias = parser.parse_identifier()?;
+                let promql = sql[index - 1..query_end_index]
+                    .trim()
+                    .trim_end_matches(';')
+                    .to_string();
+                if promql.is_empty() {
+                    return Err(ParserError::ParserError("Empty promql query".to_string()));
+                }
+
+                if parser.consume_token(&Token::EOF) || parser.consume_token(&Token::SemiColon) {
+                    return Ok((promql, Some(alias.value)));
+                } else {
+                    return Err(ParserError::ParserError(format!(
+                        "Unexpected token after alias: {}",
+                        parser.peek_token()
+                    )));
+                }
+            }
+            token = parser.next_token();
+            if token == Token::EOF {
+                break;
+            }
         }
-        // remove the last ';' or tailing space if exists
-        Ok(query.trim().trim_end_matches(';').to_string())
+
+        // AS clause not found
+        let promql = sql[index - 1..].trim().trim_end_matches(';').to_string();
+        if promql.is_empty() {
+            return Err(ParserError::ParserError("Empty promql query".to_string()));
+        }
+        Ok((promql, None))
     }
 }
 
@@ -1018,6 +1051,188 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_parse_tql_with_alias() {
+        // Test TQL EVAL with alias
+        let sql = "TQL EVAL (0, 30, '10s') http_requests_total AS my_metric";
+        match parse_into_statement(sql) {
+            Statement::Tql(Tql::Eval(eval)) => {
+                assert_eq!(eval.start, "0");
+                assert_eq!(eval.end, "30");
+                assert_eq!(eval.step, "10s");
+                assert_eq!(eval.lookback, None);
+                assert_eq!(eval.query, "http_requests_total");
+                assert_eq!(eval.alias, Some("my_metric".to_string()));
+            }
+            _ => unreachable!(),
+        }
+
+        // Test TQL EVAL with complex query and alias
+        let sql = "TQL EVAL (1676887657, 1676887659, '1m') http_requests_total{environment=~'staging|testing|development',method!='GET'} @ 1609746000 offset 5m AS web_requests";
+        match parse_into_statement(sql) {
+            Statement::Tql(Tql::Eval(eval)) => {
+                assert_eq!(eval.start, "1676887657");
+                assert_eq!(eval.end, "1676887659");
+                assert_eq!(eval.step, "1m");
+                assert_eq!(eval.lookback, None);
+                assert_eq!(
+                    eval.query,
+                    "http_requests_total{environment=~'staging|testing|development',method!='GET'} @ 1609746000 offset 5m"
+                );
+                assert_eq!(eval.alias, Some("web_requests".to_string()));
+            }
+            _ => unreachable!(),
+        }
+
+        // Test TQL EVAL with lookback and alias
+        let sql = "TQL EVAL (0, 100, '30s', '5m') cpu_usage_total AS cpu_metrics";
+        match parse_into_statement(sql) {
+            Statement::Tql(Tql::Eval(eval)) => {
+                assert_eq!(eval.start, "0");
+                assert_eq!(eval.end, "100");
+                assert_eq!(eval.step, "30s");
+                assert_eq!(eval.lookback, Some("5m".to_string()));
+                assert_eq!(eval.query, "cpu_usage_total");
+                assert_eq!(eval.alias, Some("cpu_metrics".to_string()));
+            }
+            _ => unreachable!(),
+        }
+
+        // Test TQL EXPLAIN with alias
+        let sql = "TQL EXPLAIN (20, 100, '10s') memory_usage{app='web'} AS memory_data";
+        match parse_into_statement(sql) {
+            Statement::Tql(Tql::Explain(explain)) => {
+                assert_eq!(explain.start, "20");
+                assert_eq!(explain.end, "100");
+                assert_eq!(explain.step, "10s");
+                assert_eq!(explain.lookback, None);
+                assert_eq!(explain.query, "memory_usage{app='web'}");
+                assert_eq!(explain.alias, Some("memory_data".to_string()));
+                assert!(!explain.is_verbose);
+                assert_eq!(explain.format, None);
+            }
+            _ => unreachable!(),
+        }
+
+        // Test TQL EXPLAIN VERBOSE with alias
+        let sql = "TQL EXPLAIN VERBOSE FORMAT JSON (0, 50, '5s') disk_io_rate AS disk_metrics";
+        match parse_into_statement(sql) {
+            Statement::Tql(Tql::Explain(explain)) => {
+                assert_eq!(explain.start, "0");
+                assert_eq!(explain.end, "50");
+                assert_eq!(explain.step, "5s");
+                assert_eq!(explain.lookback, None);
+                assert_eq!(explain.query, "disk_io_rate");
+                assert_eq!(explain.alias, Some("disk_metrics".to_string()));
+                assert!(explain.is_verbose);
+                assert_eq!(explain.format, Some(AnalyzeFormat::JSON));
+            }
+            _ => unreachable!(),
+        }
+
+        // Test TQL ANALYZE with alias
+        let sql = "TQL ANALYZE (100, 200, '1m') network_bytes_total AS network_stats";
+        match parse_into_statement(sql) {
+            Statement::Tql(Tql::Analyze(analyze)) => {
+                assert_eq!(analyze.start, "100");
+                assert_eq!(analyze.end, "200");
+                assert_eq!(analyze.step, "1m");
+                assert_eq!(analyze.lookback, None);
+                assert_eq!(analyze.query, "network_bytes_total");
+                assert_eq!(analyze.alias, Some("network_stats".to_string()));
+                assert!(!analyze.is_verbose);
+                assert_eq!(analyze.format, None);
+            }
+            _ => unreachable!(),
+        }
+
+        // Test TQL ANALYZE VERBOSE with alias and lookback
+        let sql = "TQL ANALYZE VERBOSE FORMAT TEXT (0, 1000, '2m', '30s') error_rate{service='api'} AS api_errors";
+        match parse_into_statement(sql) {
+            Statement::Tql(Tql::Analyze(analyze)) => {
+                assert_eq!(analyze.start, "0");
+                assert_eq!(analyze.end, "1000");
+                assert_eq!(analyze.step, "2m");
+                assert_eq!(analyze.lookback, Some("30s".to_string()));
+                assert_eq!(analyze.query, "error_rate{service='api'}");
+                assert_eq!(analyze.alias, Some("api_errors".to_string()));
+                assert!(analyze.is_verbose);
+                assert_eq!(analyze.format, Some(AnalyzeFormat::TEXT));
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn test_parse_tql_alias_edge_cases() {
+        // Test alias with underscore and numbers
+        let sql = "TQL EVAL (0, 10, '5s') test_metric AS metric_123";
+        match parse_into_statement(sql) {
+            Statement::Tql(Tql::Eval(eval)) => {
+                assert_eq!(eval.query, "test_metric");
+                assert_eq!(eval.alias, Some("metric_123".to_string()));
+            }
+            _ => unreachable!(),
+        }
+
+        // Test complex PromQL expression with AS
+        let sql = r#"TQL EVAL (0, 30, '10s') (sum by(host) (irate(host_cpu_seconds_total{mode!='idle'}[1m0s])) / sum by (host)((irate(host_cpu_seconds_total[1m0s])))) * 100 AS cpu_utilization;"#;
+        match parse_into_statement(sql) {
+            Statement::Tql(Tql::Eval(eval)) => {
+                assert_eq!(
+                    eval.query,
+                    "(sum by(host) (irate(host_cpu_seconds_total{mode!='idle'}[1m0s])) / sum by (host)((irate(host_cpu_seconds_total[1m0s])))) * 100"
+                );
+                assert_eq!(eval.alias, Some("cpu_utilization".to_string()));
+            }
+            _ => unreachable!(),
+        }
+
+        // Test query with semicolon and alias
+        let sql = "TQL EVAL (0, 10, '5s') simple_metric AS my_alias";
+        match parse_into_statement(sql) {
+            Statement::Tql(Tql::Eval(eval)) => {
+                assert_eq!(eval.query, "simple_metric");
+                assert_eq!(eval.alias, Some("my_alias".to_string()));
+            }
+            _ => unreachable!(),
+        }
+
+        // Test without alias (ensure it still works)
+        let sql = "TQL EVAL (0, 10, '5s') test_metric_no_alias";
+        match parse_into_statement(sql) {
+            Statement::Tql(Tql::Eval(eval)) => {
+                assert_eq!(eval.query, "test_metric_no_alias");
+                assert_eq!(eval.alias, None);
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn test_parse_tql_alias_errors() {
+        let dialect = &GreptimeDbDialect {};
+        let parse_options = ParseOptions::default();
+
+        // Test AS without alias identifier
+        let sql = "TQL EVAL (0, 10, '5s') test_metric AS";
+        let result = ParserContext::create_with_dialect(sql, dialect, parse_options.clone());
+        assert!(result.is_err(), "Should fail when AS has no identifier");
+
+        // Test AS with invalid characters after alias
+        let sql = "TQL EVAL (0, 10, '5s') test_metric AS alias extra_token";
+        let result = ParserContext::create_with_dialect(sql, dialect, parse_options.clone());
+        assert!(
+            result.is_err(),
+            "Should fail with unexpected token after alias"
+        );
+
+        // Test AS with empty promql query
+        let sql = "TQL EVAL (0, 10, '5s') AS alias";
+        let result = ParserContext::create_with_dialect(sql, dialect, parse_options.clone());
+        assert!(result.is_err(), "Should fail with empty promql query");
+    }
+
     #[test]
     fn test_parse_tql_error() {
         let dialect = &GreptimeDbDialect {};
diff --git a/src/sql/src/statements.rs b/src/sql/src/statements.rs
index 488fadfae6..051368f12c 100644
--- a/src/sql/src/statements.rs
+++ b/src/sql/src/statements.rs
@@ -127,7 +127,7 @@ pub fn column_to_schema(
     }) {
         let _ = column_schema
             .mut_metadata()
-            .insert(COMMENT_KEY.to_string(), c.to_string());
+            .insert(COMMENT_KEY.to_string(), c.clone());
     }
 
     if let Some(options) = column.extensions.build_fulltext_options()? {
diff --git a/src/sql/src/statements/explain.rs b/src/sql/src/statements/explain.rs
index c893321fdb..b311f55fe0 100644
--- a/src/sql/src/statements/explain.rs
+++ b/src/sql/src/statements/explain.rs
@@ -15,36 +15,44 @@
 use std::fmt::{Display, Formatter};
 
 use serde::Serialize;
-use sqlparser::ast::{AnalyzeFormat, Statement as SpStatement};
+use sqlparser::ast::AnalyzeFormat;
 use sqlparser_derive::{Visit, VisitMut};
 
-use crate::error::Error;
+use crate::statements::statement::Statement;
 
 /// Explain statement.
 #[derive(Debug, Clone, PartialEq, Eq, Visit, VisitMut, Serialize)]
-pub struct Explain {
-    pub inner: SpStatement,
+pub struct ExplainStatement {
+    /// `EXPLAIN ANALYZE ..`
+    pub analyze: bool,
+    /// `EXPLAIN .. VERBOSE ..`
+    pub verbose: bool,
+    /// `EXPLAIN .. FORMAT `
+    pub format: Option<AnalyzeFormat>,
+    /// The statement to analyze. Note this is a Greptime [`Statement`] (not a
+    /// [`sqlparser::ast::Statement`] so that we can use
+    /// Greptime specific statements
+    pub statement: Box<Statement>,
 }
 
-impl Explain {
+impl ExplainStatement {
     pub fn format(&self) -> Option<AnalyzeFormat> {
-        match self.inner {
-            SpStatement::Explain { format, .. } => format,
-            _ => None,
-        }
+        self.format
     }
 }
 
-impl TryFrom<SpStatement> for Explain {
-    type Error = Error;
-
-    fn try_from(value: SpStatement) -> Result<Self, Self::Error> {
-        Ok(Explain { inner: value })
-    }
-}
-
-impl Display for Explain {
+impl Display for ExplainStatement {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.inner)
+        write!(f, "EXPLAIN")?;
+        if self.analyze {
+            write!(f, " ANALYZE")?;
+        }
+        if self.verbose {
+            write!(f, " VERBOSE")?;
+        }
+        if let Some(format) = &self.format {
+            write!(f, " FORMAT {}", format)?;
+        }
+        write!(f, " {}", self.statement)
     }
 }
diff --git a/src/sql/src/statements/insert.rs b/src/sql/src/statements/insert.rs
index 041119fc68..a7cae6a52a 100644
--- a/src/sql/src/statements/insert.rs
+++ b/src/sql/src/statements/insert.rs
@@ -160,7 +160,7 @@ fn sql_exprs_to_values(exprs: &[Vec<Expr>]) -> Result<Vec<Vec<Value>>> {
                     {
                         match op {
                             UnaryOperator::Minus => Value::Number(format!("-{s}"), *b),
-                            UnaryOperator::Plus => Value::Number(s.to_string(), *b),
+                            UnaryOperator::Plus => Value::Number(s.clone(), *b),
                             _ => unreachable!(),
                         }
                     } else {
diff --git a/src/sql/src/statements/option_map.rs b/src/sql/src/statements/option_map.rs
index 0177624a13..864bb3b3f9 100644
--- a/src/sql/src/statements/option_map.rs
+++ b/src/sql/src/statements/option_map.rs
@@ -73,7 +73,7 @@ impl OptionMap {
         map.extend(
             self.secrets
                 .into_iter()
-                .map(|(k, v)| (k, v.expose_secret().to_string())),
+                .map(|(k, v)| (k, v.expose_secret().clone())),
         );
         map
     }
diff --git a/src/sql/src/statements/statement.rs b/src/sql/src/statements/statement.rs
index 3f582a9f30..d0096baa71 100644
--- a/src/sql/src/statements/statement.rs
+++ b/src/sql/src/statements/statement.rs
@@ -30,7 +30,7 @@ use crate::statements::cursor::{CloseCursor, DeclareCursor, FetchCursor};
 use crate::statements::delete::Delete;
 use crate::statements::describe::DescribeTable;
 use crate::statements::drop::{DropDatabase, DropFlow, DropTable, DropView};
-use crate::statements::explain::Explain;
+use crate::statements::explain::ExplainStatement;
 use crate::statements::insert::Insert;
 use crate::statements::kill::Kill;
 use crate::statements::query::Query;
@@ -126,7 +126,7 @@ pub enum Statement {
     // DESCRIBE TABLE
     DescribeTable(DescribeTable),
     // EXPLAIN QUERY
-    Explain(Box<Explain>),
+    Explain(Box<ExplainStatement>),
     // COPY
     Copy(Copy),
     // Telemetry Query Language
@@ -301,7 +301,6 @@ impl TryFrom<&Statement> for DfStatement {
     fn try_from(s: &Statement) -> Result<Self, Self::Error> {
         let s = match s {
             Statement::Query(query) => SpStatement::Query(Box::new(query.inner.clone())),
-            Statement::Explain(explain) => explain.inner.clone(),
             Statement::Insert(insert) => insert.inner.clone(),
             Statement::Delete(delete) => delete.inner.clone(),
             _ => {
diff --git a/src/sql/src/statements/tql.rs b/src/sql/src/statements/tql.rs
index 18c9f7b197..835a957ead 100644
--- a/src/sql/src/statements/tql.rs
+++ b/src/sql/src/statements/tql.rs
@@ -42,15 +42,20 @@ fn format_tql(
     step: &str,
     lookback: Option<&str>,
     query: &str,
+    alias: &Option<String>,
 ) -> std::fmt::Result {
     write!(f, "({start}, {end}, '{step}'")?;
     if let Some(lookback) = lookback {
         write!(f, ", {lookback}")?;
     }
-    write!(f, ") {query}")
+    if let Some(alias) = alias {
+        write!(f, ") {query} AS {alias}")
+    } else {
+        write!(f, ") {query}")
+    }
 }
 
-/// TQL EVAL (<start>, <end>, <step>, [lookback]) <promql>
+/// TQL EVAL (<start>, <end>, <step>, [lookback]) <promql> [AS alias]
 #[derive(Debug, Clone, PartialEq, Eq, Visit, VisitMut, Serialize)]
 pub struct TqlEval {
     pub start: String,
@@ -58,6 +63,7 @@ pub struct TqlEval {
     pub step: String,
     pub lookback: Option<String>,
     pub query: String,
+    pub alias: Option<String>,
 }
 
 impl Display for TqlEval {
@@ -70,11 +76,12 @@ impl Display for TqlEval {
             &self.step,
             self.lookback.as_deref(),
             &self.query,
+            &self.alias,
         )
     }
 }
 
-/// TQL EXPLAIN [VERBOSE] [FORMAT format] [<start>, <end>, <step>, [lookback]] <promql>
+/// TQL EXPLAIN [VERBOSE] [FORMAT format] [<start>, <end>, <step>, [lookback]] <promql> [AS alias]
 /// doesn't execute the query but tells how the query would be executed (similar to SQL EXPLAIN).
 #[derive(Debug, Clone, PartialEq, Eq, Visit, VisitMut, Serialize)]
 pub struct TqlExplain {
@@ -83,6 +90,7 @@ pub struct TqlExplain {
     pub step: String,
     pub lookback: Option<String>,
     pub query: String,
+    pub alias: Option<String>,
     pub is_verbose: bool,
     pub format: Option<AnalyzeFormat>,
 }
@@ -103,11 +111,12 @@ impl Display for TqlExplain {
             &self.step,
             self.lookback.as_deref(),
             &self.query,
+            &self.alias,
         )
     }
 }
 
-/// TQL ANALYZE [VERBOSE] [FORMAT format] (<start>, <end>, <step>, [lookback]) <promql>
+/// TQL ANALYZE [VERBOSE] [FORMAT format] (<start>, <end>, <step>, [lookback]) <promql> [AS alias]
 /// executes the plan and tells the detailed per-step execution time (similar to SQL ANALYZE).
 #[derive(Debug, Clone, PartialEq, Eq, Visit, VisitMut, Serialize)]
 pub struct TqlAnalyze {
@@ -116,6 +125,7 @@ pub struct TqlAnalyze {
     pub step: String,
     pub lookback: Option<String>,
     pub query: String,
+    pub alias: Option<String>,
     pub is_verbose: bool,
     pub format: Option<AnalyzeFormat>,
 }
@@ -136,6 +146,7 @@ impl Display for TqlAnalyze {
             &self.step,
             self.lookback.as_deref(),
             &self.query,
+            &self.alias,
         )
     }
 }
@@ -151,6 +162,7 @@ pub struct TqlParameters {
     step: String,
     lookback: Option<String>,
     query: String,
+    alias: Option<String>,
     pub is_verbose: bool,
     pub format: Option<AnalyzeFormat>,
 }
@@ -162,6 +174,7 @@ impl TqlParameters {
         step: String,
         lookback: Option<String>,
         query: String,
+        alias: Option<String>,
     ) -> Self {
         TqlParameters {
             start,
@@ -169,6 +182,7 @@ impl TqlParameters {
             step,
             lookback,
             query,
+            alias,
             is_verbose: false,
             format: None,
         }
@@ -183,6 +197,7 @@ impl From<TqlParameters> for TqlEval {
             step: params.step,
             lookback: params.lookback,
             query: params.query,
+            alias: params.alias,
         }
     }
 }
@@ -194,6 +209,7 @@ impl From<TqlParameters> for TqlExplain {
             end: params.end,
             step: params.step,
             query: params.query,
+            alias: params.alias,
             lookback: params.lookback,
             is_verbose: params.is_verbose,
             format: params.format,
@@ -208,6 +224,7 @@ impl From<TqlParameters> for TqlAnalyze {
             end: params.end,
             step: params.step,
             query: params.query,
+            alias: params.alias,
             lookback: params.lookback,
             is_verbose: params.is_verbose,
             format: params.format,
diff --git a/src/sql/src/statements/transform/expand_interval.rs b/src/sql/src/statements/transform/expand_interval.rs
index 6108978289..9095f7b7c6 100644
--- a/src/sql/src/statements/transform/expand_interval.rs
+++ b/src/sql/src/statements/transform/expand_interval.rs
@@ -125,7 +125,7 @@ impl TransformRule for ExpandIntervalTransformRule {
                             ..
                         }) => {
                             let interval_value =
-                                normalize_interval_name(value).unwrap_or_else(|| value.to_string());
+                                normalize_interval_name(value).unwrap_or_else(|| value.clone());
                             *expr = Expr::Cast {
                                 kind: kind.clone(),
                                 expr: single_quoted_string_expr(interval_value),
diff --git a/src/sql/src/util.rs b/src/sql/src/util.rs
index c477e91a53..7de02ca1fa 100644
--- a/src/sql/src/util.rs
+++ b/src/sql/src/util.rs
@@ -62,7 +62,7 @@ pub fn parse_option_string(option: SqlOption) -> Result<(String, String)> {
         Expr::Value(ValueWithSpan {
             value: Value::Number(v, _),
             ..
-        }) => v.to_string(),
+        }) => v.clone(),
         value => return InvalidTableOptionValueSnafu { key, value }.fail(),
     };
     let k = key.value.to_lowercase();
diff --git a/src/store-api/src/lib.rs b/src/store-api/src/lib.rs
index 50cb332e69..4df594fc67 100644
--- a/src/store-api/src/lib.rs
+++ b/src/store-api/src/lib.rs
@@ -14,7 +14,6 @@
 
 //! Storage related APIs
 
-#![feature(let_chains)]
 #![feature(iterator_try_collect)]
 
 pub mod codec;
diff --git a/src/store-api/src/metadata.rs b/src/store-api/src/metadata.rs
index d75caa4ace..4c4b2f3fb9 100644
--- a/src/store-api/src/metadata.rs
+++ b/src/store-api/src/metadata.rs
@@ -818,7 +818,7 @@ impl RegionMetadataBuilder {
                     .column_schema
                     .fulltext_options()
                     .with_context(|_| GetFulltextOptionsSnafu {
-                        column_name: column_name.to_string(),
+                        column_name: column_name.clone(),
                     })?;
                 set_column_fulltext_options(
                     column_metadata,
@@ -859,7 +859,7 @@ impl RegionMetadataBuilder {
                     .column_schema
                     .fulltext_options()
                     .with_context(|_| GetFulltextOptionsSnafu {
-                        column_name: column_name.to_string(),
+                        column_name: column_name.clone(),
                     })?;
 
                 unset_column_fulltext_options(
diff --git a/src/store-api/src/region_request.rs b/src/store-api/src/region_request.rs
index c44a225d6c..009cb4eeaf 100644
--- a/src/store-api/src/region_request.rs
+++ b/src/store-api/src/region_request.rs
@@ -1261,7 +1261,7 @@ impl TryFrom<&PbOption> for SetRegionOption {
                 Ok(Self::Ttl(Some(ttl)))
             }
             TWCS_TRIGGER_FILE_NUM | TWCS_MAX_OUTPUT_FILE_SIZE | TWCS_TIME_WINDOW => {
-                Ok(Self::Twsc(key.to_string(), value.to_string()))
+                Ok(Self::Twsc(key.clone(), value.clone()))
             }
             _ => InvalidSetRegionOptionRequestSnafu { key, value }.fail(),
         }
diff --git a/src/table/src/lib.rs b/src/table/src/lib.rs
index 5fb800ab3c..64e72029b8 100644
--- a/src/table/src/lib.rs
+++ b/src/table/src/lib.rs
@@ -14,7 +14,6 @@
 
 #![feature(assert_matches)]
 #![feature(try_blocks)]
-#![feature(let_chains)]
 
 pub mod dist_table;
 pub mod error;
diff --git a/src/table/src/metadata.rs b/src/table/src/metadata.rs
index d824afc1da..07d646ff21 100644
--- a/src/table/src/metadata.rs
+++ b/src/table/src/metadata.rs
@@ -271,9 +271,7 @@ impl TableMeta {
                 }
                 SetRegionOption::Twsc(key, value) => {
                     if !value.is_empty() {
-                        new_options
-                            .extra_options
-                            .insert(key.to_string(), value.to_string());
+                        new_options.extra_options.insert(key.clone(), value.clone());
                         // Ensure node restart correctly.
                         new_options.extra_options.insert(
                             COMPACTION_TYPE.to_string(),
@@ -1291,7 +1289,7 @@ impl RawTableInfo {
     }
 
     /// Returns the table reference.
-    pub fn table_ref(&self) -> TableReference {
+    pub fn table_ref(&self) -> TableReference<'_> {
         TableReference::full(
             self.catalog_name.as_str(),
             self.schema_name.as_str(),
diff --git a/src/table/src/requests.rs b/src/table/src/requests.rs
index 8f64f0b9fc..2418c4a2c5 100644
--- a/src/table/src/requests.rs
+++ b/src/table/src/requests.rs
@@ -424,7 +424,7 @@ pub struct TruncateTableRequest {
 }
 
 impl TruncateTableRequest {
-    pub fn table_ref(&self) -> TableReference {
+    pub fn table_ref(&self) -> TableReference<'_> {
         TableReference {
             catalog: &self.catalog_name,
             schema: &self.schema_name,
diff --git a/src/table/src/table.rs b/src/table/src/table.rs
index a42edacfaf..ce36544b73 100644
--- a/src/table/src/table.rs
+++ b/src/table/src/table.rs
@@ -184,7 +184,7 @@ fn collect_column_defaults(column_schemas: &[ColumnSchema]) -> HashMap<String, E
                 column_schema.default_constraint()?,
                 &column_schema.data_type,
             )
-            .map(|expr| (column_schema.name.to_string(), expr))
+            .map(|expr| (column_schema.name.clone(), expr))
         })
         .collect()
 }
@@ -226,7 +226,7 @@ mod tests {
 
     #[test]
     fn test_collect_columns_defaults() {
-        let column_schemas = vec![
+        let column_schemas = [
             ColumnSchema::new("col1", ConcreteDataType::int32_datatype(), false),
             ColumnSchema::new("col2", ConcreteDataType::string_datatype(), true)
                 .with_default_constraint(Some(ColumnDefaultConstraint::Value("test".into())))
diff --git a/src/table/src/table/metrics.rs b/src/table/src/table/metrics.rs
index 5fbdf641f5..23356a408d 100644
--- a/src/table/src/table/metrics.rs
+++ b/src/table/src/table/metrics.rs
@@ -66,7 +66,7 @@ impl StreamMetrics {
     }
 
     /// Return a timer guard that records the time elapsed in poll
-    pub fn poll_timer(&self) -> ScopedTimerGuard {
+    pub fn poll_timer(&self) -> ScopedTimerGuard<'_> {
         self.poll_elapsed.timer()
     }
 
diff --git a/tests-fuzz/src/generator/create_expr.rs b/tests-fuzz/src/generator/create_expr.rs
index 6aee3e6251..e9c43955eb 100644
--- a/tests-fuzz/src/generator/create_expr.rs
+++ b/tests-fuzz/src/generator/create_expr.rs
@@ -160,7 +160,7 @@ impl<R: Rng + 'static> Generator<CreateTableExpr, R> for CreateTableExprGenerato
 
         builder.columns(columns);
         builder.primary_keys(primary_keys);
-        builder.engine(self.engine.to_string());
+        builder.engine(self.engine.clone());
         builder.if_not_exists(self.if_not_exists);
         if self.name.is_empty() {
             builder.table_name(self.name_generator.generate(rng));
@@ -170,7 +170,7 @@ impl<R: Rng + 'static> Generator<CreateTableExpr, R> for CreateTableExprGenerato
         if !self.with_clause.is_empty() {
             let mut options = HashMap::new();
             for (key, value) in &self.with_clause {
-                options.insert(key.to_string(), Value::from(value.to_string()));
+                options.insert(key.clone(), Value::from(value.clone()));
             }
             builder.options(options);
         }
@@ -239,7 +239,7 @@ impl<R: Rng + 'static> Generator<CreateTableExpr, R> for CreatePhysicalTableExpr
         let mut options = HashMap::with_capacity(self.with_clause.len() + 1);
         options.insert("physical_metric_table".to_string(), Value::from(""));
         for (key, value) in &self.with_clause {
-            options.insert(key.to_string(), Value::from(value.to_string()));
+            options.insert(key.clone(), Value::from(value.clone()));
         }
 
         Ok(CreateTableExpr {
@@ -357,7 +357,7 @@ impl<R: Rng + 'static> Generator<CreateDatabaseExpr, R> for CreateDatabaseExprGe
         if self.database_name.is_empty() {
             builder.database_name(self.name_generator.generate(rng));
         } else {
-            builder.database_name(self.database_name.to_string());
+            builder.database_name(self.database_name.clone());
         }
         builder.build().context(error::BuildCreateDatabaseExprSnafu)
     }
@@ -451,7 +451,7 @@ mod tests {
         let physical_ts_name = physical_table_expr.columns[physical_ts.unwrap()]
             .name
             .value
-            .to_string();
+            .clone();
 
         let physical_table_ctx = Arc::new(TableContext::from(&physical_table_expr));
 
@@ -472,7 +472,7 @@ mod tests {
         let logical_ts_name = logical_table_expr.columns[logical_ts.unwrap()]
             .name
             .value
-            .to_string();
+            .clone();
 
         assert_eq!(logical_table_expr.engine, "metric");
         assert_eq!(logical_table_expr.columns.len(), 7);
diff --git a/tests-fuzz/src/ir.rs b/tests-fuzz/src/ir.rs
index 7be697ab69..ad49ea8a4c 100644
--- a/tests-fuzz/src/ir.rs
+++ b/tests-fuzz/src/ir.rs
@@ -552,7 +552,6 @@ pub fn format_columns(columns: &[Column]) -> String {
         .map(|c| c.name.to_string())
         .collect::<Vec<_>>()
         .join(", ")
-        .to_string()
 }
 
 #[cfg(test)]
diff --git a/tests-fuzz/src/translator/mysql/insert_expr.rs b/tests-fuzz/src/translator/mysql/insert_expr.rs
index 480395aede..77529182df 100644
--- a/tests-fuzz/src/translator/mysql/insert_expr.rs
+++ b/tests-fuzz/src/translator/mysql/insert_expr.rs
@@ -41,8 +41,7 @@ impl InsertIntoExprTranslator {
                 .iter()
                 .map(|c| c.name.to_string())
                 .collect::<Vec<_>>()
-                .join(", ")
-                .to_string();
+                .join(", ");
 
             format!("({})", list)
         }
diff --git a/tests-fuzz/src/translator/mysql/select_expr.rs b/tests-fuzz/src/translator/mysql/select_expr.rs
index bc68440ec8..9d101d443e 100644
--- a/tests-fuzz/src/translator/mysql/select_expr.rs
+++ b/tests-fuzz/src/translator/mysql/select_expr.rs
@@ -27,16 +27,14 @@ impl DslTranslator<SelectExpr, String> for SelectExprTranslator {
             .iter()
             .map(|c| c.name.to_string())
             .collect::<Vec<_>>()
-            .join(", ")
-            .to_string();
+            .join(", ");
 
         let order_by = input
             .order_by
             .iter()
             .map(|c| c.as_str())
             .collect::<Vec<_>>()
-            .join(", ")
-            .to_string();
+            .join(", ");
 
         Ok(format!(
             "SELECT {} FROM {} ORDER BY {} {};",
diff --git a/tests-fuzz/src/utils/partition.rs b/tests-fuzz/src/utils/partition.rs
index 197a51d00a..d3dc30061d 100644
--- a/tests-fuzz/src/utils/partition.rs
+++ b/tests-fuzz/src/utils/partition.rs
@@ -60,7 +60,7 @@ pub async fn fetch_partitions(db: &MySqlPool, table_name: Ident) -> Result<Vec<P
 from information_schema.partitions a left join information_schema.region_peers b
 on a.greptime_partition_id = b.region_id where a.table_name= ? order by datanode_id asc;";
     sqlx::query_as::<_, Partition>(sql)
-        .bind(table_name.value.to_string())
+        .bind(table_name.value.clone())
         .fetch_all(db)
         .await
         .context(error::ExecuteQuerySnafu { sql })
diff --git a/tests-fuzz/src/validator/column.rs b/tests-fuzz/src/validator/column.rs
index 29e08a24c2..d092d892e9 100644
--- a/tests-fuzz/src/validator/column.rs
+++ b/tests-fuzz/src/validator/column.rs
@@ -85,7 +85,7 @@ impl PartialEq<Column> for ColumnEntry {
                 }
                 let default_value = match default_value_opt.unwrap() {
                     ColumnOption::DefaultValue(v) => v.to_string(),
-                    ColumnOption::DefaultFn(f) => f.to_string(),
+                    ColumnOption::DefaultFn(f) => f.clone(),
                     _ => unreachable!(),
                 };
                 if &default_value != value {
@@ -204,8 +204,8 @@ pub async fn fetch_columns(
 ) -> Result<Vec<ColumnEntry>> {
     let sql = "SELECT table_schema, table_name, column_name, greptime_data_type as data_type, semantic_type, column_default, is_nullable FROM information_schema.columns WHERE table_schema = ? AND table_name = ?";
     sqlx::query_as::<_, ColumnEntry>(sql)
-        .bind(schema_name.value.to_string())
-        .bind(table_name.value.to_string())
+        .bind(schema_name.value.clone())
+        .bind(table_name.value.clone())
         .fetch_all(db)
         .await
         .context(error::ExecuteQuerySnafu { sql })
diff --git a/tests-fuzz/targets/fuzz_insert.rs b/tests-fuzz/targets/fuzz_insert.rs
index 3756782d42..61fac8c50f 100644
--- a/tests-fuzz/targets/fuzz_insert.rs
+++ b/tests-fuzz/targets/fuzz_insert.rs
@@ -180,16 +180,14 @@ async fn execute_insert(ctx: FuzzContext, input: FuzzInput) -> Result<()> {
         .iter()
         .map(|&i| insert_expr.columns[i].name.to_string())
         .collect::<Vec<_>>()
-        .join(", ")
-        .to_string();
+        .join(", ");
 
     let column_list = insert_expr
         .columns
         .iter()
         .map(|c| c.name.to_string())
         .collect::<Vec<_>>()
-        .join(", ")
-        .to_string();
+        .join(", ");
 
     let select_sql = format!(
         "SELECT {} FROM {} ORDER BY {}",
diff --git a/tests-fuzz/targets/fuzz_insert_logical_table.rs b/tests-fuzz/targets/fuzz_insert_logical_table.rs
index b5594ded4a..cb87f07c87 100644
--- a/tests-fuzz/targets/fuzz_insert_logical_table.rs
+++ b/tests-fuzz/targets/fuzz_insert_logical_table.rs
@@ -174,16 +174,14 @@ async fn validate_values(
         .iter()
         .map(|&i| insert_expr.columns[i].name.to_string())
         .collect::<Vec<_>>()
-        .join(", ")
-        .to_string();
+        .join(", ");
 
     let column_list = insert_expr
         .columns
         .iter()
         .map(|c| c.name.to_string())
         .collect::<Vec<_>>()
-        .join(", ")
-        .to_string();
+        .join(", ");
 
     let select_sql = format!(
         "SELECT {} FROM {} ORDER BY {}",
diff --git a/tests-fuzz/targets/migration/fuzz_migrate_mito_regions.rs b/tests-fuzz/targets/migration/fuzz_migrate_mito_regions.rs
index a5ab0ad856..882a79bfb5 100644
--- a/tests-fuzz/targets/migration/fuzz_migrate_mito_regions.rs
+++ b/tests-fuzz/targets/migration/fuzz_migrate_mito_regions.rs
@@ -247,7 +247,7 @@ async fn migrate_regions(ctx: &FuzzContext, migrations: &[Migration]) -> Result<
             Duration::from_secs(240),
             || {
                 let greptime = ctx.greptime.clone();
-                let procedure_id = procedure_id.to_string();
+                let procedure_id = procedure_id.clone();
                 Box::pin(async move {
                     {
                         let output = procedure_state(&greptime, &procedure_id).await;
diff --git a/tests-integration/src/grpc/flight.rs b/tests-integration/src/grpc/flight.rs
index af940f069c..aa0d2356ff 100644
--- a/tests-integration/src/grpc/flight.rs
+++ b/tests-integration/src/grpc/flight.rs
@@ -89,10 +89,7 @@ mod test {
         let runtime = common_runtime::global_runtime().clone();
         let greptime_request_handler = GreptimeRequestHandler::new(
             ServerGrpcQueryHandlerAdapter::arc(db.frontend.instance.clone()),
-            user_provider_from_option(
-                &"static_user_provider:cmd:greptime_user=greptime_pwd".to_string(),
-            )
-            .ok(),
+            user_provider_from_option("static_user_provider:cmd:greptime_user=greptime_pwd").ok(),
             Some(runtime.clone()),
             FlightCompression::default(),
         );
diff --git a/tests-integration/src/grpc/network.rs b/tests-integration/src/grpc/network.rs
index 625597cc59..afe1ae05d5 100644
--- a/tests-integration/src/grpc/network.rs
+++ b/tests-integration/src/grpc/network.rs
@@ -12,126 +12,126 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use futures_util::future::BoxFuture;
-use http::Uri;
-use hyper_util::rt::TokioIo;
-use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-use tokio::net::TcpStream;
-use tokio::sync::mpsc;
-use tower::Service;
-
-struct NetworkTrafficMonitorableConnector {
-    interested_tx: mpsc::Sender<String>,
-}
-
-impl Service<Uri> for NetworkTrafficMonitorableConnector {
-    type Response = TokioIo<CollectGrpcResponseFrameTypeStream>;
-    type Error = String;
-    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
-
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, uri: Uri) -> Self::Future {
-        let frame_types = self.interested_tx.clone();
-
-        Box::pin(async move {
-            let addr = format!(
-                "{}:{}",
-                uri.host().unwrap_or("localhost"),
-                uri.port_u16().unwrap_or(4001),
-            );
-            let inner = TcpStream::connect(addr).await.map_err(|e| e.to_string())?;
-            Ok(TokioIo::new(CollectGrpcResponseFrameTypeStream {
-                inner,
-                frame_types,
-            }))
-        })
-    }
-}
-
-struct CollectGrpcResponseFrameTypeStream {
-    inner: TcpStream,
-    frame_types: mpsc::Sender<String>,
-}
-
-impl AsyncRead for CollectGrpcResponseFrameTypeStream {
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        let before_len = buf.filled().len();
-
-        let result = Pin::new(&mut self.inner).poll_read(cx, buf);
-        if let Poll::Ready(Ok(())) = &result {
-            let after_len = buf.filled().len();
-
-            let new_data = &buf.filled()[before_len..after_len];
-            if let Some(frame_type) = maybe_decode_frame_type(new_data)
-                && let Err(_) = self.frame_types.try_send(frame_type.to_string())
-            {
-                return Poll::Ready(Err(io::Error::other("interested party has gone")));
-            }
-        }
-        result
-    }
-}
-
-fn maybe_decode_frame_type(data: &[u8]) -> Option<&str> {
-    (data.len() >= 9).then(|| match data[3] {
-        0x0 => "DATA",
-        0x1 => "HEADERS",
-        0x2 => "PRIORITY",
-        0x3 => "RST_STREAM",
-        0x4 => "SETTINGS",
-        0x5 => "PUSH_PROMISE",
-        0x6 => "PING",
-        0x7 => "GOAWAY",
-        0x8 => "WINDOW_UPDATE",
-        0x9 => "CONTINUATION",
-        _ => "UNKNOWN",
-    })
-}
-
-impl AsyncWrite for CollectGrpcResponseFrameTypeStream {
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<Result<usize, io::Error>> {
-        Pin::new(&mut self.inner).poll_write(cx, buf)
-    }
-
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
-        Pin::new(&mut self.inner).poll_flush(cx)
-    }
-
-    fn poll_shutdown(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<(), io::Error>> {
-        Pin::new(&mut self.inner).poll_shutdown(cx)
-    }
-}
-
 #[cfg(test)]
 mod tests {
+    use std::io;
+    use std::pin::Pin;
+    use std::task::{Context, Poll};
     use std::time::Duration;
 
     use client::Client;
     use common_grpc::channel_manager::ChannelManager;
+    use futures_util::future::BoxFuture;
+    use http::Uri;
+    use hyper_util::rt::TokioIo;
     use servers::grpc::GrpcServerConfig;
     use servers::server::Server;
+    use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+    use tokio::net::TcpStream;
+    use tokio::sync::mpsc;
+    use tower::Service;
 
-    use super::*;
     use crate::test_util::{StorageType, setup_grpc_server_with};
 
+    struct NetworkTrafficMonitorableConnector {
+        interested_tx: mpsc::Sender<String>,
+    }
+
+    impl Service<Uri> for NetworkTrafficMonitorableConnector {
+        type Response = TokioIo<CollectGrpcResponseFrameTypeStream>;
+        type Error = String;
+        type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
+
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+
+        fn call(&mut self, uri: Uri) -> Self::Future {
+            let frame_types = self.interested_tx.clone();
+
+            Box::pin(async move {
+                let addr = format!(
+                    "{}:{}",
+                    uri.host().unwrap_or("localhost"),
+                    uri.port_u16().unwrap_or(4001),
+                );
+                let inner = TcpStream::connect(addr).await.map_err(|e| e.to_string())?;
+                Ok(TokioIo::new(CollectGrpcResponseFrameTypeStream {
+                    inner,
+                    frame_types,
+                }))
+            })
+        }
+    }
+
+    struct CollectGrpcResponseFrameTypeStream {
+        inner: TcpStream,
+        frame_types: mpsc::Sender<String>,
+    }
+
+    impl AsyncRead for CollectGrpcResponseFrameTypeStream {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            let before_len = buf.filled().len();
+
+            let result = Pin::new(&mut self.inner).poll_read(cx, buf);
+            if let Poll::Ready(Ok(())) = &result {
+                let after_len = buf.filled().len();
+
+                let new_data = &buf.filled()[before_len..after_len];
+                if let Some(frame_type) = maybe_decode_frame_type(new_data)
+                    && let Err(_) = self.frame_types.try_send(frame_type.to_string())
+                {
+                    return Poll::Ready(Err(io::Error::other("interested party has gone")));
+                }
+            }
+            result
+        }
+    }
+
+    fn maybe_decode_frame_type(data: &[u8]) -> Option<&str> {
+        (data.len() >= 9).then(|| match data[3] {
+            0x0 => "DATA",
+            0x1 => "HEADERS",
+            0x2 => "PRIORITY",
+            0x3 => "RST_STREAM",
+            0x4 => "SETTINGS",
+            0x5 => "PUSH_PROMISE",
+            0x6 => "PING",
+            0x7 => "GOAWAY",
+            0x8 => "WINDOW_UPDATE",
+            0x9 => "CONTINUATION",
+            _ => "UNKNOWN",
+        })
+    }
+
+    impl AsyncWrite for CollectGrpcResponseFrameTypeStream {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            buf: &[u8],
+        ) -> Poll<Result<usize, io::Error>> {
+            Pin::new(&mut self.inner).poll_write(cx, buf)
+        }
+
+        fn poll_flush(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+        ) -> Poll<Result<(), io::Error>> {
+            Pin::new(&mut self.inner).poll_flush(cx)
+        }
+
+        fn poll_shutdown(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+        ) -> Poll<Result<(), io::Error>> {
+            Pin::new(&mut self.inner).poll_shutdown(cx)
+        }
+    }
+
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
     async fn test_grpc_max_connection_age() {
         let config = GrpcServerConfig {
diff --git a/tests-integration/src/influxdb.rs b/tests-integration/src/influxdb.rs
index e0eb7192c6..c047cc4c01 100644
--- a/tests-integration/src/influxdb.rs
+++ b/tests-integration/src/influxdb.rs
@@ -17,7 +17,9 @@ mod test {
     use std::sync::Arc;
 
     use client::OutputData;
+    use common_grpc::precision::Precision;
     use common_recordbatch::RecordBatches;
+    use common_test_util::recordbatch::check_output_stream;
     use rstest::rstest;
     use rstest_reuse::apply;
     use servers::influxdb::InfluxdbRequest;
@@ -110,19 +112,95 @@ monitor1,host=host2 cpu=32 1663840496400340001";
             )
             .await;
         let output = output.remove(0).unwrap();
-        let OutputData::Stream(stream) = output.data else {
-            unreachable!()
-        };
-        let recordbatches = RecordBatches::try_collect(stream).await.unwrap();
-        assert_eq!(
-            recordbatches.pretty_print().unwrap(),
-            "\
+        let expected = "\
 +-------------------------------+-------+------+--------+
 | greptime_timestamp            | host  | cpu  | memory |
 +-------------------------------+-------+------+--------+
 | 2022-09-22T09:54:56.100023100 | host1 | 66.6 | 1024.0 |
 | 2022-09-22T09:54:56.400340001 | host2 | 32.0 | 1027.0 |
-+-------------------------------+-------+------+--------+"
-        );
++-------------------------------+-------+------+--------+";
+        check_output_stream(output.data, expected).await;
+    }
+
+    #[apply(both_instances_cases)]
+    async fn test_put_influxdb_lines_with_auto_aligning_timestamps(
+        instance: Arc<dyn MockInstance>,
+    ) {
+        let instance = instance.frontend();
+
+        // First create a table with millisecond time index.
+        let sql = "create table monitor (
+                    ts timestamp time index,
+                    host string primary key,
+                    cpu double,
+                    memory double,
+                )";
+        instance.do_query(sql, QueryContext::arc()).await;
+
+        // Insert some influxdb lines with millisecond precision.
+        let lines = r"
+monitor,host=127.0.0.1 cpu=0.1,memory=1.0 1719460800001
+monitor,host=127.0.0.2 cpu=0.2,memory=2.0 1719460800002";
+        let request = InfluxdbRequest {
+            precision: Some(Precision::Millisecond),
+            lines: lines.to_string(),
+        };
+        instance.exec(request, QueryContext::arc()).await.unwrap();
+
+        // Insert some influxdb lines without precision.
+        // According to the specification (both v1 and v2), if precision is not set, it is default
+        // to "nanosecond". The lines here will be converted to insert requests as usual and then
+        // be aligned to millisecond time unit.
+        let lines = r"
+monitor,host=127.0.0.1 cpu=0.3,memory=3.0 1719460800003000000
+monitor,host=127.0.0.2 cpu=0.4,memory=4.0 1719460800004000000";
+        let request = InfluxdbRequest {
+            precision: None,
+            lines: lines.to_string(),
+        };
+        instance.exec(request, QueryContext::arc()).await.unwrap();
+
+        // Insert other influxdb lines with nanosecond precision.
+        let lines = r"
+monitor,host=127.0.0.1 cpu=0.5,memory=5.0 1719460800005000000
+monitor,host=127.0.0.2 cpu=0.6,memory=6.0 1719460800006000000";
+        let request = InfluxdbRequest {
+            precision: Some(Precision::Nanosecond),
+            lines: lines.to_string(),
+        };
+        instance.exec(request, QueryContext::arc()).await.unwrap();
+
+        // Insert other influxdb lines with second precision.
+        let lines = r"
+monitor,host=127.0.0.1 cpu=0.7,memory=7.0 1719460801
+monitor,host=127.0.0.2 cpu=0.8,memory=8.0 1719460802";
+        let request = InfluxdbRequest {
+            precision: Some(Precision::Second),
+            lines: lines.to_string(),
+        };
+        instance.exec(request, QueryContext::arc()).await.unwrap();
+
+        // Check the data.
+        let mut output = instance
+            .do_query(
+                "SELECT ts, host, cpu, memory FROM monitor ORDER BY ts",
+                QueryContext::arc(),
+            )
+            .await;
+        let output = output.remove(0).unwrap();
+        let expected = "\
++-------------------------+-----------+-----+--------+
+| ts                      | host      | cpu | memory |
++-------------------------+-----------+-----+--------+
+| 2024-06-27T04:00:00.001 | 127.0.0.1 | 0.1 | 1.0    |
+| 2024-06-27T04:00:00.002 | 127.0.0.2 | 0.2 | 2.0    |
+| 2024-06-27T04:00:00.003 | 127.0.0.1 | 0.3 | 3.0    |
+| 2024-06-27T04:00:00.004 | 127.0.0.2 | 0.4 | 4.0    |
+| 2024-06-27T04:00:00.005 | 127.0.0.1 | 0.5 | 5.0    |
+| 2024-06-27T04:00:00.006 | 127.0.0.2 | 0.6 | 6.0    |
+| 2024-06-27T04:00:01     | 127.0.0.1 | 0.7 | 7.0    |
+| 2024-06-27T04:00:02     | 127.0.0.2 | 0.8 | 8.0    |
++-------------------------+-----------+-----+--------+";
+        check_output_stream(output.data, expected).await;
     }
 }
diff --git a/tests-integration/src/tests/promql_test.rs b/tests-integration/src/tests/promql_test.rs
index c8d1f6597a..3c8f8d8f33 100644
--- a/tests-integration/src/tests/promql_test.rs
+++ b/tests-integration/src/tests/promql_test.rs
@@ -32,6 +32,7 @@ use crate::tests::test_util::MockInstance;
 async fn promql_query(
     ins: Arc<Instance>,
     promql: &str,
+    alias: Option<String>,
     query_ctx: Arc<QueryContext>,
     start: SystemTime,
     end: SystemTime,
@@ -40,9 +41,10 @@ async fn promql_query(
 ) -> operator::error::Result<Output> {
     let query = PromQuery {
         query: promql.to_string(),
+        alias,
         ..PromQuery::default()
     };
-    let QueryStatement::Promql(mut eval_stmt) =
+    let QueryStatement::Promql(mut eval_stmt, alias) =
         QueryLanguageParser::parse_promql(&query, &query_ctx).unwrap()
     else {
         unreachable!()
@@ -53,7 +55,7 @@ async fn promql_query(
     eval_stmt.lookback_delta = lookback;
 
     ins.statement_executor()
-        .execute_stmt(QueryStatement::Promql(eval_stmt), query_ctx)
+        .execute_stmt(QueryStatement::Promql(eval_stmt, alias), query_ctx)
         .await
 }
 
@@ -68,6 +70,25 @@ async fn create_insert_query_assert(
     interval: Duration,
     lookback: Duration,
     expected: &str,
+) {
+    create_insert_query_assert_with_alias(
+        instance, create, insert, promql, None, start, end, interval, lookback, expected,
+    )
+    .await
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn create_insert_query_assert_with_alias(
+    instance: Arc<Instance>,
+    create: &str,
+    insert: &str,
+    promql: &str,
+    alias: Option<String>,
+    start: SystemTime,
+    end: SystemTime,
+    interval: Duration,
+    lookback: Duration,
+    expected: &str,
 ) {
     instance
         .do_query(create, QueryContext::arc())
@@ -87,6 +108,7 @@ async fn create_insert_query_assert(
     let query_output = promql_query(
         instance,
         promql,
+        alias,
         QueryContext::arc(),
         start,
         end,
@@ -335,6 +357,31 @@ async fn aggregators_simple_count(instance: Arc<dyn MockInstance>) {
     .await;
 }
 
+// Test like `aggregators_simple_count` but with value aliasing.
+#[apply(both_instances_cases)]
+async fn value_alias(instance: Arc<dyn MockInstance>) {
+    let instance = instance.frontend();
+
+    create_insert_query_assert_with_alias(
+        instance,
+        AGGREGATORS_CREATE_TABLE,
+        AGGREGATORS_INSERT_DATA,
+        "COUNT BY (group) (http_requests{job=\"api-server\"})",
+        Some("my_series".to_string()),
+        UNIX_EPOCH,
+        unix_epoch_plus_100s(),
+        Duration::from_secs(60),
+        Duration::from_secs(0),
+        "+-----------+------------+---------------------+\
+        \n| my_series | group      | ts                  |\
+        \n+-----------+------------+---------------------+\
+        \n| 2         | canary     | 1970-01-01T00:00:00 |\
+        \n| 2         | production | 1970-01-01T00:00:00 |\
+        \n+-----------+------------+---------------------+",
+    )
+    .await;
+}
+
 // # Simple without.
 // eval instant at 50m sum without (instance) (http_requests{job="api-server"})
 //   {group="canary",job="api-server"} 700
@@ -578,6 +625,7 @@ async fn cross_schema_query(instance: Arc<dyn MockInstance>) {
     let query_output = promql_query(
         ins.clone(),
         r#"http_requests{__schema__="greptime_private"}"#,
+        None,
         QueryContext::arc(),
         start,
         end,
@@ -605,6 +653,7 @@ async fn cross_schema_query(instance: Arc<dyn MockInstance>) {
     let query_output = promql_query(
         ins.clone(),
         r#"http_requests{__database__="greptime_private"}"#,
+        None,
         QueryContext::arc(),
         start,
         end,
@@ -632,6 +681,7 @@ async fn cross_schema_query(instance: Arc<dyn MockInstance>) {
     let query_output = promql_query(
         ins.clone(),
         r#"http_requests"#,
+        None,
         QueryContext::arc(),
         start,
         end,
@@ -649,6 +699,7 @@ async fn cross_schema_query(instance: Arc<dyn MockInstance>) {
     let query_output = promql_query(
         ins.clone(),
         r#"http_requests"#,
+        None,
         QueryContext::with_db_name(Some("greptime_private")).into(),
         start,
         end,
diff --git a/tests-integration/src/tests/test_util.rs b/tests-integration/src/tests/test_util.rs
index 84efb2acf6..019ccd79e5 100644
--- a/tests-integration/src/tests/test_util.rs
+++ b/tests-integration/src/tests/test_util.rs
@@ -275,7 +275,7 @@ pub(crate) async fn standalone_with_kafka_wal() -> Option<Box<dyn RebuildableMoc
                 ..Default::default()
             },
             kafka_topic: KafkaTopicConfig {
-                topic_name_prefix: test_name.to_string(),
+                topic_name_prefix: test_name.clone(),
                 num_topics: 3,
                 ..Default::default()
             },
@@ -314,7 +314,7 @@ pub(crate) async fn distributed_with_kafka_wal() -> Option<Box<dyn RebuildableMo
                 ..Default::default()
             },
             kafka_topic: KafkaTopicConfig {
-                topic_name_prefix: test_name.to_string(),
+                topic_name_prefix: test_name.clone(),
                 num_topics: 3,
                 ..Default::default()
             },
diff --git a/tests-integration/tests/grpc.rs b/tests-integration/tests/grpc.rs
index f359c45ff9..b9e56564a5 100644
--- a/tests-integration/tests/grpc.rs
+++ b/tests-integration/tests/grpc.rs
@@ -229,10 +229,8 @@ pub async fn test_grpc_message_size_limit_recv(store_type: StorageType) {
 }
 
 pub async fn test_grpc_auth(store_type: StorageType) {
-    let user_provider = user_provider_from_option(
-        &"static_user_provider:cmd:greptime_user=greptime_pwd".to_string(),
-    )
-    .unwrap();
+    let user_provider =
+        user_provider_from_option("static_user_provider:cmd:greptime_user=greptime_pwd").unwrap();
     let (_db, fe_grpc_server) =
         setup_grpc_server_with_user_provider(store_type, "auto_create_table", Some(user_provider))
             .await;
@@ -282,10 +280,8 @@ pub async fn test_grpc_auth(store_type: StorageType) {
 }
 
 pub async fn test_otel_arrow_auth(store_type: StorageType) {
-    let user_provider = user_provider_from_option(
-        &"static_user_provider:cmd:greptime_user=greptime_pwd".to_string(),
-    )
-    .unwrap();
+    let user_provider =
+        user_provider_from_option("static_user_provider:cmd:greptime_user=greptime_pwd").unwrap();
     let (_db, fe_grpc_server) = setup_grpc_server_with_user_provider(
         store_type,
         "test_otel_arrow_auth",
diff --git a/tests-integration/tests/http.rs b/tests-integration/tests/http.rs
index c3b0a86885..347a8d12c9 100644
--- a/tests-integration/tests/http.rs
+++ b/tests-integration/tests/http.rs
@@ -150,7 +150,7 @@ pub async fn test_http_auth(store_type: StorageType) {
     common_telemetry::init_default_ut_logging();
 
     let user_provider = user_provider_from_option(
-        &"static_user_provider:cmd:greptime_user=greptime_pwd,readonly_user:ro=readonly_pwd,writeonly_user:wo=writeonly_pwd".to_string(),
+        "static_user_provider:cmd:greptime_user=greptime_pwd,readonly_user:ro=readonly_pwd,writeonly_user:wo=writeonly_pwd",
     )
     .unwrap();
 
diff --git a/tests-integration/tests/sql.rs b/tests-integration/tests/sql.rs
index fb537876ce..bacafc5380 100644
--- a/tests-integration/tests/sql.rs
+++ b/tests-integration/tests/sql.rs
@@ -88,7 +88,7 @@ macro_rules! sql_tests {
 
 pub async fn test_mysql_auth(store_type: StorageType) {
     let user_provider = user_provider_from_option(
-        &"static_user_provider:cmd:greptime_user=greptime_pwd,readonly_user:ro=readonly_pwd,writeonly_user:wo=writeonly_pwd".to_string(),
+        "static_user_provider:cmd:greptime_user=greptime_pwd,readonly_user:ro=readonly_pwd,writeonly_user:wo=writeonly_pwd",
     )
     .unwrap();
 
@@ -463,10 +463,8 @@ pub async fn test_mysql_timezone(store_type: StorageType) {
 }
 
 pub async fn test_postgres_auth(store_type: StorageType) {
-    let user_provider = user_provider_from_option(
-        &"static_user_provider:cmd:greptime_user=greptime_pwd".to_string(),
-    )
-    .unwrap();
+    let user_provider =
+        user_provider_from_option("static_user_provider:cmd:greptime_user=greptime_pwd").unwrap();
 
     let (mut guard, fe_pg_server) =
         setup_pg_server_with_user_provider(store_type, "sql_crud", Some(user_provider)).await;
@@ -1185,7 +1183,7 @@ pub async fn test_mysql_async_timestamp(store_type: StorageType) {
     .await
     .expect("create table failure");
 
-    let metrics = vec![
+    let metrics = [
         CpuMetric::new(
             "host0".into(),
             "test".into(),
diff --git a/tests/README.md b/tests/README.md
index ae2d42d9c5..98435399ad 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -32,7 +32,7 @@ To run test with kafka, you need to pass the option `-w kafka`. If no other opti
 Otherwise, you can additionally pass the your existing kafka environment to sqlness with `-k` option. E.g.:
 
 ```shell
-cargo sqlness -w kafka -k localhost:9092
+cargo sqlness bare -w kafka -k localhost:9092
 ```
 
 In this case, sqlness will not start its own kafka cluster and the one you provided instead.
@@ -42,7 +42,7 @@ In this case, sqlness will not start its own kafka cluster and the one you provi
 Unlike other tests, this harness is in a binary target form. You can run it with:
 
 ```shell
-cargo sqlness
+cargo sqlness bare
 ```
 
 It automatically finishes the following procedures: compile `GreptimeDB`, start it, grab tests and feed it to
diff --git a/tests/cases/standalone/common/tql-explain-analyze/explain.result b/tests/cases/standalone/common/tql-explain-analyze/explain.result
index 3ef82f9806..33cd57b327 100644
--- a/tests/cases/standalone/common/tql-explain-analyze/explain.result
+++ b/tests/cases/standalone/common/tql-explain-analyze/explain.result
@@ -205,6 +205,143 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test;
 |_|_|
 +-+-+
 
+-- explain verbose at 0s, 5s and 10s. No point at 0s.
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+-- SQLNESS REPLACE (elapsed_compute.*) REDACTED
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
+TQL EXPLAIN VERBOSE (0, 10, '5s') test AS series;
+
++-+-+
+| plan_type_| plan_|
++-+-+
+| initial_logical_plan_| PromInstantManipulate: range=[0..0], lookback=[300000], interval=[300000], time index=[j]_|
+|_|_PromSeriesDivide: tags=["k"]_|
+|_|_Sort: test.k ASC NULLS FIRST, test.j ASC NULLS FIRST_|
+|_|_Filter: test.j >= TimestampMillisecond(-300000, None) AND test.j <= TimestampMillisecond(300000, None)_|
+|_|_TableScan: test_|
+| logical_plan after count_wildcard_to_time_index_rule_| SAME TEXT AS ABOVE_|
+| logical_plan after StringNormalizationRule_| SAME TEXT AS ABOVE_|
+| logical_plan after TranscribeAtatRule_| SAME TEXT AS ABOVE_|
+| logical_plan after resolve_grouping_function_| SAME TEXT AS ABOVE_|
+| logical_plan after type_coercion_| SAME TEXT AS ABOVE_|
+| logical_plan after DistPlannerAnalyzer_| Projection: test.i, test.j, test.k_|
+|_|_MergeScan [is_placeholder=false, remote_input=[_|
+|_| PromInstantManipulate: range=[0..0], lookback=[300000], interval=[300000], time index=[j]_|
+|_|_PromSeriesDivide: tags=["k"]_|
+|_|_Sort: test.k ASC NULLS FIRST, test.j ASC NULLS FIRST_|
+|_|_Filter: test.j >= TimestampMillisecond(-300000, None) AND test.j <= TimestampMillisecond(300000, None)_|
+|_|_TableScan: test_|
+|_| ]]_|
+| logical_plan after FixStateUdafOrderingAnalyzer_| SAME TEXT AS ABOVE_|
+| analyzed_logical_plan_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_nested_union_| SAME TEXT AS ABOVE_|
+| logical_plan after simplify_expressions_| SAME TEXT AS ABOVE_|
+| logical_plan after replace_distinct_aggregate_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_join_| SAME TEXT AS ABOVE_|
+| logical_plan after decorrelate_predicate_subquery_| SAME TEXT AS ABOVE_|
+| logical_plan after scalar_subquery_to_join_| SAME TEXT AS ABOVE_|
+| logical_plan after decorrelate_lateral_join_| SAME TEXT AS ABOVE_|
+| logical_plan after extract_equijoin_predicate_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_duplicated_expr_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_filter_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_cross_join_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_limit_| SAME TEXT AS ABOVE_|
+| logical_plan after propagate_empty_relation_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_one_union_| SAME TEXT AS ABOVE_|
+| logical_plan after filter_null_join_keys_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_outer_join_| SAME TEXT AS ABOVE_|
+| logical_plan after push_down_limit_| SAME TEXT AS ABOVE_|
+| logical_plan after push_down_filter_| SAME TEXT AS ABOVE_|
+| logical_plan after single_distinct_aggregation_to_group_by | SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_group_by_constant_| SAME TEXT AS ABOVE_|
+| logical_plan after common_sub_expression_eliminate_| SAME TEXT AS ABOVE_|
+| logical_plan after optimize_projections_| MergeScan [is_placeholder=false, remote_input=[_|
+|_| PromInstantManipulate: range=[0..0], lookback=[300000], interval=[300000], time index=[j]_|
+|_|_PromSeriesDivide: tags=["k"]_|
+|_|_Sort: test.k ASC NULLS FIRST, test.j ASC NULLS FIRST_|
+|_|_Filter: test.j >= TimestampMillisecond(-300000, None) AND test.j <= TimestampMillisecond(300000, None)_|
+|_|_TableScan: test_|
+|_| ]]_|
+| logical_plan after ScanHintRule_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_nested_union_| SAME TEXT AS ABOVE_|
+| logical_plan after simplify_expressions_| SAME TEXT AS ABOVE_|
+| logical_plan after replace_distinct_aggregate_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_join_| SAME TEXT AS ABOVE_|
+| logical_plan after decorrelate_predicate_subquery_| SAME TEXT AS ABOVE_|
+| logical_plan after scalar_subquery_to_join_| SAME TEXT AS ABOVE_|
+| logical_plan after decorrelate_lateral_join_| SAME TEXT AS ABOVE_|
+| logical_plan after extract_equijoin_predicate_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_duplicated_expr_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_filter_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_cross_join_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_limit_| SAME TEXT AS ABOVE_|
+| logical_plan after propagate_empty_relation_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_one_union_| SAME TEXT AS ABOVE_|
+| logical_plan after filter_null_join_keys_| SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_outer_join_| SAME TEXT AS ABOVE_|
+| logical_plan after push_down_limit_| SAME TEXT AS ABOVE_|
+| logical_plan after push_down_filter_| SAME TEXT AS ABOVE_|
+| logical_plan after single_distinct_aggregation_to_group_by | SAME TEXT AS ABOVE_|
+| logical_plan after eliminate_group_by_constant_| SAME TEXT AS ABOVE_|
+| logical_plan after common_sub_expression_eliminate_| SAME TEXT AS ABOVE_|
+| logical_plan after optimize_projections_| SAME TEXT AS ABOVE_|
+| logical_plan after ScanHintRule_| SAME TEXT AS ABOVE_|
+| logical_plan_| MergeScan [is_placeholder=false, remote_input=[_|
+|_| PromInstantManipulate: range=[0..0], lookback=[300000], interval=[300000], time index=[j]_|
+|_|_PromSeriesDivide: tags=["k"]_|
+|_|_Sort: test.k ASC NULLS FIRST, test.j ASC NULLS FIRST_|
+|_|_Filter: test.j >= TimestampMillisecond(-300000, None) AND test.j <= TimestampMillisecond(300000, None)_|
+|_|_TableScan: test_|
+|_| ]]_|
+| initial_physical_plan_| MergeScanExec: REDACTED
+|_|_|
+| initial_physical_plan_with_stats_| MergeScanExec: REDACTED
+|_|_|
+| initial_physical_plan_with_schema_| MergeScanExec: REDACTED
+|_|_|
+| physical_plan after OutputRequirements_| OutputRequirementExec: order_by=[], dist_by=Unspecified_|
+|_|_MergeScanExec: REDACTED
+|_|_|
+| physical_plan after aggregate_statistics_| SAME TEXT AS ABOVE_|
+| physical_plan after join_selection_| SAME TEXT AS ABOVE_|
+| physical_plan after LimitedDistinctAggregation_| SAME TEXT AS ABOVE_|
+| physical_plan after FilterPushdown_| SAME TEXT AS ABOVE_|
+| physical_plan after parallelize_scan_| SAME TEXT AS ABOVE_|
+| physical_plan after PassDistributionRule_| SAME TEXT AS ABOVE_|
+| physical_plan after EnforceSorting_| SAME TEXT AS ABOVE_|
+| physical_plan after EnforceDistribution_| SAME TEXT AS ABOVE_|
+| physical_plan after CombinePartialFinalAggregate_| SAME TEXT AS ABOVE_|
+| physical_plan after EnforceSorting_| SAME TEXT AS ABOVE_|
+| physical_plan after OptimizeAggregateOrder_| SAME TEXT AS ABOVE_|
+| physical_plan after ProjectionPushdown_| SAME TEXT AS ABOVE_|
+| physical_plan after coalesce_batches_| SAME TEXT AS ABOVE_|
+| physical_plan after coalesce_async_exec_input_| SAME TEXT AS ABOVE_|
+| physical_plan after OutputRequirements_| MergeScanExec: REDACTED
+|_|_|
+| physical_plan after LimitAggregation_| SAME TEXT AS ABOVE_|
+| physical_plan after LimitPushdown_| SAME TEXT AS ABOVE_|
+| physical_plan after ProjectionPushdown_| SAME TEXT AS ABOVE_|
+| physical_plan after EnsureCooperative_| CooperativeExec_|
+|_|_MergeScanExec: REDACTED
+|_|_|
+| physical_plan after FilterPushdown(Post)_| SAME TEXT AS ABOVE_|
+| physical_plan after WindowedSortRule_| SAME TEXT AS ABOVE_|
+| physical_plan after MatchesConstantTerm_| SAME TEXT AS ABOVE_|
+| physical_plan after RemoveDuplicateRule_| SAME TEXT AS ABOVE_|
+| physical_plan after SanityCheckPlan_| SAME TEXT AS ABOVE_|
+| physical_plan_| CooperativeExec_|
+|_|_MergeScanExec: REDACTED
+|_|_|
+| physical_plan_with_stats_| CooperativeExec, statistics=[Rows=Absent, Bytes=Absent, [(Col[0]:),(Col[1]:),(Col[2]:)]]_|
+|_|_MergeScanExec: REDACTED
+|_|_|
+| physical_plan_with_schema_| CooperativeExec, schema=[i:Float64;N, j:Timestamp(Millisecond, None), k:Utf8;N]_|
+|_|_MergeScanExec: REDACTED
+|_|_|
++-+-+
+
 DROP TABLE test;
 
 Affected Rows: 0
diff --git a/tests/cases/standalone/common/tql-explain-analyze/explain.sql b/tests/cases/standalone/common/tql-explain-analyze/explain.sql
index cf5618496d..5e296d4b6b 100644
--- a/tests/cases/standalone/common/tql-explain-analyze/explain.sql
+++ b/tests/cases/standalone/common/tql-explain-analyze/explain.sql
@@ -27,4 +27,12 @@ TQL EXPLAIN ('1970-01-01T00:00:00'::timestamp, '1970-01-01T00:00:00'::timestamp
 -- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
 TQL EXPLAIN VERBOSE (0, 10, '5s') test;
 
+-- explain verbose at 0s, 5s and 10s. No point at 0s.
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+-- SQLNESS REPLACE (elapsed_compute.*) REDACTED
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
+TQL EXPLAIN VERBOSE (0, 10, '5s') test AS series;
+
 DROP TABLE test;
diff --git a/tests/cases/standalone/common/tql/basic.result b/tests/cases/standalone/common/tql/basic.result
index 5523b0bd4b..b6e7c0679d 100644
--- a/tests/cases/standalone/common/tql/basic.result
+++ b/tests/cases/standalone/common/tql/basic.result
@@ -32,6 +32,30 @@ TQL EVAL (0, 10, '5s') {__name__="test"};
 | 2.0 | 1970-01-01T00:00:10 | a |
 +-----+---------------------+---+
 
+-- SQLNESS SORT_RESULT 2 1
+TQL EVAL (0, 10, '5s') {__name__="test"} AS test_series;
+
++-------------+---+---------------------+
+| test_series | k | j                   |
++-------------+---+---------------------+
+| 1.0         | b | 1970-01-01T00:00:05 |
+| 1.0         | b | 1970-01-01T00:00:10 |
+| 2.0         | a | 1970-01-01T00:00:05 |
+| 2.0         | a | 1970-01-01T00:00:10 |
++-------------+---+---------------------+
+
+-- SQLNESS SORT_RESULT 2 1
+TQL EVAL (0, 10, '5s') count by (k) (test) AS c;
+
++---+---+---------------------+
+| c | k | j                   |
++---+---+---------------------+
+| 1 | a | 1970-01-01T00:00:05 |
+| 1 | a | 1970-01-01T00:00:10 |
+| 1 | b | 1970-01-01T00:00:05 |
+| 1 | b | 1970-01-01T00:00:10 |
++---+---+---------------------+
+
 -- SQLNESS SORT_RESULT 2 1
 TQL EVAL (0, 10, '5s') test{__schema__="public"};
 
diff --git a/tests/cases/standalone/common/tql/basic.sql b/tests/cases/standalone/common/tql/basic.sql
index 939d329f8d..79008985de 100644
--- a/tests/cases/standalone/common/tql/basic.sql
+++ b/tests/cases/standalone/common/tql/basic.sql
@@ -10,6 +10,12 @@ TQL EVAL (0, 10, '5s') test;
 -- SQLNESS SORT_RESULT 2 1
 TQL EVAL (0, 10, '5s') {__name__="test"};
 
+-- SQLNESS SORT_RESULT 2 1
+TQL EVAL (0, 10, '5s') {__name__="test"} AS test_series;
+
+-- SQLNESS SORT_RESULT 2 1
+TQL EVAL (0, 10, '5s') count by (k) (test) AS c;
+
 -- SQLNESS SORT_RESULT 2 1
 TQL EVAL (0, 10, '5s') test{__schema__="public"};
 
diff --git a/tests/cases/standalone/common/tql/join.result b/tests/cases/standalone/common/tql/join.result
index 9fd2e31327..e0d957b1b8 100644
--- a/tests/cases/standalone/common/tql/join.result
+++ b/tests/cases/standalone/common/tql/join.result
@@ -63,6 +63,19 @@ tql eval(0, 10, '5s') sum(completion * 0.0015 / 1000) by (model) + sum(prompt *
 | model-b | 1970-01-01T00:00:10 | 0.00033                                                                                                   |
 +---------+---------------------+-----------------------------------------------------------------------------------------------------------+
 
+-- SQLNESS SORT_RESULT 3 1
+tql eval(0, 10, '5s') sum(completion * 0.0015 / 1000) by (model) + sum(prompt * 0.0015 / 1000) by (model) AS result;
+
++----------+---------+---------------------+
+| result   | model   | ts                  |
++----------+---------+---------------------+
+| 0.000165 | model-a | 1970-01-01T00:00:00 |
+| 0.000165 | model-a | 1970-01-01T00:00:05 |
+| 0.00033  | model-b | 1970-01-01T00:00:05 |
+| 0.00033  | model-b | 1970-01-01T00:00:10 |
+| 0.000495 | model-a | 1970-01-01T00:00:10 |
++----------+---------+---------------------+
+
 -- SQLNESS SORT_RESULT 3 1
 tql eval(0, 10, '5s') sum(completion / 1000) + max(completion / 1000);
 
diff --git a/tests/cases/standalone/common/tql/join.sql b/tests/cases/standalone/common/tql/join.sql
index e9f5c8a544..c9287c865c 100644
--- a/tests/cases/standalone/common/tql/join.sql
+++ b/tests/cases/standalone/common/tql/join.sql
@@ -29,6 +29,9 @@ tql eval(0, 10, '5s') sum(completion * 0.0015 / 1000) + sum(prompt * 0.0015 / 10
 -- SQLNESS SORT_RESULT 3 1
 tql eval(0, 10, '5s') sum(completion * 0.0015 / 1000) by (model) + sum(prompt * 0.0015 / 1000) by (model);
 
+-- SQLNESS SORT_RESULT 3 1
+tql eval(0, 10, '5s') sum(completion * 0.0015 / 1000) by (model) + sum(prompt * 0.0015 / 1000) by (model) AS result;
+
 -- SQLNESS SORT_RESULT 3 1
 tql eval(0, 10, '5s') sum(completion / 1000) + max(completion / 1000);
 
diff --git a/tests/cases/standalone/common/tql/tql-cte.result b/tests/cases/standalone/common/tql/tql-cte.result
index 8f9124b7d6..76e4b511db 100644
--- a/tests/cases/standalone/common/tql/tql-cte.result
+++ b/tests/cases/standalone/common/tql/tql-cte.result
@@ -45,6 +45,29 @@ SELECT * FROM tql;
 | 1970-01-01T00:00:40 | 3.0 |
 +---------------------+-----+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql as (
+    TQL EVAL (0, 40, '10s') metric
+)
+SELECT * FROM tql;
+
++---------------+----------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                 |
++---------------+----------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                      |
+|               | Projection: tql.ts, tql.val                                                                                          |
+|               |   SubqueryAlias: tql                                                                                                 |
+|               |     PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                    |
+|               |       PromSeriesDivide: tags=[]                                                                                      |
+|               |         Filter: metric.ts >= TimestampMillisecond(-300000, None) AND metric.ts <= TimestampMillisecond(340000, None) |
+|               |           TableScan: metric                                                                                          |
+|               | ]]                                                                                                                   |
+| physical_plan | CooperativeExec                                                                                                      |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                      |
++---------------+----------------------------------------------------------------------------------------------------------------------+
+
 -- TQL CTE with column aliases
 WITH tql (the_timestamp, the_value) as (
     TQL EVAL (0, 40, '10s') metric
@@ -61,6 +84,53 @@ SELECT * FROM tql;
 | 1970-01-01T00:00:40 | 3.0       |
 +---------------------+-----------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql (the_timestamp, the_value) as (
+    TQL EVAL (0, 40, '10s') metric
+)
+SELECT * FROM tql;
+
++---------------+------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                   |
++---------------+------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                        |
+|               | Projection: tql.the_timestamp, tql.the_value                                                                           |
+|               |   SubqueryAlias: tql                                                                                                   |
+|               |     Projection: metric.ts AS the_timestamp, metric.val AS the_value                                                    |
+|               |       PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                    |
+|               |         PromSeriesDivide: tags=[]                                                                                      |
+|               |           Filter: metric.ts >= TimestampMillisecond(-300000, None) AND metric.ts <= TimestampMillisecond(340000, None) |
+|               |             TableScan: metric                                                                                          |
+|               | ]]                                                                                                                     |
+| physical_plan | CooperativeExec                                                                                                        |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                        |
++---------------+------------------------------------------------------------------------------------------------------------------------+
+
+-- Explain TQL CTE
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql AS (
+    TQL EVAL (0, 40, '10s') metric
+) SELECT * FROM tql;
+
++---------------+----------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                 |
++---------------+----------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                      |
+|               | Projection: tql.ts, tql.val                                                                                          |
+|               |   SubqueryAlias: tql                                                                                                 |
+|               |     PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                    |
+|               |       PromSeriesDivide: tags=[]                                                                                      |
+|               |         Filter: metric.ts >= TimestampMillisecond(-300000, None) AND metric.ts <= TimestampMillisecond(340000, None) |
+|               |           TableScan: metric                                                                                          |
+|               | ]]                                                                                                                   |
+| physical_plan | CooperativeExec                                                                                                      |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                      |
++---------------+----------------------------------------------------------------------------------------------------------------------+
+
 -- Hybrid CTEs (TQL + SQL)
 WITH
     tql_data (ts, val) AS (TQL EVAL (0, 40, '10s') metric),
@@ -73,6 +143,34 @@ SELECT count(*) FROM filtered;
 | 2        |
 +----------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH
+    tql_data (ts, val) AS (TQL EVAL (0, 40, '10s') metric),
+    filtered AS (SELECT * FROM tql_data WHERE val > 5)
+SELECT count(*) FROM filtered;
+
++---------------+--------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                           |
++---------------+--------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                                |
+|               | Projection: count(Int64(1)) AS count(*)                                                                                        |
+|               |   Aggregate: groupBy=[[]], aggr=[[count(Int64(1))]]                                                                            |
+|               |     SubqueryAlias: filtered                                                                                                    |
+|               |       Projection: tql_data.ts, tql_data.val                                                                                    |
+|               |         Filter: tql_data.val > CAST(Int64(5) AS Float64)                                                                       |
+|               |           SubqueryAlias: tql_data                                                                                              |
+|               |             Projection: metric.ts AS ts, metric.val AS val                                                                     |
+|               |               PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                    |
+|               |                 PromSeriesDivide: tags=[]                                                                                      |
+|               |                   Filter: metric.ts >= TimestampMillisecond(-300000, None) AND metric.ts <= TimestampMillisecond(340000, None) |
+|               |                     TableScan: metric                                                                                          |
+|               | ]]                                                                                                                             |
+| physical_plan | CooperativeExec                                                                                                                |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                                |
++---------------+--------------------------------------------------------------------------------------------------------------------------------+
+
 -- TQL CTE with complex PromQL expressions
 WITH
     tql_data (ts, val) AS (TQL EVAL (0, 40, '10s') rate(metric[20s])),
@@ -85,6 +183,38 @@ SELECT sum(val) FROM filtered;
 | 1.05              |
 +-------------------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH
+    tql_data (ts, val) AS (TQL EVAL (0, 40, '10s') rate(metric[20s])),
+    filtered (ts, val) AS (SELECT * FROM tql_data WHERE val > 0)
+SELECT sum(val) FROM filtered;
+
++---------------+----------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                   |
++---------------+----------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                                        |
+|               | Projection: sum(filtered.val)                                                                                                          |
+|               |   Aggregate: groupBy=[[]], aggr=[[sum(filtered.val)]]                                                                                  |
+|               |     SubqueryAlias: filtered                                                                                                            |
+|               |       Projection: tql_data.ts AS ts, tql_data.val AS val                                                                               |
+|               |         Projection: tql_data.ts, tql_data.val                                                                                          |
+|               |           Filter: tql_data.val > CAST(Int64(0) AS Float64)                                                                             |
+|               |             SubqueryAlias: tql_data                                                                                                    |
+|               |               Projection: metric.ts AS ts, prom_rate(ts_range,val,ts,Int64(20000)) AS val                                              |
+|               |                 Filter: prom_rate(ts_range,val,ts,Int64(20000)) IS NOT NULL                                                            |
+|               |                   Projection: metric.ts, prom_rate(ts_range, val, metric.ts, Int64(20000)) AS prom_rate(ts_range,val,ts,Int64(20000))  |
+|               |                     PromRangeManipulate: req range=[0..40000], interval=[10000], eval range=[20000], time index=[ts], values=["val"]   |
+|               |                       PromSeriesNormalize: offset=[0], time index=[ts], filter NaN: [true]                                             |
+|               |                         PromSeriesDivide: tags=[]                                                                                      |
+|               |                           Filter: metric.ts >= TimestampMillisecond(-320000, None) AND metric.ts <= TimestampMillisecond(340000, None) |
+|               |                             TableScan: metric                                                                                          |
+|               | ]]                                                                                                                                     |
+| physical_plan | CooperativeExec                                                                                                                        |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                                        |
++---------------+----------------------------------------------------------------------------------------------------------------------------------------+
+
 -- TQL CTE with aggregation functions
 WITH tql_agg(ts, summary) AS (
     TQL EVAL (0, 40, '10s') sum(labels{host=~"host.*"})
@@ -97,6 +227,32 @@ SELECT round(avg(summary)) as avg_sum FROM tql_agg;
 | 1.0     |
 +---------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_agg(ts, summary) AS (
+    TQL EVAL (0, 40, '10s') sum(labels{host=~"host.*"})
+)
+SELECT round(avg(summary)) as avg_sum FROM tql_agg;
+
++---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                              |
++---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                                                                   |
+|               | Projection: round(avg(tql_agg.summary)) AS avg_sum                                                                                                                |
+|               |   Aggregate: groupBy=[[]], aggr=[[avg(tql_agg.summary)]]                                                                                                          |
+|               |     SubqueryAlias: tql_agg                                                                                                                                        |
+|               |       Projection: labels.ts AS ts, sum(labels.cpu) AS summary                                                                                                     |
+|               |         Aggregate: groupBy=[[labels.ts]], aggr=[[sum(labels.cpu)]]                                                                                                |
+|               |           PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                                                           |
+|               |             PromSeriesDivide: tags=["host"]                                                                                                                       |
+|               |               Filter: labels.host ~ Utf8("^(?:host.*)$") AND labels.ts >= TimestampMillisecond(-300000, None) AND labels.ts <= TimestampMillisecond(340000, None) |
+|               |                 TableScan: labels                                                                                                                                 |
+|               | ]]                                                                                                                                                                |
+| physical_plan | CooperativeExec                                                                                                                                                   |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                                                                   |
++---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
 -- TQL CTE with label selectors
 WITH host_metrics AS (
     TQL EVAL (0, 40, '10s') labels{host="host1"}
@@ -109,6 +265,30 @@ SELECT count(*) as host1_points FROM host_metrics;
 | 5            |
 +--------------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH host_metrics AS (
+    TQL EVAL (0, 40, '10s') labels{host="host1"}
+)
+SELECT count(*) as host1_points FROM host_metrics;
+
++---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                   |
++---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                                                        |
+|               | Projection: count(Int64(1)) AS count(*) AS host1_points                                                                                                |
+|               |   Aggregate: groupBy=[[]], aggr=[[count(host_metrics.ts) AS count(Int64(1))]]                                                                          |
+|               |     SubqueryAlias: host_metrics                                                                                                                        |
+|               |       PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                                                    |
+|               |         PromSeriesDivide: tags=["host"]                                                                                                                |
+|               |           Filter: labels.host = Utf8("host1") AND labels.ts >= TimestampMillisecond(-300000, None) AND labels.ts <= TimestampMillisecond(340000, None) |
+|               |             TableScan: labels                                                                                                                          |
+|               | ]]                                                                                                                                                     |
+| physical_plan | CooperativeExec                                                                                                                                        |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                                                        |
++---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+
 -- TQL CTE with column reference
 WITH host_metrics AS (
     TQL EVAL (0, 40, '10s') labels{host="host1"}
@@ -125,6 +305,29 @@ SELECT host_metrics.ts, host_metrics.host FROM host_metrics;
 | 1970-01-01T00:00:40 | host1 |
 +---------------------+-------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH host_metrics AS (
+    TQL EVAL (0, 40, '10s') labels{host="host1"}
+)
+SELECT host_metrics.ts, host_metrics.host FROM host_metrics;
+
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                 |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                                                      |
+|               | Projection: host_metrics.ts, host_metrics.host                                                                                                       |
+|               |   SubqueryAlias: host_metrics                                                                                                                        |
+|               |     PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                                                    |
+|               |       PromSeriesDivide: tags=["host"]                                                                                                                |
+|               |         Filter: labels.host = Utf8("host1") AND labels.ts >= TimestampMillisecond(-300000, None) AND labels.ts <= TimestampMillisecond(340000, None) |
+|               |           TableScan: labels                                                                                                                          |
+|               | ]]                                                                                                                                                   |
+| physical_plan | CooperativeExec                                                                                                                                      |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                                                      |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
+
 -- Multiple TQL CTEs referencing different tables
 WITH
     metric_data(ts, val) AS (TQL EVAL (0, 40, '10s') metric),
@@ -145,6 +348,63 @@ LIMIT 3;
 | 8.0        | 0.7       |
 +------------+-----------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH
+    metric_data(ts, val) AS (TQL EVAL (0, 40, '10s') metric),
+    label_data(ts, host, cpu) AS (TQL EVAL (0, 40, '10s') labels{host="host2"})
+SELECT
+    m.val as metric_val,
+    l.cpu as label_val
+FROM metric_data m, label_data l
+WHERE m.ts = l.ts
+ORDER BY m.ts
+LIMIT 3;
+
++---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                   |
++---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | Projection: metric_val, label_val                                                                                                                      |
+|               |   Sort: m.ts ASC NULLS LAST, fetch=3                                                                                                                   |
+|               |     Projection: m.val AS metric_val, l.cpu AS label_val, m.ts                                                                                          |
+|               |       Inner Join: m.ts = l.ts                                                                                                                          |
+|               |         MergeScan [is_placeholder=false, remote_input=[                                                                                                |
+|               | SubqueryAlias: m                                                                                                                                       |
+|               |   SubqueryAlias: metric_data                                                                                                                           |
+|               |     Projection: metric.ts AS ts, metric.val AS val                                                                                                     |
+|               |       PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                                                    |
+|               |         PromSeriesDivide: tags=[]                                                                                                                      |
+|               |           Filter: metric.ts >= TimestampMillisecond(-300000, None) AND metric.ts <= TimestampMillisecond(340000, None)                                 |
+|               |             TableScan: metric                                                                                                                          |
+|               | ]]                                                                                                                                                     |
+|               |         Projection: l.ts, l.cpu                                                                                                                        |
+|               |           MergeScan [is_placeholder=false, remote_input=[                                                                                              |
+|               | SubqueryAlias: l                                                                                                                                       |
+|               |   SubqueryAlias: label_data                                                                                                                            |
+|               |     Projection: labels.ts AS ts, labels.host AS host, labels.cpu AS cpu                                                                                |
+|               |       PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                                                    |
+|               |         PromSeriesDivide: tags=["host"]                                                                                                                |
+|               |           Filter: labels.host = Utf8("host2") AND labels.ts >= TimestampMillisecond(-300000, None) AND labels.ts <= TimestampMillisecond(340000, None) |
+|               |             TableScan: labels                                                                                                                          |
+|               | ]]                                                                                                                                                     |
+| physical_plan | ProjectionExec: expr=[metric_val@0 as metric_val, label_val@1 as label_val]                                                                            |
+|               |   SortPreservingMergeExec: [ts@2 ASC NULLS LAST], fetch=3                                                                                              |
+|               |     SortExec: TopK(fetch=3), expr=[ts@2 ASC NULLS LAST], preserve_REDACTED
+|               |       ProjectionExec: expr=[val@1 as metric_val, cpu@2 as label_val, ts@0 as ts]                                                                       |
+|               |         CoalesceBatchesExec: target_batch_size=8192                                                                                                    |
+|               |           HashJoinExec: mode=Partitioned, join_type=Inner, on=[(ts@0, ts@0)], projection=[ts@0, val@1, cpu@3]                                          |
+|               |             CoalesceBatchesExec: target_batch_size=8192                                                                                                |
+|               |               RepartitionExec: REDACTED
+|               |                 CooperativeExec                                                                                                                        |
+|               |                   MergeScanExec: REDACTED
+|               |             CoalesceBatchesExec: target_batch_size=8192                                                                                                |
+|               |               RepartitionExec: REDACTED
+|               |                 ProjectionExec: expr=[ts@0 as ts, cpu@2 as cpu]                                                                                        |
+|               |                   CooperativeExec                                                                                                                      |
+|               |                     MergeScanExec: REDACTED
+|               |                                                                                                                                                        |
++---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+
 -- TQL CTE with mathematical operations
 WITH computed(ts, val) AS (
     TQL EVAL (0, 40, '10s') metric * 2 + 1
@@ -157,6 +417,33 @@ SELECT min(val) as min_computed, max(val) as max_computed FROM computed;
 | 1.0          | 17.0         |
 +--------------+--------------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH computed(ts, val) AS (
+    TQL EVAL (0, 40, '10s') metric * 2 + 1
+)
+SELECT min(val) as min_computed, max(val) as max_computed FROM computed;
+
++---------------+------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                         |
++---------------+------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                              |
+|               | Projection: min(computed.val) AS min_computed, max(computed.val) AS max_computed                                             |
+|               |   Aggregate: groupBy=[[]], aggr=[[min(computed.val), max(computed.val)]]                                                     |
+|               |     SubqueryAlias: computed                                                                                                  |
+|               |       Projection: metric.ts AS ts, val * Float64(2) + Float64(1) AS val                                                      |
+|               |         Projection: metric.ts, val * Float64(2) + Float64(1) AS val * Float64(2) + Float64(1)                                |
+|               |           Projection: metric.ts, metric.val * Float64(2) AS val * Float64(2)                                                 |
+|               |             PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                    |
+|               |               PromSeriesDivide: tags=[]                                                                                      |
+|               |                 Filter: metric.ts >= TimestampMillisecond(-300000, None) AND metric.ts <= TimestampMillisecond(340000, None) |
+|               |                   TableScan: metric                                                                                          |
+|               | ]]                                                                                                                           |
+| physical_plan | CooperativeExec                                                                                                              |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                              |
++---------------+------------------------------------------------------------------------------------------------------------------------------+
+
 -- TQL CTE with window functions in SQL part
 WITH tql_base(ts, val) AS (
     TQL EVAL (0, 40, '10s') metric
@@ -178,6 +465,41 @@ ORDER BY ts;
 | 1970-01-01T00:00:40 | 3.0 | 2.0        |
 +---------------------+-----+------------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_base(ts, val) AS (
+    TQL EVAL (0, 40, '10s') metric
+)
+SELECT
+    ts,
+    val,
+    LAG(val, 1) OVER (ORDER BY ts) as prev_value
+FROM tql_base
+ORDER BY ts;
+
++---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
++---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | Sort: tql_base.ts ASC NULLS LAST                                                                                                                                                                                                                                                                                                                                                                                                                      |
+|               |   Projection: tql_base.ts, tql_base.val, lag(tql_base.val,Int64(1)) ORDER BY [tql_base.ts ASC NULLS LAST] RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS prev_value                                                                                                                                                                                                                                                                             |
+|               |     WindowAggr: windowExpr=[[lag(tql_base.val, Int64(1)) ORDER BY [tql_base.ts ASC NULLS LAST] RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]]                                                                                                                                                                                                                                                                                                    |
+|               |       MergeScan [is_placeholder=false, remote_input=[                                                                                                                                                                                                                                                                                                                                                                                                 |
+|               | SubqueryAlias: tql_base                                                                                                                                                                                                                                                                                                                                                                                                                               |
+|               |   Projection: metric.ts AS ts, metric.val AS val                                                                                                                                                                                                                                                                                                                                                                                                      |
+|               |     PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                                                                                                                                                                                                                                                                                                                                                     |
+|               |       PromSeriesDivide: tags=[]                                                                                                                                                                                                                                                                                                                                                                                                                       |
+|               |         Filter: metric.ts >= TimestampMillisecond(-300000, None) AND metric.ts <= TimestampMillisecond(340000, None)                                                                                                                                                                                                                                                                                                                                  |
+|               |           TableScan: metric                                                                                                                                                                                                                                                                                                                                                                                                                           |
+|               | ]]                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| physical_plan | ProjectionExec: expr=[ts@0 as ts, val@1 as val, lag(tql_base.val,Int64(1)) ORDER BY [tql_base.ts ASC NULLS LAST] RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW@2 as prev_value]                                                                                                                                                                                                                                                                   |
+|               |   BoundedWindowAggExec: wdw=[lag(tql_base.val,Int64(1)) ORDER BY [tql_base.ts ASC NULLS LAST] RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW: Field { name: "lag(tql_base.val,Int64(1)) ORDER BY [tql_base.ts ASC NULLS LAST] RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW", data_type: Float64, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }, frame: RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], mode=[Sorted] |
+|               |     SortPreservingMergeExec: [ts@0 ASC NULLS LAST]                                                                                                                                                                                                                                                                                                                                                                                                    |
+|               |       SortExec: expr=[ts@0 ASC NULLS LAST], preserve_REDACTED
+|               |         CooperativeExec                                                                                                                                                                                                                                                                                                                                                                                                                               |
+|               |           MergeScanExec: REDACTED
+|               |                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
++---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
 -- TQL CTE with HAVING clause
 WITH tql_grouped(ts, host, cpu) AS (
     TQL EVAL (0, 40, '10s') labels
@@ -195,6 +517,37 @@ HAVING count(*) > 1;
 | 1970-01-01T00:00:00 | 10          |
 +---------------------+-------------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_grouped(ts, host, cpu) AS (
+    TQL EVAL (0, 40, '10s') labels
+)
+SELECT
+    DATE_TRUNC('minute', ts) as minute,
+    count(*) as point_count
+FROM tql_grouped
+GROUP BY minute
+HAVING count(*) > 1;
+
++---------------+----------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                       |
++---------------+----------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                            |
+|               | Projection: date_trunc(Utf8("minute"),tql_grouped.ts) AS minute, count(Int64(1)) AS count(*) AS point_count                |
+|               |   Filter: count(Int64(1)) > Int64(1)                                                                                       |
+|               |     Aggregate: groupBy=[[date_trunc(Utf8("minute"), tql_grouped.ts)]], aggr=[[count(tql_grouped.ts) AS count(Int64(1))]]   |
+|               |       SubqueryAlias: tql_grouped                                                                                           |
+|               |         Projection: labels.ts AS ts, labels.host AS host, labels.cpu AS cpu                                                |
+|               |           PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                    |
+|               |             PromSeriesDivide: tags=["host"]                                                                                |
+|               |               Filter: labels.ts >= TimestampMillisecond(-300000, None) AND labels.ts <= TimestampMillisecond(340000, None) |
+|               |                 TableScan: labels                                                                                          |
+|               | ]]                                                                                                                         |
+| physical_plan | CooperativeExec                                                                                                            |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                            |
++---------------+----------------------------------------------------------------------------------------------------------------------------+
+
 -- TQL CTE with UNION
 -- SQLNESS SORT_RESULT 3 1
 WITH
@@ -219,6 +572,45 @@ SELECT 'host2' as source, ts, cpu FROM host2_data;
 | host2  | 1970-01-01T00:00:40 | 0.5 |
 +--------+---------------------+-----+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH
+    host1_data(ts, host, cpu) AS (TQL EVAL (0, 40, '10s') labels{host="host1"}),
+    host2_data(ts, host, cpu) AS (TQL EVAL (0, 40, '10s') labels{host="host2"})
+SELECT 'host1' as source, ts, cpu FROM host1_data
+UNION ALL
+SELECT 'host2' as source, ts, cpu FROM host2_data;
+
++---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                   |
++---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | Union                                                                                                                                                  |
+|               |   MergeScan [is_placeholder=false, remote_input=[                                                                                                      |
+|               | Projection: Utf8("host1") AS source, host1_data.ts, host1_data.cpu                                                                                     |
+|               |   SubqueryAlias: host1_data                                                                                                                            |
+|               |     Projection: labels.ts AS ts, labels.host AS host, labels.cpu AS cpu                                                                                |
+|               |       PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                                                    |
+|               |         PromSeriesDivide: tags=["host"]                                                                                                                |
+|               |           Filter: labels.host = Utf8("host1") AND labels.ts >= TimestampMillisecond(-300000, None) AND labels.ts <= TimestampMillisecond(340000, None) |
+|               |             TableScan: labels                                                                                                                          |
+|               | ]]                                                                                                                                                     |
+|               |   MergeScan [is_placeholder=false, remote_input=[                                                                                                      |
+|               | Projection: Utf8("host2") AS source, host2_data.ts, host2_data.cpu                                                                                     |
+|               |   SubqueryAlias: host2_data                                                                                                                            |
+|               |     Projection: labels.ts AS ts, labels.host AS host, labels.cpu AS cpu                                                                                |
+|               |       PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                                                    |
+|               |         PromSeriesDivide: tags=["host"]                                                                                                                |
+|               |           Filter: labels.host = Utf8("host2") AND labels.ts >= TimestampMillisecond(-300000, None) AND labels.ts <= TimestampMillisecond(340000, None) |
+|               |             TableScan: labels                                                                                                                          |
+|               | ]]                                                                                                                                                     |
+| physical_plan | InterleaveExec                                                                                                                                         |
+|               |   CooperativeExec                                                                                                                                      |
+|               |     MergeScanExec: REDACTED
+|               |   CooperativeExec                                                                                                                                      |
+|               |     MergeScanExec: REDACTED
+|               |                                                                                                                                                        |
++---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+
 -- Nested CTEs with TQL
 WITH
     base_tql(ts, val) AS (TQL EVAL (0, 40, '10s') metric),
@@ -238,6 +630,46 @@ SELECT count(*) as high_values FROM final;
 | 3           |
 +-------------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH
+    base_tql(ts, val) AS (TQL EVAL (0, 40, '10s') metric),
+    processed(ts, percent) AS (
+        SELECT ts, val * 100 as percent
+        FROM base_tql
+        WHERE val > 0
+    ),
+    final(ts, percent) AS (
+        SELECT * FROM processed WHERE percent > 200
+    )
+SELECT count(*) as high_values FROM final;
+
++---------------+------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                     |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                                          |
+|               | Projection: count(Int64(1)) AS count(*) AS high_values                                                                                   |
+|               |   Aggregate: groupBy=[[]], aggr=[[count(Int64(1))]]                                                                                      |
+|               |     SubqueryAlias: final                                                                                                                 |
+|               |       Projection: processed.ts AS ts, processed.percent AS percent                                                                       |
+|               |         Projection: processed.ts, processed.percent                                                                                      |
+|               |           Filter: processed.percent > CAST(Int64(200) AS Float64)                                                                        |
+|               |             SubqueryAlias: processed                                                                                                     |
+|               |               Projection: base_tql.ts AS ts, percent AS percent                                                                          |
+|               |                 Projection: base_tql.ts, base_tql.val * CAST(Int64(100) AS Float64) AS percent                                           |
+|               |                   Filter: base_tql.val > CAST(Int64(0) AS Float64)                                                                       |
+|               |                     SubqueryAlias: base_tql                                                                                              |
+|               |                       Projection: metric.ts AS ts, metric.val AS val                                                                     |
+|               |                         PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                    |
+|               |                           PromSeriesDivide: tags=[]                                                                                      |
+|               |                             Filter: metric.ts >= TimestampMillisecond(-300000, None) AND metric.ts <= TimestampMillisecond(340000, None) |
+|               |                               TableScan: metric                                                                                          |
+|               | ]]                                                                                                                                       |
+| physical_plan | CooperativeExec                                                                                                                          |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                                          |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------+
+
 -- TQL CTE with time-based functions
 WITH time_shifted AS (
     TQL EVAL (0, 40, '10s') metric offset 50s
@@ -254,6 +686,30 @@ SELECT * FROM time_shifted;
 | 1970-01-01T00:00:40 | 3.0 |
 +---------------------+-----+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH time_shifted AS (
+    TQL EVAL (0, 40, '10s') metric offset 50s
+)
+SELECT * FROM time_shifted;
+
++---------------+------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                   |
++---------------+------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                        |
+|               | Projection: time_shifted.ts, time_shifted.val                                                                          |
+|               |   SubqueryAlias: time_shifted                                                                                          |
+|               |     PromInstantManipulate: range=[0..40000], lookback=[300000], interval=[10000], time index=[ts]                      |
+|               |       PromSeriesNormalize: offset=[50000], time index=[ts], filter NaN: [false]                                        |
+|               |         PromSeriesDivide: tags=[]                                                                                      |
+|               |           Filter: metric.ts >= TimestampMillisecond(-250000, None) AND metric.ts <= TimestampMillisecond(390000, None) |
+|               |             TableScan: metric                                                                                          |
+|               | ]]                                                                                                                     |
+| physical_plan | CooperativeExec                                                                                                        |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                        |
++---------------+------------------------------------------------------------------------------------------------------------------------+
+
 -- TQL CTE with JOIN between TQL and regular table
 -- SQLNESS SORT_RESULT 3 1
 WITH tql_summary(ts, host, cpu) AS (
@@ -279,6 +735,153 @@ LIMIT 5;
 | 1970-01-01T00:00:20 | host1     | host1 |
 +---------------------+-----------+-------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_summary(ts, host, cpu) AS (
+    TQL EVAL (0, 40, '10s') avg_over_time(labels[30s])
+)
+SELECT
+    t.ts,
+    t.cpu as avg_value,
+    l.host
+FROM tql_summary t
+JOIN labels l ON DATE_TRUNC('second', t.ts) = DATE_TRUNC('second', l.ts)
+WHERE l.host = 'host1'
+ORDER BY t.ts, l.host, avg_value
+LIMIT 5;
+
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                                   |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | Sort: t.ts ASC NULLS LAST, l.host ASC NULLS LAST, avg_value ASC NULLS LAST, fetch=5                                                                                    |
+|               |   Projection: t.ts, t.cpu AS avg_value, l.host                                                                                                                         |
+|               |     Inner Join: date_trunc(Utf8("second"), t.ts) = date_trunc(Utf8("second"), l.ts)                                                                                    |
+|               |       Projection: t.ts, t.cpu                                                                                                                                          |
+|               |         MergeScan [is_placeholder=false, remote_input=[                                                                                                                |
+|               | SubqueryAlias: t                                                                                                                                                       |
+|               |   SubqueryAlias: tql_summary                                                                                                                                           |
+|               |     Projection: labels.ts AS ts, prom_avg_over_time(ts_range,cpu) AS host, labels.host AS cpu                                                                          |
+|               |       Filter: prom_avg_over_time(ts_range,cpu) IS NOT NULL                                                                                                             |
+|               |         Projection: labels.ts, prom_avg_over_time(ts_range, cpu) AS prom_avg_over_time(ts_range,cpu), labels.host                                                      |
+|               |           PromRangeManipulate: req range=[0..40000], interval=[10000], eval range=[30000], time index=[ts], values=["cpu"]                                             |
+|               |             PromSeriesNormalize: offset=[0], time index=[ts], filter NaN: [true]                                                                                       |
+|               |               PromSeriesDivide: tags=["host"]                                                                                                                          |
+|               |                 Filter: labels.ts >= TimestampMillisecond(-330000, None) AND labels.ts <= TimestampMillisecond(340000, None)                                           |
+|               |                   TableScan: labels                                                                                                                                    |
+|               | ]]                                                                                                                                                                     |
+|               |       Filter: l.host = Utf8("host1")                                                                                                                                   |
+|               |         Projection: l.ts, l.host                                                                                                                                       |
+|               |           MergeScan [is_placeholder=false, remote_input=[                                                                                                              |
+|               | SubqueryAlias: l                                                                                                                                                       |
+|               |   TableScan: labels                                                                                                                                                    |
+|               | ]]                                                                                                                                                                     |
+| physical_plan | SortPreservingMergeExec: [ts@0 ASC NULLS LAST, host@2 ASC NULLS LAST, avg_value@1 ASC NULLS LAST], fetch=5                                                             |
+|               |   SortExec: TopK(fetch=5), expr=[ts@0 ASC NULLS LAST, host@2 ASC NULLS LAST, avg_value@1 ASC NULLS LAST], preserve_REDACTED
+|               |     ProjectionExec: expr=[ts@0 as ts, cpu@1 as avg_value, host@2 as host]                                                                                              |
+|               |       CoalesceBatchesExec: target_batch_size=8192                                                                                                                      |
+|               |         HashJoinExec: mode=Partitioned, join_type=Inner, on=[(date_trunc(Utf8("second"),t.ts)@2, date_trunc(Utf8("second"),l.ts)@2)], projection=[ts@0, cpu@1, host@4] |
+|               |           CoalesceBatchesExec: target_batch_size=8192                                                                                                                  |
+|               |             RepartitionExec: REDACTED
+|               |               ProjectionExec: expr=[ts@0 as ts, cpu@2 as cpu, date_trunc(second, ts@0) as date_trunc(Utf8("second"),t.ts)]                                             |
+|               |                 CooperativeExec                                                                                                                                        |
+|               |                   MergeScanExec: REDACTED
+|               |           CoalesceBatchesExec: target_batch_size=8192                                                                                                                  |
+|               |             RepartitionExec: REDACTED
+|               |               ProjectionExec: expr=[ts@0 as ts, host@1 as host, date_trunc(second, ts@0) as date_trunc(Utf8("second"),l.ts)]                                           |
+|               |                 CoalesceBatchesExec: target_batch_size=8192                                                                                                            |
+|               |                   FilterExec: host@1 = host1                                                                                                                           |
+|               |                     ProjectionExec: expr=[ts@0 as ts, host@1 as host]                                                                                                  |
+|               |                       CooperativeExec                                                                                                                                  |
+|               |                         MergeScanExec: REDACTED
+|               |                                                                                                                                                                        |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
+-- TQL CTE with JOIN and value aliasing
+-- SQLNESS SORT_RESULT 3 1
+WITH tql_summary AS (
+    TQL EVAL (0, 40, '10s') avg_over_time(labels[30s]) AS cpu
+)
+SELECT
+    t.ts,
+    t.cpu as avg_value,
+    l.host
+FROM tql_summary t
+JOIN labels l ON DATE_TRUNC('second', t.ts) = DATE_TRUNC('second', l.ts)
+WHERE l.host = 'host1'
+ORDER BY t.ts, l.host, avg_value
+LIMIT 5;
+
++---------------------+--------------------+-------+
+| ts                  | avg_value          | host  |
++---------------------+--------------------+-------+
+| 1970-01-01T00:00:00 | 0.1                | host1 |
+| 1970-01-01T00:00:00 | 0.2                | host1 |
+| 1970-01-01T00:00:10 | 0.45               | host1 |
+| 1970-01-01T00:00:10 | 0.55               | host1 |
+| 1970-01-01T00:00:20 | 0.5666666666666668 | host1 |
++---------------------+--------------------+-------+
+
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_summary AS (
+    TQL EVAL (0, 40, '10s') avg_over_time(labels[30s]) AS cpu
+)
+SELECT
+    t.ts,
+    t.cpu as avg_value,
+    l.host
+FROM tql_summary t
+JOIN labels l ON DATE_TRUNC('second', t.ts) = DATE_TRUNC('second', l.ts)
+WHERE l.host = 'host1'
+ORDER BY t.ts, l.host, avg_value
+LIMIT 5;
+
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                                   |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | Sort: t.ts ASC NULLS LAST, l.host ASC NULLS LAST, avg_value ASC NULLS LAST, fetch=5                                                                                    |
+|               |   Projection: t.ts, t.cpu AS avg_value, l.host                                                                                                                         |
+|               |     Inner Join: date_trunc(Utf8("second"), t.ts) = date_trunc(Utf8("second"), l.ts)                                                                                    |
+|               |       Projection: t.cpu, t.ts                                                                                                                                          |
+|               |         MergeScan [is_placeholder=false, remote_input=[                                                                                                                |
+|               | SubqueryAlias: t                                                                                                                                                       |
+|               |   SubqueryAlias: tql_summary                                                                                                                                           |
+|               |     Projection: prom_avg_over_time(ts_range,cpu) AS cpu, labels.host, labels.ts                                                                                        |
+|               |       Filter: prom_avg_over_time(ts_range,cpu) IS NOT NULL                                                                                                             |
+|               |         Projection: labels.ts, prom_avg_over_time(ts_range, cpu) AS prom_avg_over_time(ts_range,cpu), labels.host                                                      |
+|               |           PromRangeManipulate: req range=[0..40000], interval=[10000], eval range=[30000], time index=[ts], values=["cpu"]                                             |
+|               |             PromSeriesNormalize: offset=[0], time index=[ts], filter NaN: [true]                                                                                       |
+|               |               PromSeriesDivide: tags=["host"]                                                                                                                          |
+|               |                 Filter: labels.ts >= TimestampMillisecond(-330000, None) AND labels.ts <= TimestampMillisecond(340000, None)                                           |
+|               |                   TableScan: labels                                                                                                                                    |
+|               | ]]                                                                                                                                                                     |
+|               |       Filter: l.host = Utf8("host1")                                                                                                                                   |
+|               |         Projection: l.ts, l.host                                                                                                                                       |
+|               |           MergeScan [is_placeholder=false, remote_input=[                                                                                                              |
+|               | SubqueryAlias: l                                                                                                                                                       |
+|               |   TableScan: labels                                                                                                                                                    |
+|               | ]]                                                                                                                                                                     |
+| physical_plan | SortPreservingMergeExec: [ts@0 ASC NULLS LAST, host@2 ASC NULLS LAST, avg_value@1 ASC NULLS LAST], fetch=5                                                             |
+|               |   SortExec: TopK(fetch=5), expr=[ts@0 ASC NULLS LAST, host@2 ASC NULLS LAST, avg_value@1 ASC NULLS LAST], preserve_REDACTED
+|               |     ProjectionExec: expr=[ts@1 as ts, cpu@0 as avg_value, host@2 as host]                                                                                              |
+|               |       CoalesceBatchesExec: target_batch_size=8192                                                                                                                      |
+|               |         HashJoinExec: mode=Partitioned, join_type=Inner, on=[(date_trunc(Utf8("second"),t.ts)@2, date_trunc(Utf8("second"),l.ts)@2)], projection=[cpu@0, ts@1, host@4] |
+|               |           CoalesceBatchesExec: target_batch_size=8192                                                                                                                  |
+|               |             RepartitionExec: REDACTED
+|               |               ProjectionExec: expr=[cpu@0 as cpu, ts@2 as ts, date_trunc(second, ts@2) as date_trunc(Utf8("second"),t.ts)]                                             |
+|               |                 CooperativeExec                                                                                                                                        |
+|               |                   MergeScanExec: REDACTED
+|               |           CoalesceBatchesExec: target_batch_size=8192                                                                                                                  |
+|               |             RepartitionExec: REDACTED
+|               |               ProjectionExec: expr=[ts@0 as ts, host@1 as host, date_trunc(second, ts@0) as date_trunc(Utf8("second"),l.ts)]                                           |
+|               |                 CoalesceBatchesExec: target_batch_size=8192                                                                                                            |
+|               |                   FilterExec: host@1 = host1                                                                                                                           |
+|               |                     ProjectionExec: expr=[ts@0 as ts, host@1 as host]                                                                                                  |
+|               |                       CooperativeExec                                                                                                                                  |
+|               |                         MergeScanExec: REDACTED
+|               |                                                                                                                                                                        |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
 -- Error case - TQL ANALYZE should fail
 WITH tql_analyze AS (
     TQL ANALYZE (0, 40, '10s') metric
@@ -287,6 +890,15 @@ SELECT * FROM tql_analyze limit 1;
 
 Error: 2000(InvalidSyntax), Invalid SQL, error: Only TQL EVAL is supported in CTEs
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_analyze AS (
+    TQL ANALYZE (0, 40, '10s') metric
+)
+SELECT * FROM tql_analyze limit 1;
+
+Error: 2000(InvalidSyntax), Invalid SQL, error: Only TQL EVAL is supported in CTEs
+
 -- Error case - TQL EXPLAIN should fail
 WITH tql_explain AS (
     TQL EXPLAIN (0, 40, '10s') metric
@@ -295,6 +907,15 @@ SELECT * FROM tql_explain limit 1;
 
 Error: 2000(InvalidSyntax), Invalid SQL, error: Only TQL EVAL is supported in CTEs
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_explain AS (
+    TQL EXPLAIN (0, 40, '10s') metric
+)
+SELECT * FROM tql_explain limit 1;
+
+Error: 2000(InvalidSyntax), Invalid SQL, error: Only TQL EVAL is supported in CTEs
+
 -- TQL CTE with lookback parameter
 WITH tql_lookback AS (
     TQL EVAL (0, 40, '10s', '15s') metric
@@ -307,6 +928,30 @@ SELECT count(*) FROM tql_lookback;
 | 5        |
 +----------+
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_lookback AS (
+    TQL EVAL (0, 40, '10s', '15s') metric
+)
+SELECT count(*) FROM tql_lookback;
+
++---------------+----------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                 |
++---------------+----------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                      |
+|               | Projection: count(Int64(1)) AS count(*)                                                                              |
+|               |   Aggregate: groupBy=[[]], aggr=[[count(tql_lookback.ts) AS count(Int64(1))]]                                        |
+|               |     SubqueryAlias: tql_lookback                                                                                      |
+|               |       PromInstantManipulate: range=[0..40000], lookback=[15000], interval=[10000], time index=[ts]                   |
+|               |         PromSeriesDivide: tags=[]                                                                                    |
+|               |           Filter: metric.ts >= TimestampMillisecond(-15000, None) AND metric.ts <= TimestampMillisecond(55000, None) |
+|               |             TableScan: metric                                                                                        |
+|               | ]]                                                                                                                   |
+| physical_plan | CooperativeExec                                                                                                      |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                      |
++---------------+----------------------------------------------------------------------------------------------------------------------+
+
 drop table metric;
 
 Affected Rows: 0
diff --git a/tests/cases/standalone/common/tql/tql-cte.sql b/tests/cases/standalone/common/tql/tql-cte.sql
index 6a182b9272..6d928d8451 100644
--- a/tests/cases/standalone/common/tql/tql-cte.sql
+++ b/tests/cases/standalone/common/tql/tql-cte.sql
@@ -26,42 +26,99 @@ WITH tql as (
 )
 SELECT * FROM tql;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql as (
+    TQL EVAL (0, 40, '10s') metric
+)
+SELECT * FROM tql;
+
 -- TQL CTE with column aliases
 WITH tql (the_timestamp, the_value) as (
     TQL EVAL (0, 40, '10s') metric
 )
 SELECT * FROM tql;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql (the_timestamp, the_value) as (
+    TQL EVAL (0, 40, '10s') metric
+)
+SELECT * FROM tql;
+
+-- Explain TQL CTE
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql AS (
+    TQL EVAL (0, 40, '10s') metric
+) SELECT * FROM tql;
+
 -- Hybrid CTEs (TQL + SQL)
 WITH
     tql_data (ts, val) AS (TQL EVAL (0, 40, '10s') metric),
     filtered AS (SELECT * FROM tql_data WHERE val > 5)
 SELECT count(*) FROM filtered;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH
+    tql_data (ts, val) AS (TQL EVAL (0, 40, '10s') metric),
+    filtered AS (SELECT * FROM tql_data WHERE val > 5)
+SELECT count(*) FROM filtered;
+
 -- TQL CTE with complex PromQL expressions
 WITH
     tql_data (ts, val) AS (TQL EVAL (0, 40, '10s') rate(metric[20s])),
     filtered (ts, val) AS (SELECT * FROM tql_data WHERE val > 0)
 SELECT sum(val) FROM filtered;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH
+    tql_data (ts, val) AS (TQL EVAL (0, 40, '10s') rate(metric[20s])),
+    filtered (ts, val) AS (SELECT * FROM tql_data WHERE val > 0)
+SELECT sum(val) FROM filtered;
+
 -- TQL CTE with aggregation functions
 WITH tql_agg(ts, summary) AS (
     TQL EVAL (0, 40, '10s') sum(labels{host=~"host.*"})
 )
 SELECT round(avg(summary)) as avg_sum FROM tql_agg;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_agg(ts, summary) AS (
+    TQL EVAL (0, 40, '10s') sum(labels{host=~"host.*"})
+)
+SELECT round(avg(summary)) as avg_sum FROM tql_agg;
+
 -- TQL CTE with label selectors
 WITH host_metrics AS (
     TQL EVAL (0, 40, '10s') labels{host="host1"}
 )
 SELECT count(*) as host1_points FROM host_metrics;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH host_metrics AS (
+    TQL EVAL (0, 40, '10s') labels{host="host1"}
+)
+SELECT count(*) as host1_points FROM host_metrics;
+
 -- TQL CTE with column reference
 WITH host_metrics AS (
     TQL EVAL (0, 40, '10s') labels{host="host1"}
 )
 SELECT host_metrics.ts, host_metrics.host FROM host_metrics;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH host_metrics AS (
+    TQL EVAL (0, 40, '10s') labels{host="host1"}
+)
+SELECT host_metrics.ts, host_metrics.host FROM host_metrics;
+
+
 -- Multiple TQL CTEs referencing different tables
 WITH
     metric_data(ts, val) AS (TQL EVAL (0, 40, '10s') metric),
@@ -74,12 +131,32 @@ WHERE m.ts = l.ts
 ORDER BY m.ts
 LIMIT 3;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH
+    metric_data(ts, val) AS (TQL EVAL (0, 40, '10s') metric),
+    label_data(ts, host, cpu) AS (TQL EVAL (0, 40, '10s') labels{host="host2"})
+SELECT
+    m.val as metric_val,
+    l.cpu as label_val
+FROM metric_data m, label_data l
+WHERE m.ts = l.ts
+ORDER BY m.ts
+LIMIT 3;
+
 -- TQL CTE with mathematical operations
 WITH computed(ts, val) AS (
     TQL EVAL (0, 40, '10s') metric * 2 + 1
 )
 SELECT min(val) as min_computed, max(val) as max_computed FROM computed;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH computed(ts, val) AS (
+    TQL EVAL (0, 40, '10s') metric * 2 + 1
+)
+SELECT min(val) as min_computed, max(val) as max_computed FROM computed;
+
 -- TQL CTE with window functions in SQL part
 WITH tql_base(ts, val) AS (
     TQL EVAL (0, 40, '10s') metric
@@ -91,6 +168,18 @@ SELECT
 FROM tql_base
 ORDER BY ts;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_base(ts, val) AS (
+    TQL EVAL (0, 40, '10s') metric
+)
+SELECT
+    ts,
+    val,
+    LAG(val, 1) OVER (ORDER BY ts) as prev_value
+FROM tql_base
+ORDER BY ts;
+
 -- TQL CTE with HAVING clause
 WITH tql_grouped(ts, host, cpu) AS (
     TQL EVAL (0, 40, '10s') labels
@@ -102,6 +191,18 @@ FROM tql_grouped
 GROUP BY minute
 HAVING count(*) > 1;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_grouped(ts, host, cpu) AS (
+    TQL EVAL (0, 40, '10s') labels
+)
+SELECT
+    DATE_TRUNC('minute', ts) as minute,
+    count(*) as point_count
+FROM tql_grouped
+GROUP BY minute
+HAVING count(*) > 1;
+
 -- TQL CTE with UNION
 -- SQLNESS SORT_RESULT 3 1
 WITH
@@ -111,6 +212,15 @@ SELECT 'host1' as source, ts, cpu FROM host1_data
 UNION ALL
 SELECT 'host2' as source, ts, cpu FROM host2_data;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH
+    host1_data(ts, host, cpu) AS (TQL EVAL (0, 40, '10s') labels{host="host1"}),
+    host2_data(ts, host, cpu) AS (TQL EVAL (0, 40, '10s') labels{host="host2"})
+SELECT 'host1' as source, ts, cpu FROM host1_data
+UNION ALL
+SELECT 'host2' as source, ts, cpu FROM host2_data;
+
 -- Nested CTEs with TQL
 WITH
     base_tql(ts, val) AS (TQL EVAL (0, 40, '10s') metric),
@@ -124,12 +234,33 @@ WITH
     )
 SELECT count(*) as high_values FROM final;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH
+    base_tql(ts, val) AS (TQL EVAL (0, 40, '10s') metric),
+    processed(ts, percent) AS (
+        SELECT ts, val * 100 as percent
+        FROM base_tql
+        WHERE val > 0
+    ),
+    final(ts, percent) AS (
+        SELECT * FROM processed WHERE percent > 200
+    )
+SELECT count(*) as high_values FROM final;
+
 -- TQL CTE with time-based functions
 WITH time_shifted AS (
     TQL EVAL (0, 40, '10s') metric offset 50s
 )
 SELECT * FROM time_shifted;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH time_shifted AS (
+    TQL EVAL (0, 40, '10s') metric offset 50s
+)
+SELECT * FROM time_shifted;
+
 -- TQL CTE with JOIN between TQL and regular table
 -- SQLNESS SORT_RESULT 3 1
 WITH tql_summary(ts, host, cpu) AS (
@@ -145,23 +276,89 @@ WHERE l.host = 'host1'
 ORDER BY t.ts, l.host, avg_value
 LIMIT 5;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_summary(ts, host, cpu) AS (
+    TQL EVAL (0, 40, '10s') avg_over_time(labels[30s])
+)
+SELECT
+    t.ts,
+    t.cpu as avg_value,
+    l.host
+FROM tql_summary t
+JOIN labels l ON DATE_TRUNC('second', t.ts) = DATE_TRUNC('second', l.ts)
+WHERE l.host = 'host1'
+ORDER BY t.ts, l.host, avg_value
+LIMIT 5;
+
+-- TQL CTE with JOIN and value aliasing
+-- SQLNESS SORT_RESULT 3 1
+WITH tql_summary AS (
+    TQL EVAL (0, 40, '10s') avg_over_time(labels[30s]) AS cpu
+)
+SELECT
+    t.ts,
+    t.cpu as avg_value,
+    l.host
+FROM tql_summary t
+JOIN labels l ON DATE_TRUNC('second', t.ts) = DATE_TRUNC('second', l.ts)
+WHERE l.host = 'host1'
+ORDER BY t.ts, l.host, avg_value
+LIMIT 5;
+
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_summary AS (
+    TQL EVAL (0, 40, '10s') avg_over_time(labels[30s]) AS cpu
+)
+SELECT
+    t.ts,
+    t.cpu as avg_value,
+    l.host
+FROM tql_summary t
+JOIN labels l ON DATE_TRUNC('second', t.ts) = DATE_TRUNC('second', l.ts)
+WHERE l.host = 'host1'
+ORDER BY t.ts, l.host, avg_value
+LIMIT 5;
+
 -- Error case - TQL ANALYZE should fail
 WITH tql_analyze AS (
     TQL ANALYZE (0, 40, '10s') metric
 )
 SELECT * FROM tql_analyze limit 1;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_analyze AS (
+    TQL ANALYZE (0, 40, '10s') metric
+)
+SELECT * FROM tql_analyze limit 1;
+
 -- Error case - TQL EXPLAIN should fail
 WITH tql_explain AS (
     TQL EXPLAIN (0, 40, '10s') metric
 )
 SELECT * FROM tql_explain limit 1;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_explain AS (
+    TQL EXPLAIN (0, 40, '10s') metric
+)
+SELECT * FROM tql_explain limit 1;
+
 -- TQL CTE with lookback parameter
 WITH tql_lookback AS (
     TQL EVAL (0, 40, '10s', '15s') metric
 )
 SELECT count(*) FROM tql_lookback;
 
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+EXPLAIN WITH tql_lookback AS (
+    TQL EVAL (0, 40, '10s', '15s') metric
+)
+SELECT count(*) FROM tql_lookback;
+
 drop table metric;
 drop table labels;
diff --git a/tests/compat/util.sh b/tests/compat/util.sh
index 3158e7ecd7..94ec7ea3a2 100755
--- a/tests/compat/util.sh
+++ b/tests/compat/util.sh
@@ -64,19 +64,19 @@ run_test() {
     then
         echo " === Running forward compat test ..."
         echo " === Run test: write with current GreptimeDB"
-        $runner --bins-dir $(dirname $bin_new) --case-dir $write_case_dir
+        $runner bare --bins-dir $(dirname $bin_new) --case-dir $write_case_dir
     else
         echo " === Running backward compat test ..."
         echo " === Run test: write with old GreptimeDB"
-        $runner --bins-dir $(dirname $bin_old) --case-dir $write_case_dir
+        $runner bare --bins-dir $(dirname $bin_old) --case-dir $write_case_dir
     fi
 
     if [ "$forward" == 'forward' ]
     then
         echo " === Run test: read with old GreptimeDB"
-        $runner --bins-dir $(dirname $bin_old) --case-dir $read_case_dir
+        $runner bare --bins-dir $(dirname $bin_old) --case-dir $read_case_dir
     else
         echo " === Run test: read with current GreptimeDB"
-        $runner --bins-dir $(dirname $bin_new) --case-dir $read_case_dir
+        $runner bare --bins-dir $(dirname $bin_new) --case-dir $read_case_dir
     fi
 }
diff --git a/tests/runner/src/client.rs b/tests/runner/src/client.rs
new file mode 100644
index 0000000000..163e827e53
--- /dev/null
+++ b/tests/runner/src/client.rs
@@ -0,0 +1,235 @@
+// 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::net::SocketAddr;
+use std::time::Duration;
+
+use client::error::ServerSnafu;
+use client::{
+    Client, DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, Database, OutputData, RecordBatches,
+};
+use common_error::ext::ErrorExt;
+use common_query::Output;
+use mysql::prelude::Queryable;
+use mysql::{Conn as MySqlClient, Row as MySqlRow};
+use tokio_postgres::{Client as PgClient, SimpleQueryMessage as PgRow};
+
+use crate::util::retry_with_backoff;
+
+/// A client that can connect to GreptimeDB using multiple protocols.
+pub struct MultiProtocolClient {
+    grpc_client: Database,
+    pg_client: PgClient,
+    mysql_client: MySqlClient,
+}
+
+/// The result of a MySQL query.
+pub enum MysqlSqlResult {
+    AffectedRows(u64),
+    Rows(Vec<MySqlRow>),
+}
+
+impl MultiProtocolClient {
+    /// Connect to the GreptimeDB server using multiple protocols.
+    ///
+    /// # Arguments
+    ///
+    /// * `grpc_server_addr` - The address of the GreptimeDB server.
+    /// * `pg_server_addr` - The address of the Postgres server.
+    /// * `mysql_server_addr` - The address of the MySQL server.
+    ///
+    /// # Returns
+    ///
+    /// A `MultiProtocolClient` instance.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the server addresses are invalid or the connection fails.
+    pub async fn connect(
+        grpc_server_addr: &str,
+        pg_server_addr: &str,
+        mysql_server_addr: &str,
+    ) -> MultiProtocolClient {
+        let grpc_client = Database::new(
+            DEFAULT_CATALOG_NAME,
+            DEFAULT_SCHEMA_NAME,
+            Client::with_urls(vec![grpc_server_addr]),
+        );
+        let pg_client = create_postgres_client(pg_server_addr).await;
+        let mysql_client = create_mysql_client(mysql_server_addr).await;
+        MultiProtocolClient {
+            grpc_client,
+            pg_client,
+            mysql_client,
+        }
+    }
+
+    /// Reconnect the MySQL client.
+    pub async fn reconnect_mysql_client(&mut self, mysql_server_addr: &str) {
+        self.mysql_client = create_mysql_client(mysql_server_addr).await;
+    }
+
+    /// Reconnect the Postgres client.
+    pub async fn reconnect_pg_client(&mut self, pg_server_addr: &str) {
+        self.pg_client = create_postgres_client(pg_server_addr).await;
+    }
+
+    /// Execute a query on the Postgres server.
+    pub async fn postgres_query(&mut self, query: &str) -> Result<Vec<PgRow>, String> {
+        match self.pg_client.simple_query(query).await {
+            Ok(rows) => Ok(rows),
+            Err(e) => Err(format!("Failed to execute query, encountered: {:?}", e)),
+        }
+    }
+
+    /// Execute a query on the MySQL server.
+    pub async fn mysql_query(&mut self, query: &str) -> Result<MysqlSqlResult, String> {
+        let result = self.mysql_client.query_iter(query);
+        match result {
+            Ok(result) => {
+                let mut rows = vec![];
+                let affected_rows = result.affected_rows();
+                for row in result {
+                    match row {
+                        Ok(r) => rows.push(r),
+                        Err(e) => {
+                            return Err(format!("Failed to parse query result, err: {:?}", e));
+                        }
+                    }
+                }
+
+                if rows.is_empty() {
+                    Ok(MysqlSqlResult::AffectedRows(affected_rows))
+                } else {
+                    Ok(MysqlSqlResult::Rows(rows))
+                }
+            }
+            Err(e) => Err(format!("Failed to execute query, err: {:?}", e)),
+        }
+    }
+
+    /// Execute a query on the GreptimeDB server.
+    pub async fn grpc_query(&mut self, query: &str) -> Result<Output, client::Error> {
+        let query_str = query.trim().to_lowercase();
+        if query_str.starts_with("use ") {
+            // use [db]
+            let database = query
+                .split_ascii_whitespace()
+                .nth(1)
+                .expect("Illegal `USE` statement: expecting a database.")
+                .trim_end_matches(';');
+            self.grpc_client.set_schema(database);
+            Ok(Output::new_with_affected_rows(0))
+        } else if query_str.starts_with("set time_zone")
+            || query_str.starts_with("set session time_zone")
+            || query_str.starts_with("set local time_zone")
+        {
+            // set time_zone='xxx'
+            let timezone = query
+                .split('=')
+                .nth(1)
+                .expect("Illegal `SET TIMEZONE` statement: expecting a timezone expr.")
+                .trim()
+                .strip_prefix('\'')
+                .unwrap()
+                .strip_suffix("';")
+                .unwrap();
+
+            self.grpc_client.set_timezone(timezone);
+            Ok(Output::new_with_affected_rows(0))
+        } else {
+            let mut result = self.grpc_client.sql(&query).await;
+            if let Ok(Output {
+                data: OutputData::Stream(stream),
+                ..
+            }) = result
+            {
+                match RecordBatches::try_collect(stream).await {
+                    Ok(recordbatches) => {
+                        result = Ok(Output::new_with_record_batches(recordbatches));
+                    }
+                    Err(e) => {
+                        let status_code = e.status_code();
+                        let msg = e.output_msg();
+                        result = ServerSnafu {
+                            code: status_code,
+                            msg,
+                        }
+                        .fail();
+                    }
+                }
+            }
+
+            result
+        }
+    }
+}
+
+/// Create a Postgres client with retry.
+///
+/// # Panics
+///
+/// Panics if the Postgres server address is invalid or the connection fails.
+async fn create_postgres_client(pg_server_addr: &str) -> PgClient {
+    let sockaddr: SocketAddr = pg_server_addr.parse().unwrap_or_else(|_| {
+        panic!("Failed to parse the Postgres server address {pg_server_addr}. Please check if the address is in the format of `ip:port`.")
+    });
+    let mut config = tokio_postgres::config::Config::new();
+    config.host(sockaddr.ip().to_string());
+    config.port(sockaddr.port());
+    config.dbname(DEFAULT_SCHEMA_NAME);
+
+    retry_with_backoff(
+        || async {
+            config
+                .connect(tokio_postgres::NoTls)
+                .await
+                .map(|(client, conn)| {
+                    tokio::spawn(conn);
+                    client
+                })
+        },
+        3,
+        Duration::from_millis(500),
+    )
+    .await
+    .unwrap_or_else(|_| {
+        panic!("Failed to connect to Postgres server. Please check if the server is running.")
+    })
+}
+
+/// Create a MySQL client with retry.
+///
+/// # Panics
+///
+/// Panics if the MySQL server address is invalid or the connection fails.
+async fn create_mysql_client(mysql_server_addr: &str) -> MySqlClient {
+    let sockaddr: SocketAddr = mysql_server_addr.parse().unwrap_or_else(|_| {
+        panic!("Failed to parse the MySQL server address {mysql_server_addr}. Please check if the address is in the format of `ip:port`.")
+    });
+    let ops = mysql::OptsBuilder::new()
+        .ip_or_hostname(Some(sockaddr.ip().to_string()))
+        .tcp_port(sockaddr.port())
+        .db_name(Some(DEFAULT_SCHEMA_NAME));
+
+    retry_with_backoff(
+        || async { mysql::Conn::new(ops.clone()) },
+        3,
+        Duration::from_millis(500),
+    )
+    .await
+    .unwrap_or_else(|_| {
+        panic!("Failed to connect to MySQL server. Please check if the server is running.")
+    })
+}
diff --git a/tests/runner/src/cmd.rs b/tests/runner/src/cmd.rs
new file mode 100644
index 0000000000..f7aaacfc73
--- /dev/null
+++ b/tests/runner/src/cmd.rs
@@ -0,0 +1,54 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pub(crate) mod bare;
+pub(crate) mod kube;
+
+use std::path::PathBuf;
+
+use bare::BareCommand;
+use clap::Parser;
+use kube::KubeCommand;
+
+#[derive(Parser)]
+#[clap(author, version, about, long_about = None)]
+pub struct Command {
+    #[clap(subcommand)]
+    pub subcmd: SubCommand,
+}
+
+#[derive(Parser)]
+pub enum SubCommand {
+    Bare(BareCommand),
+    Kube(KubeCommand),
+}
+
+#[derive(Debug, Parser)]
+pub struct SqlnessConfig {
+    /// Directory of test cases
+    #[clap(short, long)]
+    pub case_dir: Option<PathBuf>,
+
+    /// Fail this run as soon as one case fails if true
+    #[arg(short, long, default_value = "false")]
+    pub fail_fast: bool,
+
+    /// Environment Configuration File
+    #[clap(short, long, default_value = "config.toml")]
+    pub env_config_file: String,
+
+    /// Name of test cases to run. Accept as a regexp.
+    #[clap(short, long, default_value = ".*")]
+    pub test_filter: String,
+}
diff --git a/tests/runner/src/cmd/bare.rs b/tests/runner/src/cmd/bare.rs
new file mode 100644
index 0000000000..bc9f00bf0d
--- /dev/null
+++ b/tests/runner/src/cmd/bare.rs
@@ -0,0 +1,206 @@
+// 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::path::PathBuf;
+use std::sync::Arc;
+
+use clap::{Parser, ValueEnum};
+use sqlness::interceptor::Registry;
+use sqlness::{ConfigBuilder, Runner};
+
+use crate::cmd::SqlnessConfig;
+use crate::env::bare::{Env, ServiceProvider, StoreConfig, WalConfig};
+use crate::{protocol_interceptor, util};
+
+#[derive(ValueEnum, Debug, Clone)]
+#[clap(rename_all = "snake_case")]
+enum Wal {
+    RaftEngine,
+    Kafka,
+}
+
+// add a group to ensure that all server addresses are set together
+#[derive(clap::Args, Debug, Clone, Default)]
+pub(crate) struct ServerAddr {
+    /// Address of the grpc server.
+    #[clap(short, long)]
+    pub(crate) server_addr: Option<String>,
+
+    /// Address of the postgres server. Must be set if server_addr is set.
+    #[clap(short, long, requires = "server_addr")]
+    pub(crate) pg_server_addr: Option<String>,
+
+    /// Address of the mysql server. Must be set if server_addr is set.
+    #[clap(short, long, requires = "server_addr")]
+    pub(crate) mysql_server_addr: Option<String>,
+}
+
+#[derive(Debug, Parser)]
+/// Run sqlness tests in bare mode.
+pub struct BareCommand {
+    #[clap(flatten)]
+    config: SqlnessConfig,
+
+    /// Addresses of the server.
+    #[command(flatten)]
+    server_addr: ServerAddr,
+
+    /// The type of Wal.
+    #[clap(short, long, default_value = "raft_engine")]
+    wal: Wal,
+
+    /// The kafka wal broker endpoints. This config will suppress sqlness runner
+    /// from starting a kafka cluster, and use the given endpoint as kafka backend.
+    #[clap(short, long)]
+    kafka_wal_broker_endpoints: Option<String>,
+
+    /// The path to the directory where GreptimeDB's binaries resides.
+    /// If not set, sqlness will build GreptimeDB on the fly.
+    #[clap(long)]
+    bins_dir: Option<PathBuf>,
+
+    /// Preserve persistent state in the temporary directory.
+    /// This may affect future test runs.
+    #[clap(long)]
+    preserve_state: bool,
+
+    /// Pull Different versions of GreptimeDB on need.
+    #[clap(long, default_value = "true")]
+    pull_version_on_need: bool,
+
+    /// The store addresses for metadata, if empty, will use memory store.
+    #[clap(long)]
+    store_addrs: Vec<String>,
+
+    /// Whether to setup etcd, by default it is false.
+    #[clap(long, default_value = "false")]
+    setup_etcd: bool,
+
+    /// Whether to setup pg, by default it is false.
+    #[clap(long, default_missing_value = "", num_args(0..=1))]
+    setup_pg: Option<ServiceProvider>,
+
+    /// Whether to setup mysql, by default it is false.
+    #[clap(long, default_missing_value = "", num_args(0..=1))]
+    setup_mysql: Option<ServiceProvider>,
+
+    /// The number of jobs to run in parallel. Default to half of the cores.
+    #[clap(short, long, default_value = "0")]
+    jobs: usize,
+
+    /// Extra command line arguments when starting GreptimeDB binaries.
+    #[clap(long)]
+    extra_args: Vec<String>,
+}
+
+impl BareCommand {
+    pub async fn run(mut self) {
+        let temp_dir = tempfile::Builder::new()
+            .prefix("sqlness")
+            .tempdir()
+            .unwrap();
+        let sqlness_home = temp_dir.keep();
+
+        let mut interceptor_registry: Registry = Default::default();
+        interceptor_registry.register(
+            protocol_interceptor::PREFIX,
+            Arc::new(protocol_interceptor::ProtocolInterceptorFactory),
+        );
+
+        if let Some(d) = &self.config.case_dir
+            && !d.is_dir()
+        {
+            panic!("{} is not a directory", d.display());
+        }
+        if self.jobs == 0 {
+            self.jobs = num_cpus::get() / 2;
+        }
+
+        // normalize parallelism to 1 if any of the following conditions are met:
+        // Note: parallelism in pg and mysql is possible, but need configuration.
+        if self.server_addr.server_addr.is_some()
+            || self.setup_etcd
+            || self.setup_pg.is_some()
+            || self.setup_mysql.is_some()
+            || self.kafka_wal_broker_endpoints.is_some()
+            || self.config.test_filter != ".*"
+        {
+            self.jobs = 1;
+            println!(
+                "Normalizing parallelism to 1 due to server addresses, etcd/pg/mysql setup, or test filter usage"
+            );
+        }
+
+        let config = ConfigBuilder::default()
+            .case_dir(util::get_case_dir(self.config.case_dir))
+            .fail_fast(self.config.fail_fast)
+            .test_filter(self.config.test_filter)
+            .follow_links(true)
+            .env_config_file(self.config.env_config_file)
+            .interceptor_registry(interceptor_registry)
+            .parallelism(self.jobs)
+            .build()
+            .unwrap();
+
+        let wal = match self.wal {
+            Wal::RaftEngine => WalConfig::RaftEngine,
+            Wal::Kafka => WalConfig::Kafka {
+                needs_kafka_cluster: self.kafka_wal_broker_endpoints.is_none(),
+                broker_endpoints: self
+                    .kafka_wal_broker_endpoints
+                    .map(|s| s.split(',').map(|s| s.to_string()).collect())
+                    // otherwise default to the same port in `kafka-cluster.yml`
+                    .unwrap_or(vec!["127.0.0.1:9092".to_string()]),
+            },
+        };
+
+        let store = StoreConfig {
+            store_addrs: self.store_addrs.clone(),
+            setup_etcd: self.setup_etcd,
+            setup_pg: self.setup_pg,
+            setup_mysql: self.setup_mysql,
+        };
+
+        let runner = Runner::new(
+            config,
+            Env::new(
+                sqlness_home.clone(),
+                self.server_addr,
+                wal,
+                self.pull_version_on_need,
+                self.bins_dir,
+                store,
+                self.extra_args,
+            ),
+        );
+        match runner.run().await {
+            Ok(_) => println!("\x1b[32mAll sqlness tests passed!\x1b[0m"),
+            Err(e) => {
+                println!("\x1b[31mTest failed: {}\x1b[0m", e);
+                std::process::exit(1);
+            }
+        }
+
+        // clean up and exit
+        if !self.preserve_state {
+            if self.setup_etcd {
+                println!("Stopping etcd");
+                util::stop_rm_etcd();
+            }
+            // TODO(weny): remove postgre and mysql containers
+            println!("Removing state in {:?}", sqlness_home);
+            tokio::fs::remove_dir_all(sqlness_home).await.unwrap();
+        }
+    }
+}
diff --git a/tests/runner/src/cmd/kube.rs b/tests/runner/src/cmd/kube.rs
new file mode 100644
index 0000000000..650ed690b2
--- /dev/null
+++ b/tests/runner/src/cmd/kube.rs
@@ -0,0 +1,95 @@
+// 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 clap::Parser;
+use sqlness::interceptor::Registry;
+use sqlness::{ConfigBuilder, Runner};
+
+use crate::cmd::SqlnessConfig;
+use crate::env::kube::{Env, NaiveResourcesManager};
+use crate::{protocol_interceptor, util};
+
+#[derive(Debug, Parser)]
+/// Run sqlness tests in kube mode.
+pub struct KubeCommand {
+    #[clap(flatten)]
+    config: SqlnessConfig,
+
+    /// Whether to delete the namespace on stop.
+    #[clap(long, default_value = "false")]
+    delete_namespace_on_stop: bool,
+
+    /// Address of the grpc server.
+    #[clap(short, long)]
+    server_addr: String,
+
+    /// Address of the postgres server. Must be set if server_addr is set.
+    #[clap(short, long)]
+    pg_server_addr: String,
+
+    /// Address of the mysql server. Must be set if server_addr is set.
+    #[clap(short, long)]
+    mysql_server_addr: String,
+
+    /// The namespace of the GreptimeDB.
+    #[clap(short, long)]
+    namespace: String,
+}
+
+impl KubeCommand {
+    pub async fn run(self) {
+        let mut interceptor_registry: Registry = Default::default();
+        interceptor_registry.register(
+            protocol_interceptor::PREFIX,
+            Arc::new(protocol_interceptor::ProtocolInterceptorFactory),
+        );
+
+        if let Some(d) = &self.config.case_dir
+            && !d.is_dir()
+        {
+            panic!("{} is not a directory", d.display());
+        }
+
+        let config = ConfigBuilder::default()
+            .case_dir(util::get_case_dir(self.config.case_dir))
+            .fail_fast(self.config.fail_fast)
+            .test_filter(self.config.test_filter)
+            .follow_links(true)
+            .env_config_file(self.config.env_config_file)
+            .interceptor_registry(interceptor_registry)
+            .build()
+            .unwrap();
+
+        let runner = Runner::new(
+            config,
+            Env {
+                delete_namespace_on_stop: self.delete_namespace_on_stop,
+                server_addr: self.server_addr,
+                pg_server_addr: self.pg_server_addr,
+                mysql_server_addr: self.mysql_server_addr,
+                database_manager: Arc::new(()),
+                resources_manager: Arc::new(NaiveResourcesManager::new(self.namespace)),
+            },
+        );
+        match runner.run().await {
+            Ok(_) => println!("\x1b[32mAll sqlness tests passed!\x1b[0m"),
+            Err(e) => {
+                println!("\x1b[31mTest failed: {}\x1b[0m", e);
+                std::process::exit(1);
+            }
+        }
+    }
+}
diff --git a/tests/runner/src/env.rs b/tests/runner/src/env.rs
index 1a329f6756..e9a9d05fe8 100644
--- a/tests/runner/src/env.rs
+++ b/tests/runner/src/env.rs
@@ -12,1024 +12,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::borrow::Cow;
-use std::collections::HashMap;
-use std::fmt::Display;
-use std::fs::OpenOptions;
-use std::io;
-use std::io::Write;
-use std::net::SocketAddr;
-use std::path::{Path, PathBuf};
-use std::process::{Child, Command};
-use std::sync::atomic::{AtomicU32, Ordering};
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-
-use async_trait::async_trait;
-use client::error::ServerSnafu;
-use client::{
-    Client, DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, Database as DB, Error as ClientError,
-};
-use common_error::ext::ErrorExt;
-use common_query::{Output, OutputData};
-use common_recordbatch::RecordBatches;
-use datatypes::data_type::ConcreteDataType;
-use datatypes::scalars::ScalarVectorBuilder;
-use datatypes::schema::{ColumnSchema, Schema};
-use datatypes::vectors::{StringVectorBuilder, VectorRef};
-use mysql::prelude::Queryable;
-use mysql::{Conn as MySqlClient, Row as MySqlRow};
-use sqlness::{Database, EnvController, QueryContext};
-use tokio::sync::Mutex as TokioMutex;
-use tokio_postgres::{Client as PgClient, SimpleQueryMessage as PgRow};
-
-use crate::protocol_interceptor::{MYSQL, PROTOCOL_KEY};
-use crate::server_mode::ServerMode;
-use crate::util::{PROGRAM, get_workspace_root, maybe_pull_binary};
-use crate::{ServerAddr, util};
-
-// standalone mode
-const SERVER_MODE_STANDALONE_IDX: usize = 0;
-// distributed mode
-const SERVER_MODE_METASRV_IDX: usize = 0;
-const SERVER_MODE_DATANODE_START_IDX: usize = 1;
-const SERVER_MODE_FRONTEND_IDX: usize = 4;
-const SERVER_MODE_FLOWNODE_IDX: usize = 5;
-
-#[derive(Clone)]
-pub enum WalConfig {
-    RaftEngine,
-    Kafka {
-        /// Indicates whether the runner needs to start a kafka cluster
-        /// (it might be available in the external system environment).
-        needs_kafka_cluster: bool,
-        broker_endpoints: Vec<String>,
-    },
-}
-
-#[derive(Debug, Clone)]
-pub(crate) enum ServiceProvider {
-    Create,
-    External(String),
-}
-
-impl From<&str> for ServiceProvider {
-    fn from(value: &str) -> Self {
-        if value.is_empty() {
-            Self::Create
-        } else {
-            Self::External(value.to_string())
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct StoreConfig {
-    pub store_addrs: Vec<String>,
-    pub setup_etcd: bool,
-    pub(crate) setup_pg: Option<ServiceProvider>,
-    pub(crate) setup_mysql: Option<ServiceProvider>,
-}
-
-#[derive(Clone)]
-pub struct Env {
-    sqlness_home: PathBuf,
-    server_addrs: ServerAddr,
-    wal: WalConfig,
-
-    /// The path to the directory that contains the pre-built GreptimeDB binary.
-    /// When running in CI, this is expected to be set.
-    /// If not set, this runner will build the GreptimeDB binary itself when needed, and set this field by then.
-    bins_dir: Arc<Mutex<Option<PathBuf>>>,
-    /// The path to the directory that contains the old pre-built GreptimeDB binaries.
-    versioned_bins_dirs: Arc<Mutex<HashMap<String, PathBuf>>>,
-    /// Pull different versions of GreptimeDB on need.
-    pull_version_on_need: bool,
-    /// Store address for metasrv metadata
-    store_config: StoreConfig,
-    /// Extra command line arguments when starting GreptimeDB binaries.
-    extra_args: Vec<String>,
-}
-
-#[async_trait]
-impl EnvController for Env {
-    type DB = GreptimeDB;
-
-    async fn start(&self, mode: &str, id: usize, _config: Option<&Path>) -> Self::DB {
-        if self.server_addrs.server_addr.is_some() && id > 0 {
-            panic!("Parallel test mode is not supported when server address is already set.");
-        }
-
-        unsafe {
-            std::env::set_var("SQLNESS_HOME", self.sqlness_home.display().to_string());
-        }
-        match mode {
-            "standalone" => self.start_standalone(id).await,
-            "distributed" => self.start_distributed(id).await,
-            _ => panic!("Unexpected mode: {mode}"),
-        }
-    }
-
-    /// Stop one [`Database`].
-    async fn stop(&self, _mode: &str, mut database: Self::DB) {
-        database.stop();
-    }
-}
-
-impl Env {
-    pub fn new(
-        data_home: PathBuf,
-        server_addrs: ServerAddr,
-        wal: WalConfig,
-        pull_version_on_need: bool,
-        bins_dir: Option<PathBuf>,
-        store_config: StoreConfig,
-        extra_args: Vec<String>,
-    ) -> Self {
-        Self {
-            sqlness_home: data_home,
-            server_addrs,
-            wal,
-            pull_version_on_need,
-            bins_dir: Arc::new(Mutex::new(bins_dir.clone())),
-            versioned_bins_dirs: Arc::new(Mutex::new(HashMap::from_iter([(
-                "latest".to_string(),
-                bins_dir.clone().unwrap_or(util::get_binary_dir("debug")),
-            )]))),
-            store_config,
-            extra_args,
-        }
-    }
-
-    async fn start_standalone(&self, id: usize) -> GreptimeDB {
-        println!("Starting standalone instance id: {id}");
-
-        if self.server_addrs.server_addr.is_some() {
-            self.connect_db(&self.server_addrs, id).await
-        } else {
-            self.build_db();
-            self.setup_wal();
-            let mut db_ctx = GreptimeDBContext::new(self.wal.clone(), self.store_config.clone());
-
-            let server_mode = ServerMode::random_standalone();
-            db_ctx.set_server_mode(server_mode.clone(), SERVER_MODE_STANDALONE_IDX);
-            let server_addr = server_mode.server_addr().unwrap();
-            let server_process = self.start_server(server_mode, &db_ctx, id, true).await;
-
-            let mut greptimedb = self.connect_db(&server_addr, id).await;
-            greptimedb.server_processes = Some(Arc::new(Mutex::new(vec![server_process])));
-            greptimedb.is_standalone = true;
-            greptimedb.ctx = db_ctx;
-
-            greptimedb
-        }
-    }
-
-    async fn start_distributed(&self, id: usize) -> GreptimeDB {
-        if self.server_addrs.server_addr.is_some() {
-            self.connect_db(&self.server_addrs, id).await
-        } else {
-            self.build_db();
-            self.setup_wal();
-            self.setup_etcd();
-            self.setup_pg();
-            self.setup_mysql().await;
-            let mut db_ctx = GreptimeDBContext::new(self.wal.clone(), self.store_config.clone());
-
-            // start a distributed GreptimeDB
-            let meta_server_mode = ServerMode::random_metasrv();
-            let metasrv_port = match &meta_server_mode {
-                ServerMode::Metasrv {
-                    rpc_server_addr, ..
-                } => rpc_server_addr
-                    .split(':')
-                    .nth(1)
-                    .unwrap()
-                    .parse::<u16>()
-                    .unwrap(),
-                _ => panic!(
-                    "metasrv mode not set, maybe running in remote mode which doesn't support restart?"
-                ),
-            };
-            db_ctx.set_server_mode(meta_server_mode.clone(), SERVER_MODE_METASRV_IDX);
-            let meta_server = self.start_server(meta_server_mode, &db_ctx, id, true).await;
-
-            let datanode_1_mode = ServerMode::random_datanode(metasrv_port, 0);
-            db_ctx.set_server_mode(datanode_1_mode.clone(), SERVER_MODE_DATANODE_START_IDX);
-            let datanode_1 = self.start_server(datanode_1_mode, &db_ctx, id, true).await;
-            let datanode_2_mode = ServerMode::random_datanode(metasrv_port, 1);
-            db_ctx.set_server_mode(datanode_2_mode.clone(), SERVER_MODE_DATANODE_START_IDX + 1);
-            let datanode_2 = self.start_server(datanode_2_mode, &db_ctx, id, true).await;
-            let datanode_3_mode = ServerMode::random_datanode(metasrv_port, 2);
-            db_ctx.set_server_mode(datanode_3_mode.clone(), SERVER_MODE_DATANODE_START_IDX + 2);
-            let datanode_3 = self.start_server(datanode_3_mode, &db_ctx, id, true).await;
-
-            let frontend_mode = ServerMode::random_frontend(metasrv_port);
-            let server_addr = frontend_mode.server_addr().unwrap();
-            db_ctx.set_server_mode(frontend_mode.clone(), SERVER_MODE_FRONTEND_IDX);
-            let frontend = self.start_server(frontend_mode, &db_ctx, id, true).await;
-
-            let flownode_mode = ServerMode::random_flownode(metasrv_port, 0);
-            db_ctx.set_server_mode(flownode_mode.clone(), SERVER_MODE_FLOWNODE_IDX);
-            let flownode = self.start_server(flownode_mode, &db_ctx, id, true).await;
-
-            let mut greptimedb = self.connect_db(&server_addr, id).await;
-
-            greptimedb.metasrv_process = Some(meta_server).into();
-            greptimedb.server_processes = Some(Arc::new(Mutex::new(vec![
-                datanode_1, datanode_2, datanode_3,
-            ])));
-            greptimedb.frontend_process = Some(frontend).into();
-            greptimedb.flownode_process = Some(flownode).into();
-            greptimedb.is_standalone = false;
-            greptimedb.ctx = db_ctx;
-
-            greptimedb
-        }
-    }
-
-    async fn create_pg_client(&self, pg_server_addr: &str) -> PgClient {
-        let sockaddr: SocketAddr = pg_server_addr.parse().expect(
-            "Failed to parse the Postgres server address. Please check if the address is in the format of `ip:port`.",
-        );
-        let mut config = tokio_postgres::config::Config::new();
-        config.host(sockaddr.ip().to_string());
-        config.port(sockaddr.port());
-        config.dbname(DEFAULT_SCHEMA_NAME);
-
-        // retry to connect to Postgres server until success
-        const MAX_RETRY: usize = 3;
-        let mut backoff = Duration::from_millis(500);
-        for _ in 0..MAX_RETRY {
-            if let Ok((pg_client, conn)) = config.connect(tokio_postgres::NoTls).await {
-                tokio::spawn(conn);
-                return pg_client;
-            }
-            tokio::time::sleep(backoff).await;
-            backoff *= 2;
-        }
-        panic!("Failed to connect to Postgres server. Please check if the server is running.");
-    }
-
-    async fn create_mysql_client(&self, mysql_server_addr: &str) -> MySqlClient {
-        let sockaddr: SocketAddr = mysql_server_addr.parse().expect(
-            "Failed to parse the MySQL server address. Please check if the address is in the format of `ip:port`.",
-        );
-        let ops = mysql::OptsBuilder::new()
-            .ip_or_hostname(Some(sockaddr.ip().to_string()))
-            .tcp_port(sockaddr.port())
-            .db_name(Some(DEFAULT_SCHEMA_NAME));
-        // retry to connect to MySQL server until success
-        const MAX_RETRY: usize = 3;
-        let mut backoff = Duration::from_millis(500);
-
-        for _ in 0..MAX_RETRY {
-            // exponential backoff
-            if let Ok(client) = mysql::Conn::new(ops.clone()) {
-                return client;
-            }
-            tokio::time::sleep(backoff).await;
-            backoff *= 2;
-        }
-
-        panic!("Failed to connect to MySQL server. Please check if the server is running.")
-    }
-
-    async fn connect_db(&self, server_addr: &ServerAddr, id: usize) -> GreptimeDB {
-        let grpc_server_addr = server_addr.server_addr.clone().unwrap();
-        let pg_server_addr = server_addr.pg_server_addr.clone().unwrap();
-        let mysql_server_addr = server_addr.mysql_server_addr.clone().unwrap();
-
-        let grpc_client = Client::with_urls(vec![grpc_server_addr.clone()]);
-        let db = DB::new(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, grpc_client);
-        let pg_client = self.create_pg_client(&pg_server_addr).await;
-        let mysql_client = self.create_mysql_client(&mysql_server_addr).await;
-
-        GreptimeDB {
-            grpc_client: TokioMutex::new(db),
-            pg_client: TokioMutex::new(pg_client),
-            mysql_client: TokioMutex::new(mysql_client),
-            server_processes: None,
-            metasrv_process: None.into(),
-            frontend_process: None.into(),
-            flownode_process: None.into(),
-            ctx: GreptimeDBContext {
-                time: 0,
-                datanode_id: Default::default(),
-                wal: self.wal.clone(),
-                store_config: self.store_config.clone(),
-                server_modes: Vec::new(),
-            },
-            is_standalone: false,
-            env: self.clone(),
-            id,
-        }
-    }
-
-    fn stop_server(process: &mut Child) {
-        let _ = process.kill();
-        let _ = process.wait();
-    }
-
-    async fn start_server(
-        &self,
-        mode: ServerMode,
-        db_ctx: &GreptimeDBContext,
-        id: usize,
-        truncate_log: bool,
-    ) -> Child {
-        let log_file_name = match mode {
-            ServerMode::Datanode { node_id, .. } => {
-                db_ctx.incr_datanode_id();
-                format!("greptime-{}-sqlness-datanode-{}.log", id, node_id)
-            }
-            ServerMode::Flownode { .. } => format!("greptime-{}-sqlness-flownode.log", id),
-            ServerMode::Frontend { .. } => format!("greptime-{}-sqlness-frontend.log", id),
-            ServerMode::Metasrv { .. } => format!("greptime-{}-sqlness-metasrv.log", id),
-            ServerMode::Standalone { .. } => format!("greptime-{}-sqlness-standalone.log", id),
-        };
-        let stdout_file_name = self.sqlness_home.join(log_file_name).display().to_string();
-
-        println!("DB instance {id} log file at {stdout_file_name}");
-
-        let stdout_file = OpenOptions::new()
-            .create(true)
-            .write(true)
-            .truncate(truncate_log)
-            .append(!truncate_log)
-            .open(stdout_file_name)
-            .unwrap();
-
-        let args = mode.get_args(&self.sqlness_home, self, db_ctx, id);
-        let check_ip_addrs = mode.check_addrs();
-
-        for check_ip_addr in &check_ip_addrs {
-            if util::check_port(check_ip_addr.parse().unwrap(), Duration::from_secs(1)).await {
-                panic!(
-                    "Port {check_ip_addr} is already in use, please check and retry.",
-                    check_ip_addr = check_ip_addr
-                );
-            }
-        }
-
-        let program = PROGRAM;
-
-        let bins_dir = self.bins_dir.lock().unwrap().clone().expect(
-            "GreptimeDB binary is not available. Please pass in the path to the directory that contains the pre-built GreptimeDB binary. Or you may call `self.build_db()` beforehand.",
-        );
-
-        let abs_bins_dir = bins_dir
-            .canonicalize()
-            .expect("Failed to canonicalize bins_dir");
-
-        let mut process = Command::new(abs_bins_dir.join(program))
-            .current_dir(bins_dir.clone())
-            .env("TZ", "UTC")
-            .args(args)
-            .stdout(stdout_file)
-            .spawn()
-            .unwrap_or_else(|error| {
-                panic!(
-                    "Failed to start the DB with subcommand {}, Error: {error}, path: {:?}",
-                    mode.name(),
-                    bins_dir.join(program)
-                );
-            });
-
-        for check_ip_addr in &check_ip_addrs {
-            if !util::check_port(check_ip_addr.parse().unwrap(), Duration::from_secs(10)).await {
-                Env::stop_server(&mut process);
-                panic!("{} doesn't up in 10 seconds, quit.", mode.name())
-            }
-        }
-
-        process
-    }
-
-    /// stop and restart the server process
-    async fn restart_server(&self, db: &GreptimeDB, is_full_restart: bool) {
-        {
-            if let Some(server_process) = db.server_processes.clone() {
-                let mut server_processes = server_process.lock().unwrap();
-                for server_process in server_processes.iter_mut() {
-                    Env::stop_server(server_process);
-                }
-            }
-
-            if is_full_restart {
-                if let Some(mut metasrv_process) =
-                    db.metasrv_process.lock().expect("poisoned lock").take()
-                {
-                    Env::stop_server(&mut metasrv_process);
-                }
-                if let Some(mut frontend_process) =
-                    db.frontend_process.lock().expect("poisoned lock").take()
-                {
-                    Env::stop_server(&mut frontend_process);
-                }
-            }
-
-            if let Some(mut flownode_process) =
-                db.flownode_process.lock().expect("poisoned lock").take()
-            {
-                Env::stop_server(&mut flownode_process);
-            }
-        }
-
-        // check if the server is distributed or standalone
-        let new_server_processes = if db.is_standalone {
-            let server_mode = db
-                .ctx
-                .get_server_mode(SERVER_MODE_STANDALONE_IDX)
-                .cloned()
-                .unwrap();
-            let server_addr = server_mode.server_addr().unwrap();
-            let new_server_process = self.start_server(server_mode, &db.ctx, db.id, false).await;
-
-            *db.pg_client.lock().await = self
-                .create_pg_client(&server_addr.pg_server_addr.unwrap())
-                .await;
-            *db.mysql_client.lock().await = self
-                .create_mysql_client(&server_addr.mysql_server_addr.unwrap())
-                .await;
-            vec![new_server_process]
-        } else {
-            db.ctx.reset_datanode_id();
-            if is_full_restart {
-                let metasrv_mode = db
-                    .ctx
-                    .get_server_mode(SERVER_MODE_METASRV_IDX)
-                    .cloned()
-                    .unwrap();
-                let metasrv = self.start_server(metasrv_mode, &db.ctx, db.id, false).await;
-                db.metasrv_process
-                    .lock()
-                    .expect("lock poisoned")
-                    .replace(metasrv);
-
-                // wait for metasrv to start
-                // since it seems older version of db might take longer to complete election
-                tokio::time::sleep(Duration::from_secs(5)).await;
-            }
-
-            let mut processes = vec![];
-            for i in 0..3 {
-                let datanode_mode = db
-                    .ctx
-                    .get_server_mode(SERVER_MODE_DATANODE_START_IDX + i)
-                    .cloned()
-                    .unwrap();
-                let new_server_process = self
-                    .start_server(datanode_mode, &db.ctx, db.id, false)
-                    .await;
-                processes.push(new_server_process);
-            }
-
-            if is_full_restart {
-                let frontend_mode = db
-                    .ctx
-                    .get_server_mode(SERVER_MODE_FRONTEND_IDX)
-                    .cloned()
-                    .unwrap();
-                let frontend = self
-                    .start_server(frontend_mode, &db.ctx, db.id, false)
-                    .await;
-                db.frontend_process
-                    .lock()
-                    .expect("lock poisoned")
-                    .replace(frontend);
-            }
-
-            let flownode_mode = db
-                .ctx
-                .get_server_mode(SERVER_MODE_FLOWNODE_IDX)
-                .cloned()
-                .unwrap();
-            let flownode = self
-                .start_server(flownode_mode, &db.ctx, db.id, false)
-                .await;
-            db.flownode_process
-                .lock()
-                .expect("lock poisoned")
-                .replace(flownode);
-
-            processes
-        };
-
-        if let Some(server_processes) = db.server_processes.clone() {
-            let mut server_processes = server_processes.lock().unwrap();
-            *server_processes = new_server_processes;
-        }
-    }
-
-    /// Setup kafka wal cluster if needed. The counterpart is in [GreptimeDB::stop].
-    fn setup_wal(&self) {
-        if matches!(self.wal, WalConfig::Kafka { needs_kafka_cluster, .. } if needs_kafka_cluster) {
-            util::setup_wal();
-        }
-    }
-
-    /// Setup etcd if needed.
-    fn setup_etcd(&self) {
-        if self.store_config.setup_etcd {
-            let client_ports = self
-                .store_config
-                .store_addrs
-                .iter()
-                .map(|s| s.split(':').nth(1).unwrap().parse::<u16>().unwrap())
-                .collect::<Vec<_>>();
-            util::setup_etcd(client_ports, None, None);
-        }
-    }
-
-    /// Setup PostgreSql if needed.
-    fn setup_pg(&self) {
-        if matches!(self.store_config.setup_pg, Some(ServiceProvider::Create)) {
-            let client_ports = self
-                .store_config
-                .store_addrs
-                .iter()
-                .map(|s| s.split(':').nth(1).unwrap().parse::<u16>().unwrap())
-                .collect::<Vec<_>>();
-            let client_port = client_ports.first().unwrap_or(&5432);
-            util::setup_pg(*client_port, None);
-        }
-    }
-
-    /// Setup MySql if needed.
-    async fn setup_mysql(&self) {
-        if matches!(self.store_config.setup_mysql, Some(ServiceProvider::Create)) {
-            let client_ports = self
-                .store_config
-                .store_addrs
-                .iter()
-                .map(|s| s.split(':').nth(1).unwrap().parse::<u16>().unwrap())
-                .collect::<Vec<_>>();
-            let client_port = client_ports.first().unwrap_or(&3306);
-            util::setup_mysql(*client_port, None);
-
-            // Docker of MySQL starts slowly, so we need to wait for a while
-            tokio::time::sleep(Duration::from_secs(10)).await;
-        }
-    }
-
-    /// Build the DB with `cargo build --bin greptime`
-    fn build_db(&self) {
-        if self.bins_dir.lock().unwrap().is_some() {
-            return;
-        }
-
-        println!("Going to build the DB...");
-        let output = Command::new("cargo")
-            .current_dir(util::get_workspace_root())
-            .args([
-                "build",
-                "--bin",
-                "greptime",
-                "--features",
-                "pg_kvbackend,mysql_kvbackend",
-            ])
-            .output()
-            .expect("Failed to start GreptimeDB");
-        if !output.status.success() {
-            println!("Failed to build GreptimeDB, {}", output.status);
-            println!("Cargo build stdout:");
-            io::stdout().write_all(&output.stdout).unwrap();
-            println!("Cargo build stderr:");
-            io::stderr().write_all(&output.stderr).unwrap();
-            panic!();
-        }
-
-        let _ = self
-            .bins_dir
-            .lock()
-            .unwrap()
-            .insert(util::get_binary_dir("debug"));
-    }
-
-    pub(crate) fn extra_args(&self) -> &Vec<String> {
-        &self.extra_args
-    }
-}
-
-pub struct GreptimeDB {
-    server_processes: Option<Arc<Mutex<Vec<Child>>>>,
-    metasrv_process: Mutex<Option<Child>>,
-    frontend_process: Mutex<Option<Child>>,
-    flownode_process: Mutex<Option<Child>>,
-    grpc_client: TokioMutex<DB>,
-    pg_client: TokioMutex<PgClient>,
-    mysql_client: TokioMutex<MySqlClient>,
-    ctx: GreptimeDBContext,
-    is_standalone: bool,
-    env: Env,
-    id: usize,
-}
-
-impl GreptimeDB {
-    async fn postgres_query(&self, _ctx: QueryContext, query: String) -> Box<dyn Display> {
-        let client = self.pg_client.lock().await;
-        match client.simple_query(&query).await {
-            Ok(rows) => Box::new(PostgresqlFormatter { rows }),
-            Err(e) => Box::new(format!("Failed to execute query, encountered: {:?}", e)),
-        }
-    }
-
-    async fn mysql_query(&self, _ctx: QueryContext, query: String) -> Box<dyn Display> {
-        let mut conn = self.mysql_client.lock().await;
-        let result = conn.query_iter(query);
-        Box::new(match result {
-            Ok(result) => {
-                let mut rows = vec![];
-                let affected_rows = result.affected_rows();
-                for row in result {
-                    match row {
-                        Ok(r) => rows.push(r),
-                        Err(e) => {
-                            return Box::new(format!("Failed to parse query result, err: {:?}", e));
-                        }
-                    }
-                }
-
-                if rows.is_empty() {
-                    format!("affected_rows: {}", affected_rows)
-                } else {
-                    format!("{}", MysqlFormatter { rows })
-                }
-            }
-            Err(e) => format!("Failed to execute query, err: {:?}", e),
-        })
-    }
-
-    async fn grpc_query(&self, _ctx: QueryContext, query: String) -> Box<dyn Display> {
-        let mut client = self.grpc_client.lock().await;
-
-        let query_str = query.trim().to_lowercase();
-
-        if query_str.starts_with("use ") {
-            // use [db]
-            let database = query
-                .split_ascii_whitespace()
-                .nth(1)
-                .expect("Illegal `USE` statement: expecting a database.")
-                .trim_end_matches(';');
-            client.set_schema(database);
-            Box::new(ResultDisplayer {
-                result: Ok(Output::new_with_affected_rows(0)),
-            }) as _
-        } else if query_str.starts_with("set time_zone")
-            || query_str.starts_with("set session time_zone")
-            || query_str.starts_with("set local time_zone")
-        {
-            // set time_zone='xxx'
-            let timezone = query
-                .split('=')
-                .nth(1)
-                .expect("Illegal `SET TIMEZONE` statement: expecting a timezone expr.")
-                .trim()
-                .strip_prefix('\'')
-                .unwrap()
-                .strip_suffix("';")
-                .unwrap();
-
-            client.set_timezone(timezone);
-
-            Box::new(ResultDisplayer {
-                result: Ok(Output::new_with_affected_rows(0)),
-            }) as _
-        } else {
-            let mut result = client.sql(&query).await;
-            if let Ok(Output {
-                data: OutputData::Stream(stream),
-                ..
-            }) = result
-            {
-                match RecordBatches::try_collect(stream).await {
-                    Ok(recordbatches) => {
-                        result = Ok(Output::new_with_record_batches(recordbatches));
-                    }
-                    Err(e) => {
-                        let status_code = e.status_code();
-                        let msg = e.output_msg();
-                        result = ServerSnafu {
-                            code: status_code,
-                            msg,
-                        }
-                        .fail();
-                    }
-                }
-            }
-            Box::new(ResultDisplayer { result }) as _
-        }
-    }
-}
-
-#[async_trait]
-impl Database for GreptimeDB {
-    async fn query(&self, ctx: QueryContext, query: String) -> Box<dyn Display> {
-        if ctx.context.contains_key("restart") && self.env.server_addrs.server_addr.is_none() {
-            self.env.restart_server(self, false).await;
-        } else if let Some(version) = ctx.context.get("version") {
-            let version_bin_dir = self
-                .env
-                .versioned_bins_dirs
-                .lock()
-                .expect("lock poison")
-                .get(version.as_str())
-                .cloned();
-
-            match version_bin_dir {
-                Some(path) if path.clone().join(PROGRAM).is_file() => {
-                    // use version in versioned_bins_dirs
-                    *self.env.bins_dir.lock().unwrap() = Some(path.clone());
-                }
-                _ => {
-                    // use version in dir files
-                    maybe_pull_binary(version, self.env.pull_version_on_need).await;
-                    let root = get_workspace_root();
-                    let new_path = PathBuf::from_iter([&root, version]);
-                    *self.env.bins_dir.lock().unwrap() = Some(new_path);
-                }
-            }
-
-            self.env.restart_server(self, true).await;
-            // sleep for a while to wait for the server to fully boot up
-            tokio::time::sleep(Duration::from_secs(5)).await;
-        }
-
-        if let Some(protocol) = ctx.context.get(PROTOCOL_KEY) {
-            // protocol is bound to be either "mysql" or "postgres"
-            if protocol == MYSQL {
-                self.mysql_query(ctx, query).await
-            } else {
-                self.postgres_query(ctx, query).await
-            }
-        } else {
-            self.grpc_query(ctx, query).await
-        }
-    }
-}
-
-impl GreptimeDB {
-    fn stop(&mut self) {
-        if let Some(server_processes) = self.server_processes.clone() {
-            let mut server_processes = server_processes.lock().unwrap();
-            for mut server_process in server_processes.drain(..) {
-                Env::stop_server(&mut server_process);
-                println!(
-                    "Standalone or Datanode (pid = {}) is stopped",
-                    server_process.id()
-                );
-            }
-        }
-        if let Some(mut metasrv) = self
-            .metasrv_process
-            .lock()
-            .expect("someone else panic when holding lock")
-            .take()
-        {
-            Env::stop_server(&mut metasrv);
-            println!("Metasrv (pid = {}) is stopped", metasrv.id());
-        }
-        if let Some(mut frontend) = self
-            .frontend_process
-            .lock()
-            .expect("someone else panic when holding lock")
-            .take()
-        {
-            Env::stop_server(&mut frontend);
-            println!("Frontend (pid = {}) is stopped", frontend.id());
-        }
-        if let Some(mut flownode) = self
-            .flownode_process
-            .lock()
-            .expect("someone else panic when holding lock")
-            .take()
-        {
-            Env::stop_server(&mut flownode);
-            println!("Flownode (pid = {}) is stopped", flownode.id());
-        }
-        if matches!(self.ctx.wal, WalConfig::Kafka { needs_kafka_cluster, .. } if needs_kafka_cluster)
-        {
-            util::teardown_wal();
-        }
-    }
-}
-
-impl Drop for GreptimeDB {
-    fn drop(&mut self) {
-        if self.env.server_addrs.server_addr.is_none() {
-            self.stop();
-        }
-    }
-}
-
-pub struct GreptimeDBContext {
-    /// Start time in millisecond
-    time: i64,
-    datanode_id: AtomicU32,
-    wal: WalConfig,
-    store_config: StoreConfig,
-    server_modes: Vec<ServerMode>,
-}
-
-impl GreptimeDBContext {
-    pub fn new(wal: WalConfig, store_config: StoreConfig) -> Self {
-        Self {
-            time: common_time::util::current_time_millis(),
-            datanode_id: AtomicU32::new(0),
-            wal,
-            store_config,
-            server_modes: Vec::new(),
-        }
-    }
-
-    pub(crate) fn time(&self) -> i64 {
-        self.time
-    }
-
-    pub fn is_raft_engine(&self) -> bool {
-        matches!(self.wal, WalConfig::RaftEngine)
-    }
-
-    pub fn kafka_wal_broker_endpoints(&self) -> String {
-        match &self.wal {
-            WalConfig::RaftEngine => String::new(),
-            WalConfig::Kafka {
-                broker_endpoints, ..
-            } => serde_json::to_string(&broker_endpoints).unwrap(),
-        }
-    }
-
-    fn incr_datanode_id(&self) {
-        let _ = self.datanode_id.fetch_add(1, Ordering::Relaxed);
-    }
-
-    fn reset_datanode_id(&self) {
-        self.datanode_id.store(0, Ordering::Relaxed);
-    }
-
-    pub(crate) fn store_config(&self) -> StoreConfig {
-        self.store_config.clone()
-    }
-
-    fn set_server_mode(&mut self, mode: ServerMode, idx: usize) {
-        if idx >= self.server_modes.len() {
-            self.server_modes.resize(idx + 1, mode.clone());
-        }
-        self.server_modes[idx] = mode;
-    }
-
-    fn get_server_mode(&self, idx: usize) -> Option<&ServerMode> {
-        self.server_modes.get(idx)
-    }
-}
-
-struct ResultDisplayer {
-    result: Result<Output, ClientError>,
-}
-
-impl Display for ResultDisplayer {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match &self.result {
-            Ok(result) => match &result.data {
-                OutputData::AffectedRows(rows) => {
-                    write!(f, "Affected Rows: {rows}")
-                }
-                OutputData::RecordBatches(recordbatches) => {
-                    let pretty = recordbatches.pretty_print().map_err(|e| e.to_string());
-                    match pretty {
-                        Ok(s) => write!(f, "{s}"),
-                        Err(e) => {
-                            write!(f, "Failed to pretty format {recordbatches:?}, error: {e}")
-                        }
-                    }
-                }
-                OutputData::Stream(_) => unreachable!(),
-            },
-            Err(e) => {
-                let status_code = e.status_code();
-                let root_cause = e.output_msg();
-                write!(
-                    f,
-                    "Error: {}({status_code}), {root_cause}",
-                    status_code as u32
-                )
-            }
-        }
-    }
-}
-
-struct PostgresqlFormatter {
-    pub rows: Vec<PgRow>,
-}
-
-impl Display for PostgresqlFormatter {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.rows.is_empty() {
-            return f.write_fmt(format_args!("(Empty response)"));
-        }
-
-        // create schema
-        let schema = match &self.rows[0] {
-            PgRow::CommandComplete(affected_rows) => {
-                write!(
-                    f,
-                    "{}",
-                    ResultDisplayer {
-                        result: Ok(Output::new_with_affected_rows(*affected_rows as usize)),
-                    }
-                )?;
-                return Ok(());
-            }
-            PgRow::RowDescription(desc) => Arc::new(Schema::new(
-                desc.iter()
-                    .map(|column| {
-                        ColumnSchema::new(column.name(), ConcreteDataType::string_datatype(), true)
-                    })
-                    .collect(),
-            )),
-            _ => unreachable!(),
-        };
-        if schema.num_columns() == 0 {
-            return Ok(());
-        }
-
-        // convert to string vectors
-        let mut columns: Vec<StringVectorBuilder> = (0..schema.num_columns())
-            .map(|_| StringVectorBuilder::with_capacity(schema.num_columns()))
-            .collect();
-        for row in self.rows.iter().skip(1) {
-            if let PgRow::Row(row) = row {
-                for (i, column) in columns.iter_mut().enumerate().take(schema.num_columns()) {
-                    column.push(row.get(i));
-                }
-            }
-        }
-        let columns: Vec<VectorRef> = columns
-            .into_iter()
-            .map(|mut col| Arc::new(col.finish()) as VectorRef)
-            .collect();
-
-        // construct recordbatch
-        let recordbatches = RecordBatches::try_from_columns(schema, columns)
-            .expect("Failed to construct recordbatches from columns. Please check the schema.");
-        let result_displayer = ResultDisplayer {
-            result: Ok(Output::new_with_record_batches(recordbatches)),
-        };
-        write!(f, "{}", result_displayer)?;
-
-        Ok(())
-    }
-}
-
-struct MysqlFormatter {
-    pub rows: Vec<MySqlRow>,
-}
-
-impl Display for MysqlFormatter {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.rows.is_empty() {
-            return f.write_fmt(format_args!("(Empty response)"));
-        }
-        // create schema
-        let head_column = &self.rows[0];
-        let head_binding = head_column.columns();
-        let names = head_binding
-            .iter()
-            .map(|column| column.name_str())
-            .collect::<Vec<Cow<str>>>();
-        let schema = Arc::new(Schema::new(
-            names
-                .iter()
-                .map(|name| {
-                    ColumnSchema::new(name.to_string(), ConcreteDataType::string_datatype(), false)
-                })
-                .collect(),
-        ));
-
-        // convert to string vectors
-        let mut columns: Vec<StringVectorBuilder> = (0..schema.num_columns())
-            .map(|_| StringVectorBuilder::with_capacity(schema.num_columns()))
-            .collect();
-        for row in self.rows.iter() {
-            for (i, name) in names.iter().enumerate() {
-                columns[i].push(row.get::<String, &str>(name).as_deref());
-            }
-        }
-        let columns: Vec<VectorRef> = columns
-            .into_iter()
-            .map(|mut col| Arc::new(col.finish()) as VectorRef)
-            .collect();
-
-        // construct recordbatch
-        let recordbatches = RecordBatches::try_from_columns(schema, columns)
-            .expect("Failed to construct recordbatches from columns. Please check the schema.");
-        let result_displayer = ResultDisplayer {
-            result: Ok(Output::new_with_record_batches(recordbatches)),
-        };
-        write!(f, "{}", result_displayer)?;
-
-        Ok(())
-    }
-}
+pub mod bare;
+pub mod kube;
diff --git a/tests/runner/src/env/bare.rs b/tests/runner/src/env/bare.rs
new file mode 100644
index 0000000000..0644151aaa
--- /dev/null
+++ b/tests/runner/src/env/bare.rs
@@ -0,0 +1,751 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::collections::HashMap;
+use std::fmt::Display;
+use std::fs::OpenOptions;
+use std::io;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::process::{Child, Command};
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use async_trait::async_trait;
+use sqlness::{Database, EnvController, QueryContext};
+use tokio::sync::Mutex as TokioMutex;
+
+use crate::client::MultiProtocolClient;
+use crate::cmd::bare::ServerAddr;
+use crate::formatter::{ErrorFormatter, MysqlFormatter, OutputFormatter, PostgresqlFormatter};
+use crate::protocol_interceptor::{MYSQL, PROTOCOL_KEY};
+use crate::server_mode::ServerMode;
+use crate::util;
+use crate::util::{PROGRAM, get_workspace_root, maybe_pull_binary};
+
+// standalone mode
+const SERVER_MODE_STANDALONE_IDX: usize = 0;
+// distributed mode
+const SERVER_MODE_METASRV_IDX: usize = 0;
+const SERVER_MODE_DATANODE_START_IDX: usize = 1;
+const SERVER_MODE_FRONTEND_IDX: usize = 4;
+const SERVER_MODE_FLOWNODE_IDX: usize = 5;
+
+#[derive(Clone)]
+pub enum WalConfig {
+    RaftEngine,
+    Kafka {
+        /// Indicates whether the runner needs to start a kafka cluster
+        /// (it might be available in the external system environment).
+        needs_kafka_cluster: bool,
+        broker_endpoints: Vec<String>,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum ServiceProvider {
+    Create,
+    External(String),
+}
+
+impl From<&str> for ServiceProvider {
+    fn from(value: &str) -> Self {
+        if value.is_empty() {
+            Self::Create
+        } else {
+            Self::External(value.to_string())
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct StoreConfig {
+    pub store_addrs: Vec<String>,
+    pub setup_etcd: bool,
+    pub(crate) setup_pg: Option<ServiceProvider>,
+    pub(crate) setup_mysql: Option<ServiceProvider>,
+}
+
+#[derive(Clone)]
+pub struct Env {
+    sqlness_home: PathBuf,
+    server_addrs: ServerAddr,
+    wal: WalConfig,
+
+    /// The path to the directory that contains the pre-built GreptimeDB binary.
+    /// When running in CI, this is expected to be set.
+    /// If not set, this runner will build the GreptimeDB binary itself when needed, and set this field by then.
+    bins_dir: Arc<Mutex<Option<PathBuf>>>,
+    /// The path to the directory that contains the old pre-built GreptimeDB binaries.
+    versioned_bins_dirs: Arc<Mutex<HashMap<String, PathBuf>>>,
+    /// Pull different versions of GreptimeDB on need.
+    pull_version_on_need: bool,
+    /// Store address for metasrv metadata
+    store_config: StoreConfig,
+    /// Extra command line arguments when starting GreptimeDB binaries.
+    extra_args: Vec<String>,
+}
+
+#[async_trait]
+impl EnvController for Env {
+    type DB = GreptimeDB;
+
+    async fn start(&self, mode: &str, id: usize, _config: Option<&Path>) -> Self::DB {
+        if self.server_addrs.server_addr.is_some() && id > 0 {
+            panic!("Parallel test mode is not supported when server address is already set.");
+        }
+
+        unsafe {
+            std::env::set_var("SQLNESS_HOME", self.sqlness_home.display().to_string());
+        }
+        match mode {
+            "standalone" => self.start_standalone(id).await,
+            "distributed" => self.start_distributed(id).await,
+            _ => panic!("Unexpected mode: {mode}"),
+        }
+    }
+
+    /// Stop one [`Database`].
+    async fn stop(&self, _mode: &str, mut database: Self::DB) {
+        database.stop();
+    }
+}
+
+impl Env {
+    pub fn new(
+        data_home: PathBuf,
+        server_addrs: ServerAddr,
+        wal: WalConfig,
+        pull_version_on_need: bool,
+        bins_dir: Option<PathBuf>,
+        store_config: StoreConfig,
+        extra_args: Vec<String>,
+    ) -> Self {
+        Self {
+            sqlness_home: data_home,
+            server_addrs,
+            wal,
+            pull_version_on_need,
+            bins_dir: Arc::new(Mutex::new(bins_dir.clone())),
+            versioned_bins_dirs: Arc::new(Mutex::new(HashMap::from_iter([(
+                "latest".to_string(),
+                bins_dir.clone().unwrap_or(util::get_binary_dir("debug")),
+            )]))),
+            store_config,
+            extra_args,
+        }
+    }
+
+    async fn start_standalone(&self, id: usize) -> GreptimeDB {
+        println!("Starting standalone instance id: {id}");
+
+        if self.server_addrs.server_addr.is_some() {
+            self.connect_db(&self.server_addrs, id).await
+        } else {
+            self.build_db();
+            self.setup_wal();
+            let mut db_ctx = GreptimeDBContext::new(self.wal.clone(), self.store_config.clone());
+
+            let server_mode = ServerMode::random_standalone();
+            db_ctx.set_server_mode(server_mode.clone(), SERVER_MODE_STANDALONE_IDX);
+            let server_addr = server_mode.server_addr().unwrap();
+            let server_process = self.start_server(server_mode, &db_ctx, id, true).await;
+
+            let mut greptimedb = self.connect_db(&server_addr, id).await;
+            greptimedb.server_processes = Some(Arc::new(Mutex::new(vec![server_process])));
+            greptimedb.is_standalone = true;
+            greptimedb.ctx = db_ctx;
+
+            greptimedb
+        }
+    }
+
+    async fn start_distributed(&self, id: usize) -> GreptimeDB {
+        if self.server_addrs.server_addr.is_some() {
+            self.connect_db(&self.server_addrs, id).await
+        } else {
+            self.build_db();
+            self.setup_wal();
+            self.setup_etcd();
+            self.setup_pg();
+            self.setup_mysql().await;
+            let mut db_ctx = GreptimeDBContext::new(self.wal.clone(), self.store_config.clone());
+
+            // start a distributed GreptimeDB
+            let meta_server_mode = ServerMode::random_metasrv();
+            let metasrv_port = match &meta_server_mode {
+                ServerMode::Metasrv {
+                    rpc_server_addr, ..
+                } => rpc_server_addr
+                    .split(':')
+                    .nth(1)
+                    .unwrap()
+                    .parse::<u16>()
+                    .unwrap(),
+                _ => panic!(
+                    "metasrv mode not set, maybe running in remote mode which doesn't support restart?"
+                ),
+            };
+            db_ctx.set_server_mode(meta_server_mode.clone(), SERVER_MODE_METASRV_IDX);
+            let meta_server = self.start_server(meta_server_mode, &db_ctx, id, true).await;
+
+            let datanode_1_mode = ServerMode::random_datanode(metasrv_port, 0);
+            db_ctx.set_server_mode(datanode_1_mode.clone(), SERVER_MODE_DATANODE_START_IDX);
+            let datanode_1 = self.start_server(datanode_1_mode, &db_ctx, id, true).await;
+            let datanode_2_mode = ServerMode::random_datanode(metasrv_port, 1);
+            db_ctx.set_server_mode(datanode_2_mode.clone(), SERVER_MODE_DATANODE_START_IDX + 1);
+            let datanode_2 = self.start_server(datanode_2_mode, &db_ctx, id, true).await;
+            let datanode_3_mode = ServerMode::random_datanode(metasrv_port, 2);
+            db_ctx.set_server_mode(datanode_3_mode.clone(), SERVER_MODE_DATANODE_START_IDX + 2);
+            let datanode_3 = self.start_server(datanode_3_mode, &db_ctx, id, true).await;
+
+            let frontend_mode = ServerMode::random_frontend(metasrv_port);
+            let server_addr = frontend_mode.server_addr().unwrap();
+            db_ctx.set_server_mode(frontend_mode.clone(), SERVER_MODE_FRONTEND_IDX);
+            let frontend = self.start_server(frontend_mode, &db_ctx, id, true).await;
+
+            let flownode_mode = ServerMode::random_flownode(metasrv_port, 0);
+            db_ctx.set_server_mode(flownode_mode.clone(), SERVER_MODE_FLOWNODE_IDX);
+            let flownode = self.start_server(flownode_mode, &db_ctx, id, true).await;
+
+            let mut greptimedb = self.connect_db(&server_addr, id).await;
+
+            greptimedb.metasrv_process = Some(meta_server).into();
+            greptimedb.server_processes = Some(Arc::new(Mutex::new(vec![
+                datanode_1, datanode_2, datanode_3,
+            ])));
+            greptimedb.frontend_process = Some(frontend).into();
+            greptimedb.flownode_process = Some(flownode).into();
+            greptimedb.is_standalone = false;
+            greptimedb.ctx = db_ctx;
+
+            greptimedb
+        }
+    }
+
+    async fn connect_db(&self, server_addr: &ServerAddr, id: usize) -> GreptimeDB {
+        let grpc_server_addr = server_addr.server_addr.as_ref().unwrap();
+        let pg_server_addr = server_addr.pg_server_addr.as_ref().unwrap();
+        let mysql_server_addr = server_addr.mysql_server_addr.as_ref().unwrap();
+
+        let client =
+            MultiProtocolClient::connect(grpc_server_addr, pg_server_addr, mysql_server_addr).await;
+        GreptimeDB {
+            client: TokioMutex::new(client),
+            server_processes: None,
+            metasrv_process: None.into(),
+            frontend_process: None.into(),
+            flownode_process: None.into(),
+            ctx: GreptimeDBContext {
+                time: 0,
+                datanode_id: Default::default(),
+                wal: self.wal.clone(),
+                store_config: self.store_config.clone(),
+                server_modes: Vec::new(),
+            },
+            is_standalone: false,
+            env: self.clone(),
+            id,
+        }
+    }
+
+    fn stop_server(process: &mut Child) {
+        let _ = process.kill();
+        let _ = process.wait();
+    }
+
+    async fn start_server(
+        &self,
+        mode: ServerMode,
+        db_ctx: &GreptimeDBContext,
+        id: usize,
+        truncate_log: bool,
+    ) -> Child {
+        let log_file_name = match mode {
+            ServerMode::Datanode { node_id, .. } => {
+                db_ctx.incr_datanode_id();
+                format!("greptime-{}-sqlness-datanode-{}.log", id, node_id)
+            }
+            ServerMode::Flownode { .. } => format!("greptime-{}-sqlness-flownode.log", id),
+            ServerMode::Frontend { .. } => format!("greptime-{}-sqlness-frontend.log", id),
+            ServerMode::Metasrv { .. } => format!("greptime-{}-sqlness-metasrv.log", id),
+            ServerMode::Standalone { .. } => format!("greptime-{}-sqlness-standalone.log", id),
+        };
+        let stdout_file_name = self.sqlness_home.join(log_file_name).display().to_string();
+
+        println!("DB instance {id} log file at {stdout_file_name}");
+
+        let stdout_file = OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(truncate_log)
+            .append(!truncate_log)
+            .open(stdout_file_name)
+            .unwrap();
+
+        let args = mode.get_args(&self.sqlness_home, self, db_ctx, id);
+        let check_ip_addrs = mode.check_addrs();
+
+        for check_ip_addr in &check_ip_addrs {
+            if util::check_port(check_ip_addr.parse().unwrap(), Duration::from_secs(1)).await {
+                panic!(
+                    "Port {check_ip_addr} is already in use, please check and retry.",
+                    check_ip_addr = check_ip_addr
+                );
+            }
+        }
+
+        let program = PROGRAM;
+
+        let bins_dir = self.bins_dir.lock().unwrap().clone().expect(
+            "GreptimeDB binary is not available. Please pass in the path to the directory that contains the pre-built GreptimeDB binary. Or you may call `self.build_db()` beforehand.",
+        );
+
+        let abs_bins_dir = bins_dir
+            .canonicalize()
+            .expect("Failed to canonicalize bins_dir");
+
+        let mut process = Command::new(abs_bins_dir.join(program))
+            .current_dir(bins_dir.clone())
+            .env("TZ", "UTC")
+            .args(args)
+            .stdout(stdout_file)
+            .spawn()
+            .unwrap_or_else(|error| {
+                panic!(
+                    "Failed to start the DB with subcommand {}, Error: {error}, path: {:?}",
+                    mode.name(),
+                    bins_dir.join(program)
+                );
+            });
+
+        for check_ip_addr in &check_ip_addrs {
+            if !util::check_port(check_ip_addr.parse().unwrap(), Duration::from_secs(10)).await {
+                Env::stop_server(&mut process);
+                panic!("{} doesn't up in 10 seconds, quit.", mode.name())
+            }
+        }
+
+        process
+    }
+
+    /// stop and restart the server process
+    async fn restart_server(&self, db: &GreptimeDB, is_full_restart: bool) {
+        {
+            if let Some(server_process) = db.server_processes.clone() {
+                let mut server_processes = server_process.lock().unwrap();
+                for server_process in server_processes.iter_mut() {
+                    Env::stop_server(server_process);
+                }
+            }
+
+            if is_full_restart {
+                if let Some(mut metasrv_process) =
+                    db.metasrv_process.lock().expect("poisoned lock").take()
+                {
+                    Env::stop_server(&mut metasrv_process);
+                }
+                if let Some(mut frontend_process) =
+                    db.frontend_process.lock().expect("poisoned lock").take()
+                {
+                    Env::stop_server(&mut frontend_process);
+                }
+            }
+
+            if let Some(mut flownode_process) =
+                db.flownode_process.lock().expect("poisoned lock").take()
+            {
+                Env::stop_server(&mut flownode_process);
+            }
+        }
+
+        // check if the server is distributed or standalone
+        let new_server_processes = if db.is_standalone {
+            let server_mode = db
+                .ctx
+                .get_server_mode(SERVER_MODE_STANDALONE_IDX)
+                .cloned()
+                .unwrap();
+            let server_addr = server_mode.server_addr().unwrap();
+            let new_server_process = self.start_server(server_mode, &db.ctx, db.id, false).await;
+
+            let mut client = db.client.lock().await;
+            client
+                .reconnect_mysql_client(&server_addr.mysql_server_addr.unwrap())
+                .await;
+            client
+                .reconnect_pg_client(&server_addr.pg_server_addr.unwrap())
+                .await;
+            vec![new_server_process]
+        } else {
+            db.ctx.reset_datanode_id();
+            if is_full_restart {
+                let metasrv_mode = db
+                    .ctx
+                    .get_server_mode(SERVER_MODE_METASRV_IDX)
+                    .cloned()
+                    .unwrap();
+                let metasrv = self.start_server(metasrv_mode, &db.ctx, db.id, false).await;
+                db.metasrv_process
+                    .lock()
+                    .expect("lock poisoned")
+                    .replace(metasrv);
+
+                // wait for metasrv to start
+                // since it seems older version of db might take longer to complete election
+                tokio::time::sleep(Duration::from_secs(5)).await;
+            }
+
+            let mut processes = vec![];
+            for i in 0..3 {
+                let datanode_mode = db
+                    .ctx
+                    .get_server_mode(SERVER_MODE_DATANODE_START_IDX + i)
+                    .cloned()
+                    .unwrap();
+                let new_server_process = self
+                    .start_server(datanode_mode, &db.ctx, db.id, false)
+                    .await;
+                processes.push(new_server_process);
+            }
+
+            if is_full_restart {
+                let frontend_mode = db
+                    .ctx
+                    .get_server_mode(SERVER_MODE_FRONTEND_IDX)
+                    .cloned()
+                    .unwrap();
+                let frontend = self
+                    .start_server(frontend_mode, &db.ctx, db.id, false)
+                    .await;
+                db.frontend_process
+                    .lock()
+                    .expect("lock poisoned")
+                    .replace(frontend);
+            }
+
+            let flownode_mode = db
+                .ctx
+                .get_server_mode(SERVER_MODE_FLOWNODE_IDX)
+                .cloned()
+                .unwrap();
+            let flownode = self
+                .start_server(flownode_mode, &db.ctx, db.id, false)
+                .await;
+            db.flownode_process
+                .lock()
+                .expect("lock poisoned")
+                .replace(flownode);
+
+            processes
+        };
+
+        if let Some(server_processes) = db.server_processes.clone() {
+            let mut server_processes = server_processes.lock().unwrap();
+            *server_processes = new_server_processes;
+        }
+    }
+
+    /// Setup kafka wal cluster if needed. The counterpart is in [GreptimeDB::stop].
+    fn setup_wal(&self) {
+        if matches!(self.wal, WalConfig::Kafka { needs_kafka_cluster, .. } if needs_kafka_cluster) {
+            util::setup_wal();
+        }
+    }
+
+    /// Setup etcd if needed.
+    fn setup_etcd(&self) {
+        if self.store_config.setup_etcd {
+            let client_ports = self
+                .store_config
+                .store_addrs
+                .iter()
+                .map(|s| s.split(':').nth(1).unwrap().parse::<u16>().unwrap())
+                .collect::<Vec<_>>();
+            util::setup_etcd(client_ports, None, None);
+        }
+    }
+
+    /// Setup PostgreSql if needed.
+    fn setup_pg(&self) {
+        if matches!(self.store_config.setup_pg, Some(ServiceProvider::Create)) {
+            let client_ports = self
+                .store_config
+                .store_addrs
+                .iter()
+                .map(|s| s.split(':').nth(1).unwrap().parse::<u16>().unwrap())
+                .collect::<Vec<_>>();
+            let client_port = client_ports.first().unwrap_or(&5432);
+            util::setup_pg(*client_port, None);
+        }
+    }
+
+    /// Setup MySql if needed.
+    async fn setup_mysql(&self) {
+        if matches!(self.store_config.setup_mysql, Some(ServiceProvider::Create)) {
+            let client_ports = self
+                .store_config
+                .store_addrs
+                .iter()
+                .map(|s| s.split(':').nth(1).unwrap().parse::<u16>().unwrap())
+                .collect::<Vec<_>>();
+            let client_port = client_ports.first().unwrap_or(&3306);
+            util::setup_mysql(*client_port, None);
+
+            // Docker of MySQL starts slowly, so we need to wait for a while
+            tokio::time::sleep(Duration::from_secs(10)).await;
+        }
+    }
+
+    /// Build the DB with `cargo build --bin greptime`
+    fn build_db(&self) {
+        if self.bins_dir.lock().unwrap().is_some() {
+            return;
+        }
+
+        println!("Going to build the DB...");
+        let output = Command::new("cargo")
+            .current_dir(util::get_workspace_root())
+            .args([
+                "build",
+                "--bin",
+                "greptime",
+                "--features",
+                "pg_kvbackend,mysql_kvbackend",
+            ])
+            .output()
+            .expect("Failed to start GreptimeDB");
+        if !output.status.success() {
+            println!("Failed to build GreptimeDB, {}", output.status);
+            println!("Cargo build stdout:");
+            io::stdout().write_all(&output.stdout).unwrap();
+            println!("Cargo build stderr:");
+            io::stderr().write_all(&output.stderr).unwrap();
+            panic!();
+        }
+
+        let _ = self
+            .bins_dir
+            .lock()
+            .unwrap()
+            .insert(util::get_binary_dir("debug"));
+    }
+
+    pub(crate) fn extra_args(&self) -> &Vec<String> {
+        &self.extra_args
+    }
+}
+
+pub struct GreptimeDB {
+    server_processes: Option<Arc<Mutex<Vec<Child>>>>,
+    metasrv_process: Mutex<Option<Child>>,
+    frontend_process: Mutex<Option<Child>>,
+    flownode_process: Mutex<Option<Child>>,
+    client: TokioMutex<MultiProtocolClient>,
+    ctx: GreptimeDBContext,
+    is_standalone: bool,
+    env: Env,
+    id: usize,
+}
+
+impl GreptimeDB {
+    async fn postgres_query(&self, _ctx: QueryContext, query: String) -> Box<dyn Display> {
+        let mut client = self.client.lock().await;
+
+        match client.postgres_query(&query).await {
+            Ok(rows) => Box::new(PostgresqlFormatter::from(rows)),
+            Err(e) => Box::new(e),
+        }
+    }
+
+    async fn mysql_query(&self, _ctx: QueryContext, query: String) -> Box<dyn Display> {
+        let mut client = self.client.lock().await;
+
+        match client.mysql_query(&query).await {
+            Ok(res) => Box::new(MysqlFormatter::from(res)),
+            Err(e) => Box::new(e),
+        }
+    }
+
+    async fn grpc_query(&self, _ctx: QueryContext, query: String) -> Box<dyn Display> {
+        let mut client = self.client.lock().await;
+
+        match client.grpc_query(&query).await {
+            Ok(rows) => Box::new(OutputFormatter::from(rows)),
+            Err(e) => Box::new(ErrorFormatter::from(e)),
+        }
+    }
+}
+
+#[async_trait]
+impl Database for GreptimeDB {
+    async fn query(&self, ctx: QueryContext, query: String) -> Box<dyn Display> {
+        if ctx.context.contains_key("restart") && self.env.server_addrs.server_addr.is_none() {
+            self.env.restart_server(self, false).await;
+        } else if let Some(version) = ctx.context.get("version") {
+            let version_bin_dir = self
+                .env
+                .versioned_bins_dirs
+                .lock()
+                .expect("lock poison")
+                .get(version.as_str())
+                .cloned();
+
+            match version_bin_dir {
+                Some(path) if path.clone().join(PROGRAM).is_file() => {
+                    // use version in versioned_bins_dirs
+                    *self.env.bins_dir.lock().unwrap() = Some(path.clone());
+                }
+                _ => {
+                    // use version in dir files
+                    maybe_pull_binary(version, self.env.pull_version_on_need).await;
+                    let root = get_workspace_root();
+                    let new_path = PathBuf::from_iter([&root, version]);
+                    *self.env.bins_dir.lock().unwrap() = Some(new_path);
+                }
+            }
+
+            self.env.restart_server(self, true).await;
+            // sleep for a while to wait for the server to fully boot up
+            tokio::time::sleep(Duration::from_secs(5)).await;
+        }
+
+        if let Some(protocol) = ctx.context.get(PROTOCOL_KEY) {
+            // protocol is bound to be either "mysql" or "postgres"
+            if protocol == MYSQL {
+                self.mysql_query(ctx, query).await
+            } else {
+                self.postgres_query(ctx, query).await
+            }
+        } else {
+            self.grpc_query(ctx, query).await
+        }
+    }
+}
+
+impl GreptimeDB {
+    fn stop(&mut self) {
+        if let Some(server_processes) = self.server_processes.clone() {
+            let mut server_processes = server_processes.lock().unwrap();
+            for mut server_process in server_processes.drain(..) {
+                Env::stop_server(&mut server_process);
+                println!(
+                    "Standalone or Datanode (pid = {}) is stopped",
+                    server_process.id()
+                );
+            }
+        }
+        if let Some(mut metasrv) = self
+            .metasrv_process
+            .lock()
+            .expect("someone else panic when holding lock")
+            .take()
+        {
+            Env::stop_server(&mut metasrv);
+            println!("Metasrv (pid = {}) is stopped", metasrv.id());
+        }
+        if let Some(mut frontend) = self
+            .frontend_process
+            .lock()
+            .expect("someone else panic when holding lock")
+            .take()
+        {
+            Env::stop_server(&mut frontend);
+            println!("Frontend (pid = {}) is stopped", frontend.id());
+        }
+        if let Some(mut flownode) = self
+            .flownode_process
+            .lock()
+            .expect("someone else panic when holding lock")
+            .take()
+        {
+            Env::stop_server(&mut flownode);
+            println!("Flownode (pid = {}) is stopped", flownode.id());
+        }
+        if matches!(self.ctx.wal, WalConfig::Kafka { needs_kafka_cluster, .. } if needs_kafka_cluster)
+        {
+            util::teardown_wal();
+        }
+    }
+}
+
+impl Drop for GreptimeDB {
+    fn drop(&mut self) {
+        if self.env.server_addrs.server_addr.is_none() {
+            self.stop();
+        }
+    }
+}
+
+pub struct GreptimeDBContext {
+    /// Start time in millisecond
+    time: i64,
+    datanode_id: AtomicU32,
+    wal: WalConfig,
+    store_config: StoreConfig,
+    server_modes: Vec<ServerMode>,
+}
+
+impl GreptimeDBContext {
+    pub fn new(wal: WalConfig, store_config: StoreConfig) -> Self {
+        Self {
+            time: common_time::util::current_time_millis(),
+            datanode_id: AtomicU32::new(0),
+            wal,
+            store_config,
+            server_modes: Vec::new(),
+        }
+    }
+
+    pub(crate) fn time(&self) -> i64 {
+        self.time
+    }
+
+    pub fn is_raft_engine(&self) -> bool {
+        matches!(self.wal, WalConfig::RaftEngine)
+    }
+
+    pub fn kafka_wal_broker_endpoints(&self) -> String {
+        match &self.wal {
+            WalConfig::RaftEngine => String::new(),
+            WalConfig::Kafka {
+                broker_endpoints, ..
+            } => serde_json::to_string(&broker_endpoints).unwrap(),
+        }
+    }
+
+    fn incr_datanode_id(&self) {
+        let _ = self.datanode_id.fetch_add(1, Ordering::Relaxed);
+    }
+
+    fn reset_datanode_id(&self) {
+        self.datanode_id.store(0, Ordering::Relaxed);
+    }
+
+    pub(crate) fn store_config(&self) -> StoreConfig {
+        self.store_config.clone()
+    }
+
+    fn set_server_mode(&mut self, mode: ServerMode, idx: usize) {
+        if idx >= self.server_modes.len() {
+            self.server_modes.resize(idx + 1, mode.clone());
+        }
+        self.server_modes[idx] = mode;
+    }
+
+    fn get_server_mode(&self, idx: usize) -> Option<&ServerMode> {
+        self.server_modes.get(idx)
+    }
+}
diff --git a/tests/runner/src/env/kube.rs b/tests/runner/src/env/kube.rs
new file mode 100644
index 0000000000..91fb747102
--- /dev/null
+++ b/tests/runner/src/env/kube.rs
@@ -0,0 +1,204 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::fmt::Display;
+use std::path::Path;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use sqlness::{Database, EnvController, QueryContext};
+use tokio::process::Command;
+use tokio::sync::Mutex;
+
+use crate::client::MultiProtocolClient;
+use crate::formatter::{ErrorFormatter, MysqlFormatter, OutputFormatter, PostgresqlFormatter};
+use crate::protocol_interceptor::{MYSQL, PROTOCOL_KEY};
+
+#[async_trait]
+pub trait DatabaseManager: Send + Sync {
+    // Restarts the database.
+    async fn restart(&self, database: &GreptimeDB);
+}
+
+#[async_trait]
+impl DatabaseManager for () {
+    async fn restart(&self, _: &GreptimeDB) {
+        // Do nothing
+    }
+}
+
+#[async_trait]
+pub trait ResourcesManager: Send + Sync {
+    // Delete namespace.
+    async fn delete_namespace(&self);
+
+    // Get namespace.
+    fn namespace(&self) -> &str;
+}
+
+#[derive(Clone)]
+pub struct Env {
+    /// Whether to delete the namespace on stop.
+    pub delete_namespace_on_stop: bool,
+    /// Address of the grpc server.
+    pub server_addr: String,
+    /// Address of the postgres server.
+    pub pg_server_addr: String,
+    /// Address of the mysql server.
+    pub mysql_server_addr: String,
+    /// The database manager.
+    pub database_manager: Arc<dyn DatabaseManager>,
+    /// The resources manager.
+    pub resources_manager: Arc<dyn ResourcesManager>,
+}
+
+#[async_trait]
+impl EnvController for Env {
+    type DB = GreptimeDB;
+
+    async fn start(&self, mode: &str, id: usize, _config: Option<&Path>) -> Self::DB {
+        if id > 0 {
+            panic!("Parallel test mode is not supported in kube env");
+        }
+
+        match mode {
+            "standalone" | "distributed" => GreptimeDB {
+                client: Mutex::new(
+                    MultiProtocolClient::connect(
+                        &self.server_addr,
+                        &self.pg_server_addr,
+                        &self.mysql_server_addr,
+                    )
+                    .await,
+                ),
+                database_manager: self.database_manager.clone(),
+                resources_manager: self.resources_manager.clone(),
+                delete_namespace_on_stop: self.delete_namespace_on_stop,
+            },
+
+            _ => panic!("Unexpected mode: {mode}"),
+        }
+    }
+
+    async fn stop(&self, _mode: &str, database: Self::DB) {
+        database.stop().await;
+    }
+}
+
+pub struct GreptimeDB {
+    pub client: Mutex<MultiProtocolClient>,
+    pub delete_namespace_on_stop: bool,
+    pub database_manager: Arc<dyn DatabaseManager>,
+    pub resources_manager: Arc<dyn ResourcesManager>,
+}
+
+impl GreptimeDB {
+    async fn postgres_query(&self, _ctx: QueryContext, query: String) -> Box<dyn Display> {
+        let mut client = self.client.lock().await;
+
+        match client.postgres_query(&query).await {
+            Ok(rows) => Box::new(PostgresqlFormatter::from(rows)),
+            Err(e) => Box::new(e),
+        }
+    }
+
+    async fn mysql_query(&self, _ctx: QueryContext, query: String) -> Box<dyn Display> {
+        let mut client = self.client.lock().await;
+
+        match client.mysql_query(&query).await {
+            Ok(res) => Box::new(MysqlFormatter::from(res)),
+            Err(e) => Box::new(e),
+        }
+    }
+
+    async fn grpc_query(&self, _ctx: QueryContext, query: String) -> Box<dyn Display> {
+        let mut client = self.client.lock().await;
+
+        match client.grpc_query(&query).await {
+            Ok(rows) => Box::new(OutputFormatter::from(rows)),
+            Err(e) => Box::new(ErrorFormatter::from(e)),
+        }
+    }
+}
+
+#[async_trait]
+impl Database for GreptimeDB {
+    async fn query(&self, ctx: QueryContext, query: String) -> Box<dyn Display> {
+        if ctx.context.contains_key("restart") {
+            self.database_manager.restart(self).await
+        }
+
+        if let Some(protocol) = ctx.context.get(PROTOCOL_KEY) {
+            // protocol is bound to be either "mysql" or "postgres"
+            if protocol == MYSQL {
+                self.mysql_query(ctx, query).await
+            } else {
+                self.postgres_query(ctx, query).await
+            }
+        } else {
+            self.grpc_query(ctx, query).await
+        }
+    }
+}
+
+impl GreptimeDB {
+    async fn stop(&self) {
+        if self.delete_namespace_on_stop {
+            self.resources_manager.delete_namespace().await;
+            println!("Deleted namespace({})", self.resources_manager.namespace());
+        } else {
+            println!(
+                "Namespace({}) is not deleted",
+                self.resources_manager.namespace()
+            );
+        }
+    }
+}
+
+pub struct NaiveResourcesManager {
+    namespace: String,
+}
+
+impl NaiveResourcesManager {
+    pub fn new(namespace: String) -> Self {
+        Self { namespace }
+    }
+}
+
+#[async_trait]
+impl ResourcesManager for NaiveResourcesManager {
+    async fn delete_namespace(&self) {
+        let output = Command::new("kubectl")
+            .arg("delete")
+            .arg("namespace")
+            .arg(&self.namespace)
+            .output()
+            .await
+            .unwrap_or_else(|e| {
+                panic!(
+                    "Failed to execute kubectl delete namespace({}): {}",
+                    self.namespace, e
+                )
+            });
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            panic!("Failed to delete namespace({}): {}", self.namespace, stderr);
+        }
+    }
+
+    fn namespace(&self) -> &str {
+        &self.namespace
+    }
+}
diff --git a/tests/runner/src/formatter.rs b/tests/runner/src/formatter.rs
new file mode 100644
index 0000000000..a379ad3244
--- /dev/null
+++ b/tests/runner/src/formatter.rs
@@ -0,0 +1,216 @@
+// 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::borrow::Cow;
+use std::fmt::Display;
+use std::sync::Arc;
+
+use client::{Output, OutputData, RecordBatches};
+use common_error::ext::ErrorExt;
+use datatypes::prelude::ConcreteDataType;
+use datatypes::scalars::ScalarVectorBuilder;
+use datatypes::schema::{ColumnSchema, Schema};
+use datatypes::vectors::{StringVectorBuilder, VectorRef};
+use mysql::Row as MySqlRow;
+use tokio_postgres::SimpleQueryMessage as PgRow;
+
+use crate::client::MysqlSqlResult;
+
+/// A formatter for errors.
+pub struct ErrorFormatter<E: ErrorExt>(E);
+
+impl<E: ErrorExt> From<E> for ErrorFormatter<E> {
+    fn from(error: E) -> Self {
+        ErrorFormatter(error)
+    }
+}
+
+impl<E: ErrorExt> Display for ErrorFormatter<E> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let status_code = self.0.status_code();
+        let root_cause = self.0.output_msg();
+        write!(
+            f,
+            "Error: {}({status_code}), {root_cause}",
+            status_code as u32
+        )
+    }
+}
+
+/// A formatter for [`Output`].
+pub struct OutputFormatter(Output);
+
+impl From<Output> for OutputFormatter {
+    fn from(output: Output) -> Self {
+        OutputFormatter(output)
+    }
+}
+
+impl Display for OutputFormatter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.0.data {
+            OutputData::AffectedRows(rows) => {
+                write!(f, "Affected Rows: {rows}")
+            }
+            OutputData::RecordBatches(recordbatches) => {
+                let pretty = recordbatches.pretty_print().map_err(|e| e.to_string());
+                match pretty {
+                    Ok(s) => write!(f, "{s}"),
+                    Err(e) => {
+                        write!(f, "Failed to pretty format {recordbatches:?}, error: {e}")
+                    }
+                }
+            }
+            OutputData::Stream(_) => unreachable!(),
+        }
+    }
+}
+
+pub struct PostgresqlFormatter(Vec<PgRow>);
+
+impl From<Vec<PgRow>> for PostgresqlFormatter {
+    fn from(rows: Vec<PgRow>) -> Self {
+        PostgresqlFormatter(rows)
+    }
+}
+
+impl Display for PostgresqlFormatter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.0.is_empty() {
+            return f.write_fmt(format_args!("(Empty response)"));
+        }
+
+        if let PgRow::CommandComplete(affected_rows) = &self.0[0] {
+            return write!(
+                f,
+                "{}",
+                OutputFormatter(Output::new_with_affected_rows(*affected_rows as usize))
+            );
+        };
+
+        let Some(recordbatches) = build_recordbatches_from_postgres_rows(&self.0) else {
+            return Ok(());
+        };
+        write!(
+            f,
+            "{}",
+            OutputFormatter(Output::new_with_record_batches(recordbatches))
+        )
+    }
+}
+
+fn build_recordbatches_from_postgres_rows(rows: &[PgRow]) -> Option<RecordBatches> {
+    // create schema
+    let schema = match &rows[0] {
+        PgRow::RowDescription(desc) => Arc::new(Schema::new(
+            desc.iter()
+                .map(|column| {
+                    ColumnSchema::new(column.name(), ConcreteDataType::string_datatype(), true)
+                })
+                .collect(),
+        )),
+        _ => unreachable!(),
+    };
+    if schema.num_columns() == 0 {
+        return None;
+    }
+
+    // convert to string vectors
+    let mut columns: Vec<StringVectorBuilder> = (0..schema.num_columns())
+        .map(|_| StringVectorBuilder::with_capacity(schema.num_columns()))
+        .collect();
+    for row in rows.iter().skip(1) {
+        if let PgRow::Row(row) = row {
+            for (i, column) in columns.iter_mut().enumerate().take(schema.num_columns()) {
+                column.push(row.get(i));
+            }
+        }
+    }
+    let columns: Vec<VectorRef> = columns
+        .into_iter()
+        .map(|mut col| Arc::new(col.finish()) as VectorRef)
+        .collect();
+
+    // construct recordbatch
+    let recordbatches = RecordBatches::try_from_columns(schema, columns)
+        .expect("Failed to construct recordbatches from columns. Please check the schema.");
+    Some(recordbatches)
+}
+
+/// A formatter for [`MysqlSqlResult`].
+pub struct MysqlFormatter(MysqlSqlResult);
+
+impl From<MysqlSqlResult> for MysqlFormatter {
+    fn from(result: MysqlSqlResult) -> Self {
+        MysqlFormatter(result)
+    }
+}
+
+impl Display for MysqlFormatter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.0 {
+            MysqlSqlResult::AffectedRows(rows) => {
+                write!(f, "affected_rows: {rows}")
+            }
+            MysqlSqlResult::Rows(rows) => {
+                if rows.is_empty() {
+                    return f.write_fmt(format_args!("(Empty response)"));
+                }
+
+                let recordbatches = build_recordbatches_from_mysql_rows(rows);
+                write!(
+                    f,
+                    "{}",
+                    OutputFormatter(Output::new_with_record_batches(recordbatches))
+                )
+            }
+        }
+    }
+}
+
+pub fn build_recordbatches_from_mysql_rows(rows: &[MySqlRow]) -> RecordBatches {
+    // create schema
+    let head_column = &rows[0];
+    let head_binding = head_column.columns();
+    let names = head_binding
+        .iter()
+        .map(|column| column.name_str())
+        .collect::<Vec<Cow<str>>>();
+    let schema = Arc::new(Schema::new(
+        names
+            .iter()
+            .map(|name| {
+                ColumnSchema::new(name.to_string(), ConcreteDataType::string_datatype(), false)
+            })
+            .collect(),
+    ));
+
+    // convert to string vectors
+    let mut columns: Vec<StringVectorBuilder> = (0..schema.num_columns())
+        .map(|_| StringVectorBuilder::with_capacity(schema.num_columns()))
+        .collect();
+    for row in rows.iter() {
+        for (i, name) in names.iter().enumerate() {
+            columns[i].push(row.get::<String, &str>(name).as_deref());
+        }
+    }
+    let columns: Vec<VectorRef> = columns
+        .into_iter()
+        .map(|mut col| Arc::new(col.finish()) as VectorRef)
+        .collect();
+
+    // construct recordbatch
+    RecordBatches::try_from_columns(schema, columns)
+        .expect("Failed to construct recordbatches from columns. Please check the schema.")
+}
diff --git a/tests/runner/src/main.rs b/tests/runner/src/main.rs
index c2392b3599..c6cf5dd4b5 100644
--- a/tests/runner/src/main.rs
+++ b/tests/runner/src/main.rs
@@ -14,214 +14,24 @@
 
 #![allow(clippy::print_stdout)]
 
-use std::path::PathBuf;
-use std::sync::Arc;
+use clap::Parser;
 
-use clap::{Parser, ValueEnum};
-use env::{Env, WalConfig};
-use sqlness::interceptor::Registry;
-use sqlness::{ConfigBuilder, Runner};
-
-use crate::env::{ServiceProvider, StoreConfig};
+use crate::cmd::{Command, SubCommand};
 
+pub mod client;
+mod cmd;
 mod env;
-mod protocol_interceptor;
+pub mod formatter;
+pub mod protocol_interceptor;
 mod server_mode;
 mod util;
 
-#[derive(ValueEnum, Debug, Clone)]
-#[clap(rename_all = "snake_case")]
-enum Wal {
-    RaftEngine,
-    Kafka,
-}
-
-// add a group to ensure that all server addresses are set together
-#[derive(clap::Args, Debug, Clone, Default)]
-#[group(multiple = true, requires_all=["server_addr", "pg_server_addr", "mysql_server_addr"])]
-struct ServerAddr {
-    /// Address of the grpc server.
-    #[clap(short, long)]
-    server_addr: Option<String>,
-
-    /// Address of the postgres server. Must be set if server_addr is set.
-    #[clap(short, long, requires = "server_addr")]
-    pg_server_addr: Option<String>,
-
-    /// Address of the mysql server. Must be set if server_addr is set.
-    #[clap(short, long, requires = "server_addr")]
-    mysql_server_addr: Option<String>,
-}
-
-#[derive(Parser, Debug)]
-#[clap(author, version, about, long_about = None)]
-/// SQL Harness for GrepTimeDB
-struct Args {
-    /// Directory of test cases
-    #[clap(short, long)]
-    case_dir: Option<PathBuf>,
-
-    /// Fail this run as soon as one case fails if true
-    #[arg(short, long, default_value = "false")]
-    fail_fast: bool,
-
-    /// Environment Configuration File
-    #[clap(short, long, default_value = "config.toml")]
-    env_config_file: String,
-
-    /// Name of test cases to run. Accept as a regexp.
-    #[clap(short, long, default_value = ".*")]
-    test_filter: String,
-
-    /// Addresses of the server.
-    #[command(flatten)]
-    server_addr: ServerAddr,
-
-    /// The type of Wal.
-    #[clap(short, long, default_value = "raft_engine")]
-    wal: Wal,
-
-    /// The kafka wal broker endpoints. This config will suppress sqlness runner
-    /// from starting a kafka cluster, and use the given endpoint as kafka backend.
-    #[clap(short, long)]
-    kafka_wal_broker_endpoints: Option<String>,
-
-    /// The path to the directory where GreptimeDB's binaries resides.
-    /// If not set, sqlness will build GreptimeDB on the fly.
-    #[clap(long)]
-    bins_dir: Option<PathBuf>,
-
-    /// Preserve persistent state in the temporary directory.
-    /// This may affect future test runs.
-    #[clap(long)]
-    preserve_state: bool,
-
-    /// Pull Different versions of GreptimeDB on need.
-    #[clap(long, default_value = "true")]
-    pull_version_on_need: bool,
-
-    /// The store addresses for metadata, if empty, will use memory store.
-    #[clap(long)]
-    store_addrs: Vec<String>,
-
-    /// Whether to setup etcd, by default it is false.
-    #[clap(long, default_value = "false")]
-    setup_etcd: bool,
-
-    /// Whether to setup pg, by default it is false.
-    #[clap(long, default_missing_value = "", num_args(0..=1))]
-    setup_pg: Option<ServiceProvider>,
-
-    /// Whether to setup mysql, by default it is false.
-    #[clap(long, default_missing_value = "", num_args(0..=1))]
-    setup_mysql: Option<ServiceProvider>,
-
-    /// The number of jobs to run in parallel. Default to half of the cores.
-    #[clap(short, long, default_value = "0")]
-    jobs: usize,
-
-    /// Extra command line arguments when starting GreptimeDB binaries.
-    #[clap(long)]
-    extra_args: Vec<String>,
-}
-
 #[tokio::main]
 async fn main() {
-    let mut args = Args::parse();
+    let cmd = Command::parse();
 
-    let temp_dir = tempfile::Builder::new()
-        .prefix("sqlness")
-        .tempdir()
-        .unwrap();
-    let sqlness_home = temp_dir.keep();
-
-    let mut interceptor_registry: Registry = Default::default();
-    interceptor_registry.register(
-        protocol_interceptor::PREFIX,
-        Arc::new(protocol_interceptor::ProtocolInterceptorFactory),
-    );
-
-    if let Some(d) = &args.case_dir
-        && !d.is_dir()
-    {
-        panic!("{} is not a directory", d.display());
-    }
-    if args.jobs == 0 {
-        args.jobs = num_cpus::get() / 2;
-    }
-
-    // normalize parallelism to 1 if any of the following conditions are met:
-    // Note: parallelism in pg and mysql is possible, but need configuration.
-    if args.server_addr.server_addr.is_some()
-        || args.setup_etcd
-        || args.setup_pg.is_some()
-        || args.setup_mysql.is_some()
-        || args.kafka_wal_broker_endpoints.is_some()
-        || args.test_filter != ".*"
-    {
-        args.jobs = 1;
-        println!(
-            "Normalizing parallelism to 1 due to server addresses, etcd/pg/mysql setup, or test filter usage"
-        );
-    }
-
-    let config = ConfigBuilder::default()
-        .case_dir(util::get_case_dir(args.case_dir))
-        .fail_fast(args.fail_fast)
-        .test_filter(args.test_filter)
-        .follow_links(true)
-        .env_config_file(args.env_config_file)
-        .interceptor_registry(interceptor_registry)
-        .parallelism(args.jobs)
-        .build()
-        .unwrap();
-
-    let wal = match args.wal {
-        Wal::RaftEngine => WalConfig::RaftEngine,
-        Wal::Kafka => WalConfig::Kafka {
-            needs_kafka_cluster: args.kafka_wal_broker_endpoints.is_none(),
-            broker_endpoints: args
-                .kafka_wal_broker_endpoints
-                .map(|s| s.split(',').map(|s| s.to_string()).collect())
-                // otherwise default to the same port in `kafka-cluster.yml`
-                .unwrap_or(vec!["127.0.0.1:9092".to_string()]),
-        },
-    };
-
-    let store = StoreConfig {
-        store_addrs: args.store_addrs.clone(),
-        setup_etcd: args.setup_etcd,
-        setup_pg: args.setup_pg,
-        setup_mysql: args.setup_mysql,
-    };
-
-    let runner = Runner::new(
-        config,
-        Env::new(
-            sqlness_home.clone(),
-            args.server_addr.clone(),
-            wal,
-            args.pull_version_on_need,
-            args.bins_dir,
-            store,
-            args.extra_args,
-        ),
-    );
-    match runner.run().await {
-        Ok(_) => println!("\x1b[32mAll sqlness tests passed!\x1b[0m"),
-        Err(e) => {
-            println!("\x1b[31mTest failed: {}\x1b[0m", e);
-            std::process::exit(1);
-        }
-    }
-
-    // clean up and exit
-    if !args.preserve_state {
-        if args.setup_etcd {
-            println!("Stopping etcd");
-            util::stop_rm_etcd();
-        }
-        println!("Removing state in {:?}", sqlness_home);
-        tokio::fs::remove_dir_all(sqlness_home).await.unwrap();
+    match cmd.subcmd {
+        SubCommand::Bare(cmd) => cmd.run().await,
+        SubCommand::Kube(cmd) => cmd.run().await,
     }
 }
diff --git a/tests/runner/src/server_mode.rs b/tests/runner/src/server_mode.rs
index 77f9154c36..2e4cefa2c6 100644
--- a/tests/runner/src/server_mode.rs
+++ b/tests/runner/src/server_mode.rs
@@ -19,8 +19,9 @@ use std::sync::{Mutex, OnceLock};
 use serde::Serialize;
 use tinytemplate::TinyTemplate;
 
-use crate::env::{Env, GreptimeDBContext, ServiceProvider};
-use crate::{ServerAddr, util};
+use crate::cmd::bare::ServerAddr;
+use crate::env::bare::{Env, GreptimeDBContext, ServiceProvider};
+use crate::util;
 
 const DEFAULT_LOG_LEVEL: &str = "--log-level=debug,hyper=warn,tower=warn,datafusion=warn,reqwest=warn,sqlparser=warn,h2=info,opendal=info";
 
diff --git a/tests/runner/src/util.rs b/tests/runner/src/util.rs
index 621b5856c3..6c00c8a9a6 100644
--- a/tests/runner/src/util.rs
+++ b/tests/runner/src/util.rs
@@ -533,3 +533,28 @@ pub fn get_random_port() -> u16 {
         .expect("Failed to get local address")
         .port()
 }
+
+/// Retry to execute the function until success or the maximum number of retries is reached.
+pub async fn retry_with_backoff<T, E, Fut, F>(
+    mut fut: F,
+    max_retry: usize,
+    init_backoff: Duration,
+) -> Result<T, E>
+where
+    F: FnMut() -> Fut,
+    Fut: Future<Output = Result<T, E>>,
+{
+    let mut backoff = init_backoff;
+    for attempt in 0..max_retry {
+        match fut().await {
+            Ok(res) => return Ok(res),
+            Err(err) if attempt + 1 == max_retry => return Err(err),
+            Err(_) => {
+                tokio::time::sleep(backoff).await;
+                backoff *= 2;
+            }
+        }
+    }
+
+    unreachable!("loop should have returned before here")
+}