diff --git a/src/api/src/helper.rs b/src/api/src/helper.rs
index a091d99799..868684ab0e 100644
--- a/src/api/src/helper.rs
+++ b/src/api/src/helper.rs
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 use std::collections::HashSet;
-use std::sync::Arc;
 
 use common_decimal::Decimal128;
 use common_decimal::decimal128::{DECIMAL128_DEFAULT_SCALE, DECIMAL128_MAX_PRECISION};
@@ -21,22 +20,11 @@ use common_time::time::Time;
 use common_time::timestamp::TimeUnit;
 use common_time::{Date, IntervalDayTime, IntervalMonthDayNano, IntervalYearMonth, Timestamp};
 use datatypes::prelude::{ConcreteDataType, ValueRef};
-use datatypes::scalars::ScalarVector;
-use datatypes::types::{
-    Int8Type, Int16Type, IntervalType, StructField, StructType, TimeType, TimestampType, UInt8Type,
-    UInt16Type,
-};
+use datatypes::types::{IntervalType, StructField, StructType, TimeType, TimestampType};
 use datatypes::value::{
     ListValue, ListValueRef, OrderedF32, OrderedF64, StructValue, StructValueRef, Value,
 };
-use datatypes::vectors::{
-    BinaryVector, BooleanVector, DateVector, Decimal128Vector, Float32Vector, Float64Vector,
-    Int32Vector, Int64Vector, IntervalDayTimeVector, IntervalMonthDayNanoVector,
-    IntervalYearMonthVector, PrimitiveVector, StringVector, TimeMicrosecondVector,
-    TimeMillisecondVector, TimeNanosecondVector, TimeSecondVector, TimestampMicrosecondVector,
-    TimestampMillisecondVector, TimestampNanosecondVector, TimestampSecondVector, UInt32Vector,
-    UInt64Vector, VectorRef,
-};
+use datatypes::vectors::VectorRef;
 use greptime_proto::v1::column_data_type_extension::TypeExt;
 use greptime_proto::v1::ddl_request::Expr;
 use greptime_proto::v1::greptime_request::Request;
@@ -765,257 +753,6 @@ pub fn pb_value_to_value_ref<'a>(
     }
 }
 
-pub fn pb_values_to_vector_ref(data_type: &ConcreteDataType, values: Values) -> VectorRef {
-    match data_type {
-        ConcreteDataType::Boolean(_) => Arc::new(BooleanVector::from(values.bool_values)),
-        ConcreteDataType::Int8(_) => Arc::new(PrimitiveVector::<Int8Type>::from_iter_values(
-            values.i8_values.into_iter().map(|x| x as i8),
-        )),
-        ConcreteDataType::Int16(_) => Arc::new(PrimitiveVector::<Int16Type>::from_iter_values(
-            values.i16_values.into_iter().map(|x| x as i16),
-        )),
-        ConcreteDataType::Int32(_) => Arc::new(Int32Vector::from_vec(values.i32_values)),
-        ConcreteDataType::Int64(_) => Arc::new(Int64Vector::from_vec(values.i64_values)),
-        ConcreteDataType::UInt8(_) => Arc::new(PrimitiveVector::<UInt8Type>::from_iter_values(
-            values.u8_values.into_iter().map(|x| x as u8),
-        )),
-        ConcreteDataType::UInt16(_) => Arc::new(PrimitiveVector::<UInt16Type>::from_iter_values(
-            values.u16_values.into_iter().map(|x| x as u16),
-        )),
-        ConcreteDataType::UInt32(_) => Arc::new(UInt32Vector::from_vec(values.u32_values)),
-        ConcreteDataType::UInt64(_) => Arc::new(UInt64Vector::from_vec(values.u64_values)),
-        ConcreteDataType::Float32(_) => Arc::new(Float32Vector::from_vec(values.f32_values)),
-        ConcreteDataType::Float64(_) => Arc::new(Float64Vector::from_vec(values.f64_values)),
-        ConcreteDataType::Binary(_) => Arc::new(BinaryVector::from(values.binary_values)),
-        ConcreteDataType::String(_) => Arc::new(StringVector::from_vec(values.string_values)),
-        ConcreteDataType::Date(_) => Arc::new(DateVector::from_vec(values.date_values)),
-        ConcreteDataType::Timestamp(unit) => match unit {
-            TimestampType::Second(_) => Arc::new(TimestampSecondVector::from_vec(
-                values.timestamp_second_values,
-            )),
-            TimestampType::Millisecond(_) => Arc::new(TimestampMillisecondVector::from_vec(
-                values.timestamp_millisecond_values,
-            )),
-            TimestampType::Microsecond(_) => Arc::new(TimestampMicrosecondVector::from_vec(
-                values.timestamp_microsecond_values,
-            )),
-            TimestampType::Nanosecond(_) => Arc::new(TimestampNanosecondVector::from_vec(
-                values.timestamp_nanosecond_values,
-            )),
-        },
-        ConcreteDataType::Time(unit) => match unit {
-            TimeType::Second(_) => Arc::new(TimeSecondVector::from_iter_values(
-                values.time_second_values.iter().map(|x| *x as i32),
-            )),
-            TimeType::Millisecond(_) => Arc::new(TimeMillisecondVector::from_iter_values(
-                values.time_millisecond_values.iter().map(|x| *x as i32),
-            )),
-            TimeType::Microsecond(_) => Arc::new(TimeMicrosecondVector::from_vec(
-                values.time_microsecond_values,
-            )),
-            TimeType::Nanosecond(_) => Arc::new(TimeNanosecondVector::from_vec(
-                values.time_nanosecond_values,
-            )),
-        },
-
-        ConcreteDataType::Interval(unit) => match unit {
-            IntervalType::YearMonth(_) => Arc::new(IntervalYearMonthVector::from_vec(
-                values.interval_year_month_values,
-            )),
-            IntervalType::DayTime(_) => Arc::new(IntervalDayTimeVector::from_iter_values(
-                values
-                    .interval_day_time_values
-                    .iter()
-                    .map(|x| IntervalDayTime::from_i64(*x).into()),
-            )),
-            IntervalType::MonthDayNano(_) => {
-                Arc::new(IntervalMonthDayNanoVector::from_iter_values(
-                    values
-                        .interval_month_day_nano_values
-                        .iter()
-                        .map(|x| IntervalMonthDayNano::new(x.months, x.days, x.nanoseconds).into()),
-                ))
-            }
-        },
-        ConcreteDataType::Decimal128(d) => Arc::new(Decimal128Vector::from_values(
-            values.decimal128_values.iter().map(|x| {
-                Decimal128::from_value_precision_scale(x.hi, x.lo, d.precision(), d.scale()).into()
-            }),
-        )),
-        ConcreteDataType::Vector(_) => Arc::new(BinaryVector::from_vec(values.binary_values)),
-        ConcreteDataType::Null(_)
-        | ConcreteDataType::List(_)
-        | ConcreteDataType::Struct(_)
-        | ConcreteDataType::Dictionary(_)
-        | ConcreteDataType::Duration(_)
-        | ConcreteDataType::Json(_) => {
-            unreachable!()
-        }
-    }
-}
-
-pub fn pb_values_to_values(data_type: &ConcreteDataType, values: Values) -> Vec<Value> {
-    match data_type {
-        ConcreteDataType::Int64(_) => values
-            .i64_values
-            .into_iter()
-            .map(|val| val.into())
-            .collect(),
-        ConcreteDataType::Float64(_) => values
-            .f64_values
-            .into_iter()
-            .map(|val| val.into())
-            .collect(),
-        ConcreteDataType::String(_) => values
-            .string_values
-            .into_iter()
-            .map(|val| val.into())
-            .collect(),
-        ConcreteDataType::Boolean(_) => values
-            .bool_values
-            .into_iter()
-            .map(|val| val.into())
-            .collect(),
-        ConcreteDataType::Int8(_) => values
-            .i8_values
-            .into_iter()
-            // Safety: Since i32 only stores i8 data here, so i32 as i8 is safe.
-            .map(|val| (val as i8).into())
-            .collect(),
-        ConcreteDataType::Int16(_) => values
-            .i16_values
-            .into_iter()
-            // Safety: Since i32 only stores i16 data here, so i32 as i16 is safe.
-            .map(|val| (val as i16).into())
-            .collect(),
-        ConcreteDataType::Int32(_) => values
-            .i32_values
-            .into_iter()
-            .map(|val| val.into())
-            .collect(),
-        ConcreteDataType::UInt8(_) => values
-            .u8_values
-            .into_iter()
-            // Safety: Since i32 only stores u8 data here, so i32 as u8 is safe.
-            .map(|val| (val as u8).into())
-            .collect(),
-        ConcreteDataType::UInt16(_) => values
-            .u16_values
-            .into_iter()
-            // Safety: Since i32 only stores u16 data here, so i32 as u16 is safe.
-            .map(|val| (val as u16).into())
-            .collect(),
-        ConcreteDataType::UInt32(_) => values
-            .u32_values
-            .into_iter()
-            .map(|val| val.into())
-            .collect(),
-        ConcreteDataType::UInt64(_) => values
-            .u64_values
-            .into_iter()
-            .map(|val| val.into())
-            .collect(),
-        ConcreteDataType::Float32(_) => values
-            .f32_values
-            .into_iter()
-            .map(|val| val.into())
-            .collect(),
-        ConcreteDataType::Binary(_) => values
-            .binary_values
-            .into_iter()
-            .map(|val| val.into())
-            .collect(),
-        ConcreteDataType::Date(_) => values
-            .date_values
-            .into_iter()
-            .map(|v| Value::Date(v.into()))
-            .collect(),
-        ConcreteDataType::Timestamp(TimestampType::Second(_)) => values
-            .timestamp_second_values
-            .into_iter()
-            .map(|v| Value::Timestamp(Timestamp::new_second(v)))
-            .collect(),
-        ConcreteDataType::Timestamp(TimestampType::Millisecond(_)) => values
-            .timestamp_millisecond_values
-            .into_iter()
-            .map(|v| Value::Timestamp(Timestamp::new_millisecond(v)))
-            .collect(),
-        ConcreteDataType::Timestamp(TimestampType::Microsecond(_)) => values
-            .timestamp_microsecond_values
-            .into_iter()
-            .map(|v| Value::Timestamp(Timestamp::new_microsecond(v)))
-            .collect(),
-        ConcreteDataType::Timestamp(TimestampType::Nanosecond(_)) => values
-            .timestamp_nanosecond_values
-            .into_iter()
-            .map(|v| Value::Timestamp(Timestamp::new_nanosecond(v)))
-            .collect(),
-        ConcreteDataType::Time(TimeType::Second(_)) => values
-            .time_second_values
-            .into_iter()
-            .map(|v| Value::Time(Time::new_second(v)))
-            .collect(),
-        ConcreteDataType::Time(TimeType::Millisecond(_)) => values
-            .time_millisecond_values
-            .into_iter()
-            .map(|v| Value::Time(Time::new_millisecond(v)))
-            .collect(),
-        ConcreteDataType::Time(TimeType::Microsecond(_)) => values
-            .time_microsecond_values
-            .into_iter()
-            .map(|v| Value::Time(Time::new_microsecond(v)))
-            .collect(),
-        ConcreteDataType::Time(TimeType::Nanosecond(_)) => values
-            .time_nanosecond_values
-            .into_iter()
-            .map(|v| Value::Time(Time::new_nanosecond(v)))
-            .collect(),
-
-        ConcreteDataType::Interval(IntervalType::YearMonth(_)) => values
-            .interval_year_month_values
-            .into_iter()
-            .map(|v| Value::IntervalYearMonth(IntervalYearMonth::from_i32(v)))
-            .collect(),
-        ConcreteDataType::Interval(IntervalType::DayTime(_)) => values
-            .interval_day_time_values
-            .into_iter()
-            .map(|v| Value::IntervalDayTime(IntervalDayTime::from_i64(v)))
-            .collect(),
-        ConcreteDataType::Interval(IntervalType::MonthDayNano(_)) => values
-            .interval_month_day_nano_values
-            .into_iter()
-            .map(|v| {
-                Value::IntervalMonthDayNano(IntervalMonthDayNano::new(
-                    v.months,
-                    v.days,
-                    v.nanoseconds,
-                ))
-            })
-            .collect(),
-        ConcreteDataType::Decimal128(d) => values
-            .decimal128_values
-            .into_iter()
-            .map(|v| {
-                Value::Decimal128(Decimal128::from_value_precision_scale(
-                    v.hi,
-                    v.lo,
-                    d.precision(),
-                    d.scale(),
-                ))
-            })
-            .collect(),
-        ConcreteDataType::Vector(_) => values.binary_values.into_iter().map(|v| v.into()).collect(),
-        ConcreteDataType::Null(_)
-        | ConcreteDataType::List(_)
-        | ConcreteDataType::Struct(_)
-        | ConcreteDataType::Dictionary(_)
-        | ConcreteDataType::Duration(_)
-        | ConcreteDataType::Json(_) => {
-            unreachable!()
-        }
-    }
-}
-
 /// Returns true if the pb semantic type is valid.
 pub fn is_semantic_type_eq(type_value: i32, semantic_type: SemanticType) -> bool {
     type_value == semantic_type as i32
@@ -1350,13 +1087,11 @@ mod tests {
     use std::sync::Arc;
 
     use common_time::interval::IntervalUnit;
-    use datatypes::types::{
-        Int32Type, IntervalDayTimeType, IntervalMonthDayNanoType, IntervalYearMonthType,
-        TimeMillisecondType, TimeSecondType, TimestampMillisecondType, TimestampSecondType,
-        UInt32Type,
+    use datatypes::scalars::ScalarVector;
+    use datatypes::types::{Int8Type, Int32Type, UInt8Type, UInt32Type};
+    use datatypes::vectors::{
+        BooleanVector, DateVector, Float32Vector, PrimitiveVector, StringVector,
     };
-    use datatypes::vectors::BooleanVector;
-    use paste::paste;
 
     use super::*;
     use crate::v1::Column;
@@ -1706,269 +1441,6 @@ mod tests {
         assert_eq!(interval.nanoseconds, 3);
     }
 
-    #[test]
-    fn test_convert_timestamp_values() {
-        // second
-        let actual = pb_values_to_values(
-            &ConcreteDataType::Timestamp(TimestampType::Second(TimestampSecondType)),
-            Values {
-                timestamp_second_values: vec![1_i64, 2_i64, 3_i64],
-                ..Default::default()
-            },
-        );
-        let expect = vec![
-            Value::Timestamp(Timestamp::new_second(1_i64)),
-            Value::Timestamp(Timestamp::new_second(2_i64)),
-            Value::Timestamp(Timestamp::new_second(3_i64)),
-        ];
-        assert_eq!(expect, actual);
-
-        // millisecond
-        let actual = pb_values_to_values(
-            &ConcreteDataType::Timestamp(TimestampType::Millisecond(TimestampMillisecondType)),
-            Values {
-                timestamp_millisecond_values: vec![1_i64, 2_i64, 3_i64],
-                ..Default::default()
-            },
-        );
-        let expect = vec![
-            Value::Timestamp(Timestamp::new_millisecond(1_i64)),
-            Value::Timestamp(Timestamp::new_millisecond(2_i64)),
-            Value::Timestamp(Timestamp::new_millisecond(3_i64)),
-        ];
-        assert_eq!(expect, actual);
-    }
-
-    #[test]
-    fn test_convert_time_values() {
-        // second
-        let actual = pb_values_to_values(
-            &ConcreteDataType::Time(TimeType::Second(TimeSecondType)),
-            Values {
-                time_second_values: vec![1_i64, 2_i64, 3_i64],
-                ..Default::default()
-            },
-        );
-        let expect = vec![
-            Value::Time(Time::new_second(1_i64)),
-            Value::Time(Time::new_second(2_i64)),
-            Value::Time(Time::new_second(3_i64)),
-        ];
-        assert_eq!(expect, actual);
-
-        // millisecond
-        let actual = pb_values_to_values(
-            &ConcreteDataType::Time(TimeType::Millisecond(TimeMillisecondType)),
-            Values {
-                time_millisecond_values: vec![1_i64, 2_i64, 3_i64],
-                ..Default::default()
-            },
-        );
-        let expect = vec![
-            Value::Time(Time::new_millisecond(1_i64)),
-            Value::Time(Time::new_millisecond(2_i64)),
-            Value::Time(Time::new_millisecond(3_i64)),
-        ];
-        assert_eq!(expect, actual);
-    }
-
-    #[test]
-    fn test_convert_interval_values() {
-        // year_month
-        let actual = pb_values_to_values(
-            &ConcreteDataType::Interval(IntervalType::YearMonth(IntervalYearMonthType)),
-            Values {
-                interval_year_month_values: vec![1_i32, 2_i32, 3_i32],
-                ..Default::default()
-            },
-        );
-        let expect = vec![
-            Value::IntervalYearMonth(IntervalYearMonth::new(1_i32)),
-            Value::IntervalYearMonth(IntervalYearMonth::new(2_i32)),
-            Value::IntervalYearMonth(IntervalYearMonth::new(3_i32)),
-        ];
-        assert_eq!(expect, actual);
-
-        // day_time
-        let actual = pb_values_to_values(
-            &ConcreteDataType::Interval(IntervalType::DayTime(IntervalDayTimeType)),
-            Values {
-                interval_day_time_values: vec![1_i64, 2_i64, 3_i64],
-                ..Default::default()
-            },
-        );
-        let expect = vec![
-            Value::IntervalDayTime(IntervalDayTime::from_i64(1_i64)),
-            Value::IntervalDayTime(IntervalDayTime::from_i64(2_i64)),
-            Value::IntervalDayTime(IntervalDayTime::from_i64(3_i64)),
-        ];
-        assert_eq!(expect, actual);
-
-        // month_day_nano
-        let actual = pb_values_to_values(
-            &ConcreteDataType::Interval(IntervalType::MonthDayNano(IntervalMonthDayNanoType)),
-            Values {
-                interval_month_day_nano_values: vec![
-                    v1::IntervalMonthDayNano {
-                        months: 1,
-                        days: 2,
-                        nanoseconds: 3,
-                    },
-                    v1::IntervalMonthDayNano {
-                        months: 5,
-                        days: 6,
-                        nanoseconds: 7,
-                    },
-                    v1::IntervalMonthDayNano {
-                        months: 9,
-                        days: 10,
-                        nanoseconds: 11,
-                    },
-                ],
-                ..Default::default()
-            },
-        );
-        let expect = vec![
-            Value::IntervalMonthDayNano(IntervalMonthDayNano::new(1, 2, 3)),
-            Value::IntervalMonthDayNano(IntervalMonthDayNano::new(5, 6, 7)),
-            Value::IntervalMonthDayNano(IntervalMonthDayNano::new(9, 10, 11)),
-        ];
-        assert_eq!(expect, actual);
-    }
-
-    macro_rules! test_convert_values {
-        ($grpc_data_type: ident, $values: expr,  $concrete_data_type: ident, $expected_ret: expr) => {
-            paste! {
-                #[test]
-                fn [<test_convert_ $grpc_data_type _values>]() {
-                    let values = Values {
-                        [<$grpc_data_type _values>]: $values,
-                        ..Default::default()
-                    };
-
-                    let data_type = ConcreteDataType::[<$concrete_data_type _datatype>]();
-                    let result = pb_values_to_values(&data_type, values);
-
-                    assert_eq!(
-                        $expected_ret,
-                        result
-                    );
-                }
-            }
-        };
-    }
-
-    test_convert_values!(
-        i8,
-        vec![1_i32, 2, 3],
-        int8,
-        vec![Value::Int8(1), Value::Int8(2), Value::Int8(3)]
-    );
-
-    test_convert_values!(
-        u8,
-        vec![1_u32, 2, 3],
-        uint8,
-        vec![Value::UInt8(1), Value::UInt8(2), Value::UInt8(3)]
-    );
-
-    test_convert_values!(
-        i16,
-        vec![1_i32, 2, 3],
-        int16,
-        vec![Value::Int16(1), Value::Int16(2), Value::Int16(3)]
-    );
-
-    test_convert_values!(
-        u16,
-        vec![1_u32, 2, 3],
-        uint16,
-        vec![Value::UInt16(1), Value::UInt16(2), Value::UInt16(3)]
-    );
-
-    test_convert_values!(
-        i32,
-        vec![1, 2, 3],
-        int32,
-        vec![Value::Int32(1), Value::Int32(2), Value::Int32(3)]
-    );
-
-    test_convert_values!(
-        u32,
-        vec![1, 2, 3],
-        uint32,
-        vec![Value::UInt32(1), Value::UInt32(2), Value::UInt32(3)]
-    );
-
-    test_convert_values!(
-        i64,
-        vec![1, 2, 3],
-        int64,
-        vec![Value::Int64(1), Value::Int64(2), Value::Int64(3)]
-    );
-
-    test_convert_values!(
-        u64,
-        vec![1, 2, 3],
-        uint64,
-        vec![Value::UInt64(1), Value::UInt64(2), Value::UInt64(3)]
-    );
-
-    test_convert_values!(
-        f32,
-        vec![1.0, 2.0, 3.0],
-        float32,
-        vec![
-            Value::Float32(1.0.into()),
-            Value::Float32(2.0.into()),
-            Value::Float32(3.0.into())
-        ]
-    );
-
-    test_convert_values!(
-        f64,
-        vec![1.0, 2.0, 3.0],
-        float64,
-        vec![
-            Value::Float64(1.0.into()),
-            Value::Float64(2.0.into()),
-            Value::Float64(3.0.into())
-        ]
-    );
-
-    test_convert_values!(
-        string,
-        vec!["1".to_string(), "2".to_string(), "3".to_string()],
-        string,
-        vec![
-            Value::String("1".into()),
-            Value::String("2".into()),
-            Value::String("3".into())
-        ]
-    );
-
-    test_convert_values!(
-        binary,
-        vec!["1".into(), "2".into(), "3".into()],
-        binary,
-        vec![
-            Value::Binary(b"1".to_vec().into()),
-            Value::Binary(b"2".to_vec().into()),
-            Value::Binary(b"3".to_vec().into())
-        ]
-    );
-
-    test_convert_values!(
-        date,
-        vec![1, 2, 3],
-        date,
-        vec![
-            Value::Date(1.into()),
-            Value::Date(2.into()),
-            Value::Date(3.into())
-        ]
-    );
-
     #[test]
     fn test_vectors_to_rows_for_different_types() {
         let boolean_vec = BooleanVector::from_vec(vec![true, false, true]);
diff --git a/src/common/grpc-expr/src/delete.rs b/src/common/grpc-expr/src/delete.rs
deleted file mode 100644
index d48893a7d2..0000000000
--- a/src/common/grpc-expr/src/delete.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::collections::HashMap;
-
-use api::helper::ColumnDataTypeWrapper;
-use api::v1::{Column, DeleteRequest as GrpcDeleteRequest};
-use datatypes::prelude::ConcreteDataType;
-use snafu::{ResultExt, ensure};
-use table::requests::DeleteRequest;
-
-use crate::error::{ColumnDataTypeSnafu, IllegalDeleteRequestSnafu, Result};
-use crate::insert::add_values_to_builder;
-
-pub fn to_table_delete_request(
-    catalog_name: &str,
-    schema_name: &str,
-    request: GrpcDeleteRequest,
-) -> Result<DeleteRequest> {
-    let row_count = request.row_count as usize;
-
-    let mut key_column_values = HashMap::with_capacity(request.key_columns.len());
-    for Column {
-        column_name,
-        values,
-        null_mask,
-        datatype,
-        datatype_extension,
-        ..
-    } in request.key_columns
-    {
-        let Some(values) = values else { continue };
-
-        let datatype: ConcreteDataType =
-            ColumnDataTypeWrapper::try_new(datatype, datatype_extension)
-                .context(ColumnDataTypeSnafu)?
-                .into();
-        let vector = add_values_to_builder(datatype, values, row_count, null_mask)?;
-
-        ensure!(
-            key_column_values
-                .insert(column_name.clone(), vector)
-                .is_none(),
-            IllegalDeleteRequestSnafu {
-                reason: format!("Duplicated column '{column_name}' in delete request.")
-            }
-        );
-    }
-
-    Ok(DeleteRequest {
-        catalog_name: catalog_name.to_string(),
-        schema_name: schema_name.to_string(),
-        table_name: request.table_name,
-        key_column_values,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use api::v1::ColumnDataType;
-    use api::v1::column::Values;
-    use datatypes::prelude::{ScalarVector, VectorRef};
-    use datatypes::vectors::{Int32Vector, StringVector};
-
-    use super::*;
-
-    #[test]
-    fn test_to_table_delete_request() {
-        let grpc_request = GrpcDeleteRequest {
-            table_name: "foo".to_string(),
-            key_columns: vec![
-                Column {
-                    column_name: "id".to_string(),
-                    values: Some(Values {
-                        i32_values: vec![1, 2, 3],
-                        ..Default::default()
-                    }),
-                    datatype: ColumnDataType::Int32 as i32,
-                    ..Default::default()
-                },
-                Column {
-                    column_name: "name".to_string(),
-                    values: Some(Values {
-                        string_values: vec!["a".to_string(), "b".to_string(), "c".to_string()],
-                        ..Default::default()
-                    }),
-                    datatype: ColumnDataType::String as i32,
-                    ..Default::default()
-                },
-            ],
-            row_count: 3,
-        };
-
-        let mut request =
-            to_table_delete_request("foo_catalog", "foo_schema", grpc_request).unwrap();
-
-        assert_eq!(request.catalog_name, "foo_catalog");
-        assert_eq!(request.schema_name, "foo_schema");
-        assert_eq!(request.table_name, "foo");
-        assert_eq!(
-            Arc::new(Int32Vector::from_slice(vec![1, 2, 3])) as VectorRef,
-            request.key_column_values.remove("id").unwrap()
-        );
-        assert_eq!(
-            Arc::new(StringVector::from_slice(&["a", "b", "c"])) as VectorRef,
-            request.key_column_values.remove("name").unwrap()
-        );
-        assert!(request.key_column_values.is_empty());
-    }
-}
diff --git a/src/common/grpc-expr/src/error.rs b/src/common/grpc-expr/src/error.rs
index e4f441d882..aab1adb672 100644
--- a/src/common/grpc-expr/src/error.rs
+++ b/src/common/grpc-expr/src/error.rs
@@ -25,13 +25,6 @@ use store_api::metadata::MetadataError;
 #[snafu(visibility(pub))]
 #[stack_trace_debug]
 pub enum Error {
-    #[snafu(display("Illegal delete request, reason: {reason}"))]
-    IllegalDeleteRequest {
-        reason: String,
-        #[snafu(implicit)]
-        location: Location,
-    },
-
     #[snafu(display("Column datatype error"))]
     ColumnDataType {
         #[snafu(implicit)]
@@ -65,13 +58,6 @@ pub enum Error {
         location: Location,
     },
 
-    #[snafu(display("Failed to create vector"))]
-    CreateVector {
-        #[snafu(implicit)]
-        location: Location,
-        source: datatypes::error::Error,
-    },
-
     #[snafu(display("Missing required field in protobuf, field: {}", field))]
     MissingField {
         field: String,
@@ -87,13 +73,6 @@ pub enum Error {
         source: api::error::Error,
     },
 
-    #[snafu(display("Unexpected values length, reason: {}", reason))]
-    UnexpectedValuesLength {
-        reason: String,
-        #[snafu(implicit)]
-        location: Location,
-    },
-
     #[snafu(display("Unknown location type: {}", location_type))]
     UnknownLocationType {
         location_type: i32,
@@ -189,18 +168,13 @@ pub type Result<T> = std::result::Result<T, Error>;
 impl ErrorExt for Error {
     fn status_code(&self) -> StatusCode {
         match self {
-            Error::IllegalDeleteRequest { .. } => StatusCode::InvalidArguments,
-
             Error::ColumnDataType { .. } => StatusCode::Internal,
             Error::DuplicatedTimestampColumn { .. }
             | Error::DuplicatedColumnName { .. }
             | Error::MissingTimestampColumn { .. } => StatusCode::InvalidArguments,
-            Error::CreateVector { .. } => StatusCode::InvalidArguments,
             Error::MissingField { .. } => StatusCode::InvalidArguments,
             Error::InvalidColumnDef { source, .. } => source.status_code(),
-            Error::UnexpectedValuesLength { .. } | Error::UnknownLocationType { .. } => {
-                StatusCode::InvalidArguments
-            }
+            Error::UnknownLocationType { .. } => StatusCode::InvalidArguments,
 
             Error::UnknownColumnDataType { .. } | Error::InvalidStringIndexColumnType { .. } => {
                 StatusCode::InvalidArguments
diff --git a/src/common/grpc-expr/src/insert.rs b/src/common/grpc-expr/src/insert.rs
deleted file mode 100644
index d1e360d148..0000000000
--- a/src/common/grpc-expr/src/insert.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use api::helper;
-use api::v1::column::Values;
-use common_base::BitVec;
-use datatypes::data_type::{ConcreteDataType, DataType};
-use datatypes::prelude::VectorRef;
-use snafu::{ResultExt, ensure};
-
-use crate::error::{CreateVectorSnafu, Result, UnexpectedValuesLengthSnafu};
-
-pub(crate) fn add_values_to_builder(
-    data_type: ConcreteDataType,
-    values: Values,
-    row_count: usize,
-    null_mask: Vec<u8>,
-) -> Result<VectorRef> {
-    if null_mask.is_empty() {
-        Ok(helper::pb_values_to_vector_ref(&data_type, values))
-    } else {
-        let builder = &mut data_type.create_mutable_vector(row_count);
-        let values = helper::pb_values_to_values(&data_type, values);
-        let null_mask = BitVec::from_vec(null_mask);
-        ensure!(
-            null_mask.count_ones() + values.len() == row_count,
-            UnexpectedValuesLengthSnafu {
-                reason: "If null_mask is not empty, the sum of the number of nulls and the length of values must be equal to row_count."
-            }
-        );
-
-        let mut idx_of_values = 0;
-        for idx in 0..row_count {
-            match is_null(&null_mask, idx) {
-                Some(true) => builder.push_null(),
-                _ => {
-                    builder
-                        .try_push_value_ref(&values[idx_of_values].as_value_ref())
-                        .context(CreateVectorSnafu)?;
-                    idx_of_values += 1
-                }
-            }
-        }
-        Ok(builder.to_vector())
-    }
-}
-
-fn is_null(null_mask: &BitVec, idx: usize) -> Option<bool> {
-    null_mask.get(idx).as_deref().copied()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_is_null() {
-        let null_mask = BitVec::from_slice(&[0b0000_0001, 0b0000_1000]);
-
-        assert_eq!(Some(true), is_null(&null_mask, 0));
-        assert_eq!(Some(false), is_null(&null_mask, 1));
-        assert_eq!(Some(false), is_null(&null_mask, 10));
-        assert_eq!(Some(true), is_null(&null_mask, 11));
-        assert_eq!(Some(false), is_null(&null_mask, 12));
-
-        assert_eq!(None, is_null(&null_mask, 16));
-        assert_eq!(None, is_null(&null_mask, 99));
-    }
-}
diff --git a/src/common/grpc-expr/src/lib.rs b/src/common/grpc-expr/src/lib.rs
index c774b751d4..0941cb650d 100644
--- a/src/common/grpc-expr/src/lib.rs
+++ b/src/common/grpc-expr/src/lib.rs
@@ -13,9 +13,7 @@
 // limitations under the License.
 
 mod alter;
-pub mod delete;
 pub mod error;
-pub mod insert;
 pub mod util;
 
 pub use alter::{alter_expr_to_request, create_table_schema};