refactor: grpc insert (#2188)

* feat: interval type for row protocol * feat: minor refactor grpc insert * Update src/common/grpc-expr/src/util.rs Co-authored-by: Ruihang Xia <waynestxia@gmail.com> * fix: by comment --------- Co-authored-by: Ruihang Xia <waynestxia@gmail.com>
2026-01-16 18:22:55 +00:00 · 2023-08-16 19:25:25 +08:00
parent bb062003ef
commit 6cd7319d67
13 changed files with 796 additions and 949 deletions
--- a/src/api/Cargo.toml
+++ b/src/api/Cargo.toml
@@ -16,3 +16,6 @@ tonic.workspace = true

 [build-dependencies]
 tonic-build = "0.9"
+
+[dev-dependencies]
+paste = "1.0"
--- a/src/api/src/helper.rs
+++ b/src/api/src/helper.rs
@@ -12,15 +12,27 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

+use std::sync::Arc;
+
 use common_base::BitVec;
 use common_time::interval::IntervalUnit;
 use common_time::time::Time;
 use common_time::timestamp::TimeUnit;
 use common_time::{Date, DateTime, Interval, Timestamp};
 use datatypes::prelude::{ConcreteDataType, ValueRef};
-use datatypes::types::{IntervalType, TimeType, TimestampType};
+use datatypes::scalars::ScalarVector;
+use datatypes::types::{
+    Int16Type, Int8Type, IntervalType, TimeType, TimestampType, UInt16Type, UInt8Type,
+};
 use datatypes::value::{OrderedF32, OrderedF64, Value};
-use datatypes::vectors::VectorRef;
+use datatypes::vectors::{
+    BinaryVector, BooleanVector, DateTimeVector, DateVector, Float32Vector, Float64Vector,
+    Int32Vector, Int64Vector, IntervalDayTimeVector, IntervalMonthDayNanoVector,
+    IntervalYearMonthVector, PrimitiveVector, StringVector, TimeMicrosecondVector,
+    TimeMillisecondVector, TimeNanosecondVector, TimeSecondVector, TimestampMicrosecondVector,
+    TimestampMillisecondVector, TimestampNanosecondVector, TimestampSecondVector, UInt32Vector,
+    UInt64Vector, VectorRef,
+};
 use greptime_proto::v1;
 use greptime_proto::v1::ddl_request::Expr;
 use greptime_proto::v1::greptime_request::Request;
@@ -300,9 +312,9 @@ pub fn request_type(request: &Request) -> &'static str {
        Request::Inserts(_) => "inserts",
        Request::Query(query_req) => query_request_type(query_req),
        Request::Ddl(ddl_req) => ddl_request_type(ddl_req),
-        Request::RowInserts(_) => "row_inserts",
-        Request::RowDelete(_) => "row_delete",
        Request::Deletes(_) => "deletes",
+        Request::RowInserts(_) => "row_inserts",
+        Request::RowDeletes(_) => "row_deletes",
    }
 }

@@ -341,60 +353,265 @@ pub fn convert_i128_to_interval(v: i128) -> IntervalMonthDayNano {
    }
 }

-pub fn pb_value_to_value_ref(value: &greptime_proto::v1::Value) -> ValueRef {
+pub fn pb_value_to_value_ref(value: &v1::Value) -> ValueRef {
    let Some(value) = &value.value_data else {
        return ValueRef::Null;
    };

    match value {
-        greptime_proto::v1::value::ValueData::I8Value(v) => ValueRef::Int8(*v as i8),
-        greptime_proto::v1::value::ValueData::I16Value(v) => ValueRef::Int16(*v as i16),
-        greptime_proto::v1::value::ValueData::I32Value(v) => ValueRef::Int32(*v),
-        greptime_proto::v1::value::ValueData::I64Value(v) => ValueRef::Int64(*v),
-        greptime_proto::v1::value::ValueData::U8Value(v) => ValueRef::UInt8(*v as u8),
-        greptime_proto::v1::value::ValueData::U16Value(v) => ValueRef::UInt16(*v as u16),
-        greptime_proto::v1::value::ValueData::U32Value(v) => ValueRef::UInt32(*v),
-        greptime_proto::v1::value::ValueData::U64Value(v) => ValueRef::UInt64(*v),
-        greptime_proto::v1::value::ValueData::F32Value(f) => {
-            ValueRef::Float32(OrderedF32::from(*f))
+        ValueData::I8Value(v) => ValueRef::Int8(*v as i8),
+        ValueData::I16Value(v) => ValueRef::Int16(*v as i16),
+        ValueData::I32Value(v) => ValueRef::Int32(*v),
+        ValueData::I64Value(v) => ValueRef::Int64(*v),
+        ValueData::U8Value(v) => ValueRef::UInt8(*v as u8),
+        ValueData::U16Value(v) => ValueRef::UInt16(*v as u16),
+        ValueData::U32Value(v) => ValueRef::UInt32(*v),
+        ValueData::U64Value(v) => ValueRef::UInt64(*v),
+        ValueData::F32Value(f) => ValueRef::Float32(OrderedF32::from(*f)),
+        ValueData::F64Value(f) => ValueRef::Float64(OrderedF64::from(*f)),
+        ValueData::BoolValue(b) => ValueRef::Boolean(*b),
+        ValueData::BinaryValue(bytes) => ValueRef::Binary(bytes.as_slice()),
+        ValueData::StringValue(string) => ValueRef::String(string.as_str()),
+        ValueData::DateValue(d) => ValueRef::Date(Date::from(*d)),
+        ValueData::DatetimeValue(d) => ValueRef::DateTime(DateTime::new(*d)),
+        ValueData::TsSecondValue(t) => ValueRef::Timestamp(Timestamp::new_second(*t)),
+        ValueData::TsMillisecondValue(t) => ValueRef::Timestamp(Timestamp::new_millisecond(*t)),
+        ValueData::TsMicrosecondValue(t) => ValueRef::Timestamp(Timestamp::new_microsecond(*t)),
+        ValueData::TsNanosecondValue(t) => ValueRef::Timestamp(Timestamp::new_nanosecond(*t)),
+        ValueData::TimeSecondValue(t) => ValueRef::Time(Time::new_second(*t)),
+        ValueData::TimeMillisecondValue(t) => ValueRef::Time(Time::new_millisecond(*t)),
+        ValueData::TimeMicrosecondValue(t) => ValueRef::Time(Time::new_microsecond(*t)),
+        ValueData::TimeNanosecondValue(t) => ValueRef::Time(Time::new_nanosecond(*t)),
+        ValueData::IntervalYearMonthValues(v) => ValueRef::Interval(Interval::from_i32(*v)),
+        ValueData::IntervalDayTimeValues(v) => ValueRef::Interval(Interval::from_i64(*v)),
+        ValueData::IntervalMonthDayNanoValues(v) => {
+            let interval = Interval::from_month_day_nano(v.months, v.days, v.nanoseconds);
+            ValueRef::Interval(interval)
        }
-        greptime_proto::v1::value::ValueData::F64Value(f) => {
-            ValueRef::Float64(OrderedF64::from(*f))
+    }
+}
+
+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::DateTime(_) => Arc::new(DateTimeVector::from_vec(values.datetime_values)),
+        ConcreteDataType::Timestamp(unit) => match unit {
+            TimestampType::Second(_) => {
+                Arc::new(TimestampSecondVector::from_vec(values.ts_second_values))
+            }
+            TimestampType::Millisecond(_) => Arc::new(TimestampMillisecondVector::from_vec(
+                values.ts_millisecond_values,
+            )),
+            TimestampType::Microsecond(_) => Arc::new(TimestampMicrosecondVector::from_vec(
+                values.ts_microsecond_values,
+            )),
+            TimestampType::Nanosecond(_) => Arc::new(TimestampNanosecondVector::from_vec(
+                values.ts_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_vec(
+                values.interval_day_time_values,
+            )),
+            IntervalType::MonthDayNano(_) => {
+                Arc::new(IntervalMonthDayNanoVector::from_iter_values(
+                    values.interval_month_day_nano_values.iter().map(|x| {
+                        Interval::from_month_day_nano(x.months, x.days, x.nanoseconds).to_i128()
+                    }),
+                ))
+            }
+        },
+        ConcreteDataType::Null(_) | ConcreteDataType::List(_) | ConcreteDataType::Dictionary(_) => {
+            unreachable!()
        }
-        greptime_proto::v1::value::ValueData::BoolValue(b) => ValueRef::Boolean(*b),
-        greptime_proto::v1::value::ValueData::BinaryValue(bytes) => {
-            ValueRef::Binary(bytes.as_slice())
-        }
-        greptime_proto::v1::value::ValueData::StringValue(string) => {
-            ValueRef::String(string.as_str())
-        }
-        greptime_proto::v1::value::ValueData::DateValue(d) => ValueRef::Date(Date::from(*d)),
-        greptime_proto::v1::value::ValueData::DatetimeValue(d) => {
-            ValueRef::DateTime(DateTime::new(*d))
-        }
-        greptime_proto::v1::value::ValueData::TsSecondValue(t) => {
-            ValueRef::Timestamp(Timestamp::new_second(*t))
-        }
-        greptime_proto::v1::value::ValueData::TsMillisecondValue(t) => {
-            ValueRef::Timestamp(Timestamp::new_millisecond(*t))
-        }
-        greptime_proto::v1::value::ValueData::TsMicrosecondValue(t) => {
-            ValueRef::Timestamp(Timestamp::new_microsecond(*t))
-        }
-        greptime_proto::v1::value::ValueData::TsNanosecondValue(t) => {
-            ValueRef::Timestamp(Timestamp::new_nanosecond(*t))
-        }
-        greptime_proto::v1::value::ValueData::TimeSecondValue(t) => {
-            ValueRef::Time(Time::new_second(*t))
-        }
-        greptime_proto::v1::value::ValueData::TimeMillisecondValue(t) => {
-            ValueRef::Time(Time::new_millisecond(*t))
-        }
-        greptime_proto::v1::value::ValueData::TimeMicrosecondValue(t) => {
-            ValueRef::Time(Time::new_microsecond(*t))
-        }
-        greptime_proto::v1::value::ValueData::TimeNanosecondValue(t) => {
-            ValueRef::Time(Time::new_nanosecond(*t))
+    }
+}
+
+pub fn pb_values_to_values(data_type: &ConcreteDataType, values: Values) -> Vec<Value> {
+    // TODO(fys): use macros to optimize code
+    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::DateTime(_) => values
+            .datetime_values
+            .into_iter()
+            .map(|v| Value::DateTime(v.into()))
+            .collect(),
+        ConcreteDataType::Date(_) => values
+            .date_values
+            .into_iter()
+            .map(|v| Value::Date(v.into()))
+            .collect(),
+        ConcreteDataType::Timestamp(TimestampType::Second(_)) => values
+            .ts_second_values
+            .into_iter()
+            .map(|v| Value::Timestamp(Timestamp::new_second(v)))
+            .collect(),
+        ConcreteDataType::Timestamp(TimestampType::Millisecond(_)) => values
+            .ts_millisecond_values
+            .into_iter()
+            .map(|v| Value::Timestamp(Timestamp::new_millisecond(v)))
+            .collect(),
+        ConcreteDataType::Timestamp(TimestampType::Microsecond(_)) => values
+            .ts_microsecond_values
+            .into_iter()
+            .map(|v| Value::Timestamp(Timestamp::new_microsecond(v)))
+            .collect(),
+        ConcreteDataType::Timestamp(TimestampType::Nanosecond(_)) => values
+            .ts_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::Interval(Interval::from_i32(v)))
+            .collect(),
+        ConcreteDataType::Interval(IntervalType::DayTime(_)) => values
+            .interval_day_time_values
+            .into_iter()
+            .map(|v| Value::Interval(Interval::from_i64(v)))
+            .collect(),
+        ConcreteDataType::Interval(IntervalType::MonthDayNano(_)) => values
+            .interval_month_day_nano_values
+            .into_iter()
+            .map(|v| {
+                Value::Interval(Interval::from_month_day_nano(
+                    v.months,
+                    v.days,
+                    v.nanoseconds,
+                ))
+            })
+            .collect(),
+        ConcreteDataType::Null(_) | ConcreteDataType::List(_) | ConcreteDataType::Dictionary(_) => {
+            unreachable!()
        }
    }
 }
@@ -478,19 +695,32 @@ pub fn to_proto_value(value: Value) -> Option<v1::Value> {
        },
        Value::Time(v) => match v.unit() {
            TimeUnit::Second => v1::Value {
-                value_data: Some(v1::value::ValueData::TimeSecondValue(v.value())),
+                value_data: Some(ValueData::TimeSecondValue(v.value())),
            },
            TimeUnit::Millisecond => v1::Value {
-                value_data: Some(v1::value::ValueData::TimeMillisecondValue(v.value())),
+                value_data: Some(ValueData::TimeMillisecondValue(v.value())),
            },
            TimeUnit::Microsecond => v1::Value {
-                value_data: Some(v1::value::ValueData::TimeMicrosecondValue(v.value())),
+                value_data: Some(ValueData::TimeMicrosecondValue(v.value())),
            },
            TimeUnit::Nanosecond => v1::Value {
-                value_data: Some(v1::value::ValueData::TimeNanosecondValue(v.value())),
+                value_data: Some(ValueData::TimeNanosecondValue(v.value())),
            },
        },
-        Value::Interval(_) | Value::List(_) => return None,
+        Value::Interval(v) => match v.unit() {
+            IntervalUnit::YearMonth => v1::Value {
+                value_data: Some(ValueData::IntervalYearMonthValues(v.to_i32())),
+            },
+            IntervalUnit::DayTime => v1::Value {
+                value_data: Some(ValueData::IntervalDayTimeValues(v.to_i64())),
+            },
+            IntervalUnit::MonthDayNano => v1::Value {
+                value_data: Some(ValueData::IntervalMonthDayNanoValues(
+                    convert_i128_to_interval(v.to_i128()),
+                )),
+            },
+        },
+        Value::List(_) => return None,
    };

    Some(proto_value)
@@ -500,8 +730,7 @@ pub fn to_proto_value(value: Value) -> Option<v1::Value> {
 ///
 /// If value is null, returns `None`.
 pub fn proto_value_type(value: &v1::Value) -> Option<ColumnDataType> {
-    let value_data = value.value_data.as_ref()?;
-    let value_type = match value_data {
+    let value_type = match value.value_data.as_ref()? {
        ValueData::I8Value(_) => ColumnDataType::Int8,
        ValueData::I16Value(_) => ColumnDataType::Int16,
        ValueData::I32Value(_) => ColumnDataType::Int32,
@@ -525,6 +754,9 @@ pub fn proto_value_type(value: &v1::Value) -> Option<ColumnDataType> {
        ValueData::TimeMillisecondValue(_) => ColumnDataType::TimeMillisecond,
        ValueData::TimeMicrosecondValue(_) => ColumnDataType::TimeMicrosecond,
        ValueData::TimeNanosecondValue(_) => ColumnDataType::TimeNanosecond,
+        ValueData::IntervalYearMonthValues(_) => ColumnDataType::IntervalYearMonth,
+        ValueData::IntervalDayTimeValues(_) => ColumnDataType::IntervalDayTime,
+        ValueData::IntervalMonthDayNanoValues(_) => ColumnDataType::IntervalMonthDayNano,
    };
    Some(value_type)
 }
@@ -583,12 +815,17 @@ fn is_column_type_eq(column_type: ColumnDataType, expect_type: &ConcreteDataType
 mod tests {
    use std::sync::Arc;

+    use datatypes::types::{
+        IntervalDayTimeType, IntervalMonthDayNanoType, IntervalYearMonthType, TimeMillisecondType,
+        TimeSecondType, TimestampMillisecondType, TimestampSecondType,
+    };
    use datatypes::vectors::{
        BooleanVector, IntervalDayTimeVector, IntervalMonthDayNanoVector, IntervalYearMonthVector,
        TimeMicrosecondVector, TimeMillisecondVector, TimeNanosecondVector, TimeSecondVector,
        TimestampMicrosecondVector, TimestampMillisecondVector, TimestampNanosecondVector,
        TimestampSecondVector, Vector,
    };
+    use paste::paste;

    use super::*;

@@ -1009,4 +1246,278 @@ mod tests {
        assert_eq!(interval.days, 0);
        assert_eq!(interval.nanoseconds, 3000);
    }
+
+    #[test]
+    fn test_convert_timestamp_values() {
+        // second
+        let actual = pb_values_to_values(
+            &ConcreteDataType::Timestamp(TimestampType::Second(TimestampSecondType)),
+            Values {
+                ts_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 {
+                ts_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::Interval(Interval::from_year_month(1_i32)),
+            Value::Interval(Interval::from_year_month(2_i32)),
+            Value::Interval(Interval::from_year_month(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::Interval(Interval::from_i64(1_i64)),
+            Value::Interval(Interval::from_i64(2_i64)),
+            Value::Interval(Interval::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![
+                    IntervalMonthDayNano {
+                        months: 1,
+                        days: 2,
+                        nanoseconds: 3,
+                    },
+                    IntervalMonthDayNano {
+                        months: 5,
+                        days: 6,
+                        nanoseconds: 7,
+                    },
+                    IntervalMonthDayNano {
+                        months: 9,
+                        days: 10,
+                        nanoseconds: 11,
+                    },
+                ],
+                ..Default::default()
+            },
+        );
+        let expect = vec![
+            Value::Interval(Interval::from_month_day_nano(1, 2, 3)),
+            Value::Interval(Interval::from_month_day_nano(5, 6, 7)),
+            Value::Interval(Interval::from_month_day_nano(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_convert_values!(
+        datetime,
+        vec![1.into(), 2.into(), 3.into()],
+        datetime,
+        vec![
+            Value::DateTime(1.into()),
+            Value::DateTime(2.into()),
+            Value::DateTime(3.into())
+        ]
+    );
 }