api/
helper.rs

1// Copyright 2023 Greptime Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use std::collections::HashSet;
16use std::sync::Arc;
17
18use common_decimal::Decimal128;
19use common_decimal::decimal128::{DECIMAL128_DEFAULT_SCALE, DECIMAL128_MAX_PRECISION};
20use common_time::time::Time;
21use common_time::timestamp::TimeUnit;
22use common_time::{Date, IntervalDayTime, IntervalMonthDayNano, IntervalYearMonth, Timestamp};
23use datatypes::prelude::{ConcreteDataType, ValueRef};
24use datatypes::scalars::ScalarVector;
25use datatypes::types::{
26    Int8Type, Int16Type, IntervalType, StructField, StructType, TimeType, TimestampType, UInt8Type,
27    UInt16Type,
28};
29use datatypes::value::{
30    ListValue, ListValueRef, OrderedF32, OrderedF64, StructValue, StructValueRef, Value,
31};
32use datatypes::vectors::{
33    BinaryVector, BooleanVector, DateVector, Decimal128Vector, Float32Vector, Float64Vector,
34    Int32Vector, Int64Vector, IntervalDayTimeVector, IntervalMonthDayNanoVector,
35    IntervalYearMonthVector, PrimitiveVector, StringVector, TimeMicrosecondVector,
36    TimeMillisecondVector, TimeNanosecondVector, TimeSecondVector, TimestampMicrosecondVector,
37    TimestampMillisecondVector, TimestampNanosecondVector, TimestampSecondVector, UInt32Vector,
38    UInt64Vector, VectorRef,
39};
40use greptime_proto::v1::column_data_type_extension::TypeExt;
41use greptime_proto::v1::ddl_request::Expr;
42use greptime_proto::v1::greptime_request::Request;
43use greptime_proto::v1::query_request::Query;
44use greptime_proto::v1::value::ValueData;
45use greptime_proto::v1::{
46    self, ColumnDataTypeExtension, DdlRequest, DecimalTypeExtension, JsonTypeExtension,
47    ListTypeExtension, QueryRequest, Row, SemanticType, StructTypeExtension, VectorTypeExtension,
48};
49use paste::paste;
50use snafu::prelude::*;
51
52use crate::error::{self, InconsistentTimeUnitSnafu, InvalidTimeUnitSnafu, Result};
53use crate::v1::column::Values;
54use crate::v1::{ColumnDataType, Value as GrpcValue};
55
56/// ColumnDataTypeWrapper is a wrapper of ColumnDataType and ColumnDataTypeExtension.
57/// It could be used to convert with ConcreteDataType.
58#[derive(Debug, PartialEq)]
59pub struct ColumnDataTypeWrapper {
60    datatype: ColumnDataType,
61    datatype_ext: Option<ColumnDataTypeExtension>,
62}
63
64impl ColumnDataTypeWrapper {
65    /// Try to create a ColumnDataTypeWrapper from i32(ColumnDataType) and ColumnDataTypeExtension.
66    pub fn try_new(datatype: i32, datatype_ext: Option<ColumnDataTypeExtension>) -> Result<Self> {
67        let datatype = ColumnDataType::try_from(datatype)
68            .context(error::UnknownColumnDataTypeSnafu { datatype })?;
69        Ok(Self {
70            datatype,
71            datatype_ext,
72        })
73    }
74
75    /// Create a ColumnDataTypeWrapper from ColumnDataType and ColumnDataTypeExtension.
76    pub fn new(datatype: ColumnDataType, datatype_ext: Option<ColumnDataTypeExtension>) -> Self {
77        Self {
78            datatype,
79            datatype_ext,
80        }
81    }
82
83    /// Get the ColumnDataType.
84    pub fn datatype(&self) -> ColumnDataType {
85        self.datatype
86    }
87
88    /// Get a tuple of ColumnDataType and ColumnDataTypeExtension.
89    pub fn to_parts(&self) -> (ColumnDataType, Option<ColumnDataTypeExtension>) {
90        (self.datatype, self.datatype_ext.clone())
91    }
92}
93
94impl From<ColumnDataTypeWrapper> for ConcreteDataType {
95    fn from(datatype_wrapper: ColumnDataTypeWrapper) -> Self {
96        match datatype_wrapper.datatype {
97            ColumnDataType::Boolean => ConcreteDataType::boolean_datatype(),
98            ColumnDataType::Int8 => ConcreteDataType::int8_datatype(),
99            ColumnDataType::Int16 => ConcreteDataType::int16_datatype(),
100            ColumnDataType::Int32 => ConcreteDataType::int32_datatype(),
101            ColumnDataType::Int64 => ConcreteDataType::int64_datatype(),
102            ColumnDataType::Uint8 => ConcreteDataType::uint8_datatype(),
103            ColumnDataType::Uint16 => ConcreteDataType::uint16_datatype(),
104            ColumnDataType::Uint32 => ConcreteDataType::uint32_datatype(),
105            ColumnDataType::Uint64 => ConcreteDataType::uint64_datatype(),
106            ColumnDataType::Float32 => ConcreteDataType::float32_datatype(),
107            ColumnDataType::Float64 => ConcreteDataType::float64_datatype(),
108            ColumnDataType::Binary => {
109                if let Some(TypeExt::JsonType(_)) = datatype_wrapper
110                    .datatype_ext
111                    .as_ref()
112                    .and_then(|datatype_ext| datatype_ext.type_ext.as_ref())
113                {
114                    ConcreteDataType::json_datatype()
115                } else {
116                    ConcreteDataType::binary_datatype()
117                }
118            }
119            ColumnDataType::Json => ConcreteDataType::json_datatype(),
120            ColumnDataType::String => ConcreteDataType::string_datatype(),
121            ColumnDataType::Date => ConcreteDataType::date_datatype(),
122            ColumnDataType::Datetime => ConcreteDataType::timestamp_microsecond_datatype(),
123            ColumnDataType::TimestampSecond => ConcreteDataType::timestamp_second_datatype(),
124            ColumnDataType::TimestampMillisecond => {
125                ConcreteDataType::timestamp_millisecond_datatype()
126            }
127            ColumnDataType::TimestampMicrosecond => {
128                ConcreteDataType::timestamp_microsecond_datatype()
129            }
130            ColumnDataType::TimestampNanosecond => {
131                ConcreteDataType::timestamp_nanosecond_datatype()
132            }
133            ColumnDataType::TimeSecond => ConcreteDataType::time_second_datatype(),
134            ColumnDataType::TimeMillisecond => ConcreteDataType::time_millisecond_datatype(),
135            ColumnDataType::TimeMicrosecond => ConcreteDataType::time_microsecond_datatype(),
136            ColumnDataType::TimeNanosecond => ConcreteDataType::time_nanosecond_datatype(),
137            ColumnDataType::IntervalYearMonth => ConcreteDataType::interval_year_month_datatype(),
138            ColumnDataType::IntervalDayTime => ConcreteDataType::interval_day_time_datatype(),
139            ColumnDataType::IntervalMonthDayNano => {
140                ConcreteDataType::interval_month_day_nano_datatype()
141            }
142            ColumnDataType::Decimal128 => {
143                if let Some(TypeExt::DecimalType(d)) = datatype_wrapper
144                    .datatype_ext
145                    .as_ref()
146                    .and_then(|datatype_ext| datatype_ext.type_ext.as_ref())
147                {
148                    ConcreteDataType::decimal128_datatype(d.precision as u8, d.scale as i8)
149                } else {
150                    ConcreteDataType::decimal128_default_datatype()
151                }
152            }
153            ColumnDataType::Vector => {
154                if let Some(TypeExt::VectorType(d)) = datatype_wrapper
155                    .datatype_ext
156                    .as_ref()
157                    .and_then(|datatype_ext| datatype_ext.type_ext.as_ref())
158                {
159                    ConcreteDataType::vector_datatype(d.dim)
160                } else {
161                    ConcreteDataType::vector_default_datatype()
162                }
163            }
164            ColumnDataType::List => {
165                if let Some(TypeExt::ListType(d)) = datatype_wrapper
166                    .datatype_ext
167                    .as_ref()
168                    .and_then(|datatype_ext| datatype_ext.type_ext.as_ref())
169                {
170                    let item_type = ColumnDataTypeWrapper {
171                        datatype: d.datatype(),
172                        datatype_ext: d.datatype_extension.clone().map(|d| *d),
173                    };
174                    ConcreteDataType::list_datatype(item_type.into())
175                } else {
176                    // invalid state: type extension not found
177                    ConcreteDataType::null_datatype()
178                }
179            }
180            ColumnDataType::Struct => {
181                if let Some(TypeExt::StructType(d)) = datatype_wrapper
182                    .datatype_ext
183                    .as_ref()
184                    .and_then(|datatype_ext| datatype_ext.type_ext.as_ref())
185                {
186                    let fields = d
187                        .fields
188                        .iter()
189                        .map(|f| {
190                            let field_type = ColumnDataTypeWrapper {
191                                datatype: f.datatype(),
192                                datatype_ext: f.datatype_extension.clone(),
193                            };
194                            StructField::new(f.name.clone(), field_type.into(), true)
195                        })
196                        .collect::<Vec<_>>();
197                    ConcreteDataType::struct_datatype(StructType::from(fields))
198                } else {
199                    // invalid state: type extension not found
200                    ConcreteDataType::null_datatype()
201                }
202            }
203        }
204    }
205}
206
207/// This macro is used to generate datatype functions
208/// with lower style for ColumnDataTypeWrapper.
209///
210///
211/// For example: we can use `ColumnDataTypeWrapper::int8_datatype()`,
212/// to get a ColumnDataTypeWrapper with datatype `ColumnDataType::Int8`.
213macro_rules! impl_column_type_functions {
214    ($($Type: ident), +) => {
215        paste! {
216            impl ColumnDataTypeWrapper {
217                $(
218                    pub fn [<$Type:lower _datatype>]() -> ColumnDataTypeWrapper {
219                        ColumnDataTypeWrapper {
220                            datatype: ColumnDataType::$Type,
221                            datatype_ext: None,
222                        }
223                    }
224                )+
225            }
226        }
227    }
228}
229
230/// This macro is used to generate datatype functions
231/// with snake style for ColumnDataTypeWrapper.
232///
233///
234/// For example: we can use `ColumnDataTypeWrapper::duration_second_datatype()`,
235/// to get a ColumnDataTypeWrapper with datatype `ColumnDataType::DurationSecond`.
236macro_rules! impl_column_type_functions_with_snake {
237    ($($TypeName: ident), +) => {
238        paste!{
239            impl ColumnDataTypeWrapper {
240                $(
241                    pub fn [<$TypeName:snake _datatype>]() -> ColumnDataTypeWrapper {
242                        ColumnDataTypeWrapper {
243                            datatype: ColumnDataType::$TypeName,
244                            datatype_ext: None,
245                        }
246                    }
247                )+
248            }
249        }
250    };
251}
252
253impl_column_type_functions!(
254    Boolean, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64, Float32, Float64, Binary,
255    Date, Datetime, String
256);
257
258impl_column_type_functions_with_snake!(
259    TimestampSecond,
260    TimestampMillisecond,
261    TimestampMicrosecond,
262    TimestampNanosecond,
263    TimeSecond,
264    TimeMillisecond,
265    TimeMicrosecond,
266    TimeNanosecond,
267    IntervalYearMonth,
268    IntervalDayTime,
269    IntervalMonthDayNano
270);
271
272impl ColumnDataTypeWrapper {
273    pub fn decimal128_datatype(precision: i32, scale: i32) -> Self {
274        ColumnDataTypeWrapper {
275            datatype: ColumnDataType::Decimal128,
276            datatype_ext: Some(ColumnDataTypeExtension {
277                type_ext: Some(TypeExt::DecimalType(DecimalTypeExtension {
278                    precision,
279                    scale,
280                })),
281            }),
282        }
283    }
284
285    pub fn vector_datatype(dim: u32) -> Self {
286        ColumnDataTypeWrapper {
287            datatype: ColumnDataType::Vector,
288            datatype_ext: Some(ColumnDataTypeExtension {
289                type_ext: Some(TypeExt::VectorType(VectorTypeExtension { dim })),
290            }),
291        }
292    }
293
294    /// Create a list datatype with the given item type.
295    pub fn list_datatype(item_type: ColumnDataTypeWrapper) -> Self {
296        ColumnDataTypeWrapper {
297            datatype: ColumnDataType::List,
298            datatype_ext: Some(ColumnDataTypeExtension {
299                type_ext: Some(TypeExt::ListType(Box::new(ListTypeExtension {
300                    datatype: item_type.datatype() as i32,
301                    datatype_extension: item_type.datatype_ext.map(Box::new),
302                }))),
303            }),
304        }
305    }
306
307    /// Create a struct datatype with the given field tuples (name, datatype).
308    pub fn struct_datatype(fields: Vec<(String, ColumnDataTypeWrapper)>) -> Self {
309        let struct_fields = fields
310            .into_iter()
311            .map(|(name, datatype)| greptime_proto::v1::StructField {
312                name,
313                datatype: datatype.datatype() as i32,
314                datatype_extension: datatype.datatype_ext,
315            })
316            .collect();
317        ColumnDataTypeWrapper {
318            datatype: ColumnDataType::Struct,
319            datatype_ext: Some(ColumnDataTypeExtension {
320                type_ext: Some(TypeExt::StructType(StructTypeExtension {
321                    fields: struct_fields,
322                })),
323            }),
324        }
325    }
326}
327
328impl TryFrom<ConcreteDataType> for ColumnDataTypeWrapper {
329    type Error = error::Error;
330
331    fn try_from(datatype: ConcreteDataType) -> Result<Self> {
332        let column_datatype = match datatype {
333            ConcreteDataType::Boolean(_) => ColumnDataType::Boolean,
334            ConcreteDataType::Int8(_) => ColumnDataType::Int8,
335            ConcreteDataType::Int16(_) => ColumnDataType::Int16,
336            ConcreteDataType::Int32(_) => ColumnDataType::Int32,
337            ConcreteDataType::Int64(_) => ColumnDataType::Int64,
338            ConcreteDataType::UInt8(_) => ColumnDataType::Uint8,
339            ConcreteDataType::UInt16(_) => ColumnDataType::Uint16,
340            ConcreteDataType::UInt32(_) => ColumnDataType::Uint32,
341            ConcreteDataType::UInt64(_) => ColumnDataType::Uint64,
342            ConcreteDataType::Float32(_) => ColumnDataType::Float32,
343            ConcreteDataType::Float64(_) => ColumnDataType::Float64,
344            ConcreteDataType::Binary(_) => ColumnDataType::Binary,
345            ConcreteDataType::String(_) => ColumnDataType::String,
346            ConcreteDataType::Date(_) => ColumnDataType::Date,
347            ConcreteDataType::Timestamp(t) => match t {
348                TimestampType::Second(_) => ColumnDataType::TimestampSecond,
349                TimestampType::Millisecond(_) => ColumnDataType::TimestampMillisecond,
350                TimestampType::Microsecond(_) => ColumnDataType::TimestampMicrosecond,
351                TimestampType::Nanosecond(_) => ColumnDataType::TimestampNanosecond,
352            },
353            ConcreteDataType::Time(t) => match t {
354                TimeType::Second(_) => ColumnDataType::TimeSecond,
355                TimeType::Millisecond(_) => ColumnDataType::TimeMillisecond,
356                TimeType::Microsecond(_) => ColumnDataType::TimeMicrosecond,
357                TimeType::Nanosecond(_) => ColumnDataType::TimeNanosecond,
358            },
359            ConcreteDataType::Interval(i) => match i {
360                IntervalType::YearMonth(_) => ColumnDataType::IntervalYearMonth,
361                IntervalType::DayTime(_) => ColumnDataType::IntervalDayTime,
362                IntervalType::MonthDayNano(_) => ColumnDataType::IntervalMonthDayNano,
363            },
364            ConcreteDataType::Decimal128(_) => ColumnDataType::Decimal128,
365            ConcreteDataType::Json(_) => ColumnDataType::Json,
366            ConcreteDataType::Vector(_) => ColumnDataType::Vector,
367            ConcreteDataType::List(_) => ColumnDataType::List,
368            ConcreteDataType::Struct(_) => ColumnDataType::Struct,
369            ConcreteDataType::Null(_)
370            | ConcreteDataType::Dictionary(_)
371            | ConcreteDataType::Duration(_) => {
372                return error::IntoColumnDataTypeSnafu { from: datatype }.fail();
373            }
374        };
375        let datatype_extension = match column_datatype {
376            ColumnDataType::Decimal128 => {
377                datatype
378                    .as_decimal128()
379                    .map(|decimal_type| ColumnDataTypeExtension {
380                        type_ext: Some(TypeExt::DecimalType(DecimalTypeExtension {
381                            precision: decimal_type.precision() as i32,
382                            scale: decimal_type.scale() as i32,
383                        })),
384                    })
385            }
386            ColumnDataType::Json => datatype.as_json().map(|_| ColumnDataTypeExtension {
387                type_ext: Some(TypeExt::JsonType(JsonTypeExtension::JsonBinary.into())),
388            }),
389            ColumnDataType::Vector => {
390                datatype
391                    .as_vector()
392                    .map(|vector_type| ColumnDataTypeExtension {
393                        type_ext: Some(TypeExt::VectorType(VectorTypeExtension {
394                            dim: vector_type.dim as _,
395                        })),
396                    })
397            }
398            ColumnDataType::List => {
399                if let Some(list_type) = datatype.as_list() {
400                    let list_item_type =
401                        ColumnDataTypeWrapper::try_from(list_type.item_type().clone())?;
402                    Some(ColumnDataTypeExtension {
403                        type_ext: Some(TypeExt::ListType(Box::new(ListTypeExtension {
404                            datatype: list_item_type.datatype.into(),
405                            datatype_extension: list_item_type.datatype_ext.map(Box::new),
406                        }))),
407                    })
408                } else {
409                    None
410                }
411            }
412            ColumnDataType::Struct => {
413                if let Some(struct_type) = datatype.as_struct() {
414                    let mut fields = Vec::with_capacity(struct_type.fields().len());
415                    for field in struct_type.fields() {
416                        let field_type =
417                            ColumnDataTypeWrapper::try_from(field.data_type().clone())?;
418                        let proto_field = crate::v1::StructField {
419                            name: field.name().to_string(),
420                            datatype: field_type.datatype.into(),
421                            datatype_extension: field_type.datatype_ext,
422                        };
423                        fields.push(proto_field);
424                    }
425                    Some(ColumnDataTypeExtension {
426                        type_ext: Some(TypeExt::StructType(StructTypeExtension { fields })),
427                    })
428                } else {
429                    None
430                }
431            }
432            _ => None,
433        };
434        Ok(Self {
435            datatype: column_datatype,
436            datatype_ext: datatype_extension,
437        })
438    }
439}
440
441pub fn values_with_capacity(datatype: ColumnDataType, capacity: usize) -> Values {
442    match datatype {
443        ColumnDataType::Boolean => Values {
444            bool_values: Vec::with_capacity(capacity),
445            ..Default::default()
446        },
447        ColumnDataType::Int8 => Values {
448            i8_values: Vec::with_capacity(capacity),
449            ..Default::default()
450        },
451        ColumnDataType::Int16 => Values {
452            i16_values: Vec::with_capacity(capacity),
453            ..Default::default()
454        },
455        ColumnDataType::Int32 => Values {
456            i32_values: Vec::with_capacity(capacity),
457            ..Default::default()
458        },
459        ColumnDataType::Int64 => Values {
460            i64_values: Vec::with_capacity(capacity),
461            ..Default::default()
462        },
463        ColumnDataType::Uint8 => Values {
464            u8_values: Vec::with_capacity(capacity),
465            ..Default::default()
466        },
467        ColumnDataType::Uint16 => Values {
468            u16_values: Vec::with_capacity(capacity),
469            ..Default::default()
470        },
471        ColumnDataType::Uint32 => Values {
472            u32_values: Vec::with_capacity(capacity),
473            ..Default::default()
474        },
475        ColumnDataType::Uint64 => Values {
476            u64_values: Vec::with_capacity(capacity),
477            ..Default::default()
478        },
479        ColumnDataType::Float32 => Values {
480            f32_values: Vec::with_capacity(capacity),
481            ..Default::default()
482        },
483        ColumnDataType::Float64 => Values {
484            f64_values: Vec::with_capacity(capacity),
485            ..Default::default()
486        },
487        ColumnDataType::Binary => Values {
488            binary_values: Vec::with_capacity(capacity),
489            ..Default::default()
490        },
491        ColumnDataType::String => Values {
492            string_values: Vec::with_capacity(capacity),
493            ..Default::default()
494        },
495        ColumnDataType::Date => Values {
496            date_values: Vec::with_capacity(capacity),
497            ..Default::default()
498        },
499        ColumnDataType::Datetime => Values {
500            datetime_values: Vec::with_capacity(capacity),
501            ..Default::default()
502        },
503        ColumnDataType::TimestampSecond => Values {
504            timestamp_second_values: Vec::with_capacity(capacity),
505            ..Default::default()
506        },
507        ColumnDataType::TimestampMillisecond => Values {
508            timestamp_millisecond_values: Vec::with_capacity(capacity),
509            ..Default::default()
510        },
511        ColumnDataType::TimestampMicrosecond => Values {
512            timestamp_microsecond_values: Vec::with_capacity(capacity),
513            ..Default::default()
514        },
515        ColumnDataType::TimestampNanosecond => Values {
516            timestamp_nanosecond_values: Vec::with_capacity(capacity),
517            ..Default::default()
518        },
519        ColumnDataType::TimeSecond => Values {
520            time_second_values: Vec::with_capacity(capacity),
521            ..Default::default()
522        },
523        ColumnDataType::TimeMillisecond => Values {
524            time_millisecond_values: Vec::with_capacity(capacity),
525            ..Default::default()
526        },
527        ColumnDataType::TimeMicrosecond => Values {
528            time_microsecond_values: Vec::with_capacity(capacity),
529            ..Default::default()
530        },
531        ColumnDataType::TimeNanosecond => Values {
532            time_nanosecond_values: Vec::with_capacity(capacity),
533            ..Default::default()
534        },
535        ColumnDataType::IntervalDayTime => Values {
536            interval_day_time_values: Vec::with_capacity(capacity),
537            ..Default::default()
538        },
539        ColumnDataType::IntervalYearMonth => Values {
540            interval_year_month_values: Vec::with_capacity(capacity),
541            ..Default::default()
542        },
543        ColumnDataType::IntervalMonthDayNano => Values {
544            interval_month_day_nano_values: Vec::with_capacity(capacity),
545            ..Default::default()
546        },
547        ColumnDataType::Decimal128 => Values {
548            decimal128_values: Vec::with_capacity(capacity),
549            ..Default::default()
550        },
551        ColumnDataType::Json => Values {
552            string_values: Vec::with_capacity(capacity),
553            ..Default::default()
554        },
555        ColumnDataType::Vector => Values {
556            binary_values: Vec::with_capacity(capacity),
557            ..Default::default()
558        },
559        ColumnDataType::List => Values {
560            list_values: Vec::with_capacity(capacity),
561            ..Default::default()
562        },
563        ColumnDataType::Struct => Values {
564            struct_values: Vec::with_capacity(capacity),
565            ..Default::default()
566        },
567    }
568}
569
570/// Returns the type name of the [Request].
571pub fn request_type(request: &Request) -> &'static str {
572    match request {
573        Request::Inserts(_) => "inserts",
574        Request::Query(query_req) => query_request_type(query_req),
575        Request::Ddl(ddl_req) => ddl_request_type(ddl_req),
576        Request::Deletes(_) => "deletes",
577        Request::RowInserts(_) => "row_inserts",
578        Request::RowDeletes(_) => "row_deletes",
579    }
580}
581
582/// Returns the type name of the [QueryRequest].
583fn query_request_type(request: &QueryRequest) -> &'static str {
584    match request.query {
585        Some(Query::Sql(_)) => "query.sql",
586        Some(Query::LogicalPlan(_)) => "query.logical_plan",
587        Some(Query::PromRangeQuery(_)) => "query.prom_range",
588        Some(Query::InsertIntoPlan(_)) => "query.insert_into_plan",
589        None => "query.empty",
590    }
591}
592
593/// Returns the type name of the [DdlRequest].
594fn ddl_request_type(request: &DdlRequest) -> &'static str {
595    match request.expr {
596        Some(Expr::CreateDatabase(_)) => "ddl.create_database",
597        Some(Expr::CreateTable(_)) => "ddl.create_table",
598        Some(Expr::AlterTable(_)) => "ddl.alter_table",
599        Some(Expr::DropTable(_)) => "ddl.drop_table",
600        Some(Expr::TruncateTable(_)) => "ddl.truncate_table",
601        Some(Expr::CreateFlow(_)) => "ddl.create_flow",
602        Some(Expr::DropFlow(_)) => "ddl.drop_flow",
603        Some(Expr::CreateView(_)) => "ddl.create_view",
604        Some(Expr::DropView(_)) => "ddl.drop_view",
605        Some(Expr::AlterDatabase(_)) => "ddl.alter_database",
606        None => "ddl.empty",
607    }
608}
609
610/// Converts an interval to google protobuf type [IntervalMonthDayNano].
611pub fn convert_month_day_nano_to_pb(v: IntervalMonthDayNano) -> v1::IntervalMonthDayNano {
612    v1::IntervalMonthDayNano {
613        months: v.months,
614        days: v.days,
615        nanoseconds: v.nanoseconds,
616    }
617}
618
619/// Convert common decimal128 to grpc decimal128 without precision and scale.
620pub fn convert_to_pb_decimal128(v: Decimal128) -> v1::Decimal128 {
621    let (hi, lo) = v.split_value();
622    v1::Decimal128 { hi, lo }
623}
624
625pub fn pb_value_to_value_ref<'a>(
626    value: &'a v1::Value,
627    datatype_ext: Option<&'a ColumnDataTypeExtension>,
628) -> ValueRef<'a> {
629    let Some(value) = &value.value_data else {
630        return ValueRef::Null;
631    };
632
633    match value {
634        ValueData::I8Value(v) => ValueRef::Int8(*v as i8),
635        ValueData::I16Value(v) => ValueRef::Int16(*v as i16),
636        ValueData::I32Value(v) => ValueRef::Int32(*v),
637        ValueData::I64Value(v) => ValueRef::Int64(*v),
638        ValueData::U8Value(v) => ValueRef::UInt8(*v as u8),
639        ValueData::U16Value(v) => ValueRef::UInt16(*v as u16),
640        ValueData::U32Value(v) => ValueRef::UInt32(*v),
641        ValueData::U64Value(v) => ValueRef::UInt64(*v),
642        ValueData::F32Value(f) => ValueRef::Float32(OrderedF32::from(*f)),
643        ValueData::F64Value(f) => ValueRef::Float64(OrderedF64::from(*f)),
644        ValueData::BoolValue(b) => ValueRef::Boolean(*b),
645        ValueData::BinaryValue(bytes) => ValueRef::Binary(bytes.as_slice()),
646        ValueData::StringValue(string) => ValueRef::String(string.as_str()),
647        ValueData::DateValue(d) => ValueRef::Date(Date::from(*d)),
648        ValueData::TimestampSecondValue(t) => ValueRef::Timestamp(Timestamp::new_second(*t)),
649        ValueData::TimestampMillisecondValue(t) => {
650            ValueRef::Timestamp(Timestamp::new_millisecond(*t))
651        }
652        ValueData::DatetimeValue(t) | ValueData::TimestampMicrosecondValue(t) => {
653            ValueRef::Timestamp(Timestamp::new_microsecond(*t))
654        }
655        ValueData::TimestampNanosecondValue(t) => {
656            ValueRef::Timestamp(Timestamp::new_nanosecond(*t))
657        }
658        ValueData::TimeSecondValue(t) => ValueRef::Time(Time::new_second(*t)),
659        ValueData::TimeMillisecondValue(t) => ValueRef::Time(Time::new_millisecond(*t)),
660        ValueData::TimeMicrosecondValue(t) => ValueRef::Time(Time::new_microsecond(*t)),
661        ValueData::TimeNanosecondValue(t) => ValueRef::Time(Time::new_nanosecond(*t)),
662        ValueData::IntervalYearMonthValue(v) => {
663            ValueRef::IntervalYearMonth(IntervalYearMonth::from_i32(*v))
664        }
665        ValueData::IntervalDayTimeValue(v) => {
666            ValueRef::IntervalDayTime(IntervalDayTime::from_i64(*v))
667        }
668        ValueData::IntervalMonthDayNanoValue(v) => {
669            let interval = IntervalMonthDayNano::new(v.months, v.days, v.nanoseconds);
670            ValueRef::IntervalMonthDayNano(interval)
671        }
672        ValueData::Decimal128Value(v) => {
673            // get precision and scale from datatype_extension
674            if let Some(TypeExt::DecimalType(d)) = datatype_ext
675                .as_ref()
676                .and_then(|column_ext| column_ext.type_ext.as_ref())
677            {
678                ValueRef::Decimal128(Decimal128::from_value_precision_scale(
679                    v.hi,
680                    v.lo,
681                    d.precision as u8,
682                    d.scale as i8,
683                ))
684            } else {
685                // If the precision and scale are not set, use the default value.
686                ValueRef::Decimal128(Decimal128::from_value_precision_scale(
687                    v.hi,
688                    v.lo,
689                    DECIMAL128_MAX_PRECISION,
690                    DECIMAL128_DEFAULT_SCALE,
691                ))
692            }
693        }
694        ValueData::ListValue(list) => {
695            let list_datatype_ext = datatype_ext
696                .as_ref()
697                .and_then(|ext| {
698                    if let Some(TypeExt::ListType(l)) = &ext.type_ext {
699                        Some(l)
700                    } else {
701                        None
702                    }
703                })
704                .expect("list must contain datatype ext");
705            let item_type = ConcreteDataType::from(ColumnDataTypeWrapper::new(
706                list_datatype_ext.datatype(),
707                list_datatype_ext
708                    .datatype_extension
709                    .as_ref()
710                    .map(|ext| *ext.clone()),
711            ));
712            let items = list
713                .items
714                .iter()
715                .map(|item| {
716                    pb_value_to_value_ref(item, list_datatype_ext.datatype_extension.as_deref())
717                })
718                .collect::<Vec<_>>();
719
720            let list_value = ListValueRef::RefList {
721                val: items,
722                item_datatype: item_type.clone(),
723            };
724            ValueRef::List(list_value)
725        }
726
727        ValueData::StructValue(struct_value) => {
728            let struct_datatype_ext = datatype_ext
729                .as_ref()
730                .and_then(|ext| {
731                    if let Some(TypeExt::StructType(s)) = &ext.type_ext {
732                        Some(s)
733                    } else {
734                        None
735                    }
736                })
737                .expect("struct must contain datatype ext");
738
739            let struct_fields = struct_datatype_ext
740                .fields
741                .iter()
742                .map(|field| {
743                    let field_type = ConcreteDataType::from(ColumnDataTypeWrapper::new(
744                        field.datatype(),
745                        field.datatype_extension.clone(),
746                    ));
747                    let field_name = field.name.clone();
748                    StructField::new(field_name, field_type, true)
749                })
750                .collect::<Vec<_>>();
751
752            let items = struct_value
753                .items
754                .iter()
755                .zip(struct_datatype_ext.fields.iter())
756                .map(|(item, field)| pb_value_to_value_ref(item, field.datatype_extension.as_ref()))
757                .collect::<Vec<ValueRef>>();
758
759            let struct_value_ref = StructValueRef::RefList {
760                val: items,
761                fields: StructType::new(struct_fields),
762            };
763            ValueRef::Struct(struct_value_ref)
764        }
765    }
766}
767
768pub fn pb_values_to_vector_ref(data_type: &ConcreteDataType, values: Values) -> VectorRef {
769    match data_type {
770        ConcreteDataType::Boolean(_) => Arc::new(BooleanVector::from(values.bool_values)),
771        ConcreteDataType::Int8(_) => Arc::new(PrimitiveVector::<Int8Type>::from_iter_values(
772            values.i8_values.into_iter().map(|x| x as i8),
773        )),
774        ConcreteDataType::Int16(_) => Arc::new(PrimitiveVector::<Int16Type>::from_iter_values(
775            values.i16_values.into_iter().map(|x| x as i16),
776        )),
777        ConcreteDataType::Int32(_) => Arc::new(Int32Vector::from_vec(values.i32_values)),
778        ConcreteDataType::Int64(_) => Arc::new(Int64Vector::from_vec(values.i64_values)),
779        ConcreteDataType::UInt8(_) => Arc::new(PrimitiveVector::<UInt8Type>::from_iter_values(
780            values.u8_values.into_iter().map(|x| x as u8),
781        )),
782        ConcreteDataType::UInt16(_) => Arc::new(PrimitiveVector::<UInt16Type>::from_iter_values(
783            values.u16_values.into_iter().map(|x| x as u16),
784        )),
785        ConcreteDataType::UInt32(_) => Arc::new(UInt32Vector::from_vec(values.u32_values)),
786        ConcreteDataType::UInt64(_) => Arc::new(UInt64Vector::from_vec(values.u64_values)),
787        ConcreteDataType::Float32(_) => Arc::new(Float32Vector::from_vec(values.f32_values)),
788        ConcreteDataType::Float64(_) => Arc::new(Float64Vector::from_vec(values.f64_values)),
789        ConcreteDataType::Binary(_) => Arc::new(BinaryVector::from(values.binary_values)),
790        ConcreteDataType::String(_) => Arc::new(StringVector::from_vec(values.string_values)),
791        ConcreteDataType::Date(_) => Arc::new(DateVector::from_vec(values.date_values)),
792        ConcreteDataType::Timestamp(unit) => match unit {
793            TimestampType::Second(_) => Arc::new(TimestampSecondVector::from_vec(
794                values.timestamp_second_values,
795            )),
796            TimestampType::Millisecond(_) => Arc::new(TimestampMillisecondVector::from_vec(
797                values.timestamp_millisecond_values,
798            )),
799            TimestampType::Microsecond(_) => Arc::new(TimestampMicrosecondVector::from_vec(
800                values.timestamp_microsecond_values,
801            )),
802            TimestampType::Nanosecond(_) => Arc::new(TimestampNanosecondVector::from_vec(
803                values.timestamp_nanosecond_values,
804            )),
805        },
806        ConcreteDataType::Time(unit) => match unit {
807            TimeType::Second(_) => Arc::new(TimeSecondVector::from_iter_values(
808                values.time_second_values.iter().map(|x| *x as i32),
809            )),
810            TimeType::Millisecond(_) => Arc::new(TimeMillisecondVector::from_iter_values(
811                values.time_millisecond_values.iter().map(|x| *x as i32),
812            )),
813            TimeType::Microsecond(_) => Arc::new(TimeMicrosecondVector::from_vec(
814                values.time_microsecond_values,
815            )),
816            TimeType::Nanosecond(_) => Arc::new(TimeNanosecondVector::from_vec(
817                values.time_nanosecond_values,
818            )),
819        },
820
821        ConcreteDataType::Interval(unit) => match unit {
822            IntervalType::YearMonth(_) => Arc::new(IntervalYearMonthVector::from_vec(
823                values.interval_year_month_values,
824            )),
825            IntervalType::DayTime(_) => Arc::new(IntervalDayTimeVector::from_iter_values(
826                values
827                    .interval_day_time_values
828                    .iter()
829                    .map(|x| IntervalDayTime::from_i64(*x).into()),
830            )),
831            IntervalType::MonthDayNano(_) => {
832                Arc::new(IntervalMonthDayNanoVector::from_iter_values(
833                    values
834                        .interval_month_day_nano_values
835                        .iter()
836                        .map(|x| IntervalMonthDayNano::new(x.months, x.days, x.nanoseconds).into()),
837                ))
838            }
839        },
840        ConcreteDataType::Decimal128(d) => Arc::new(Decimal128Vector::from_values(
841            values.decimal128_values.iter().map(|x| {
842                Decimal128::from_value_precision_scale(x.hi, x.lo, d.precision(), d.scale()).into()
843            }),
844        )),
845        ConcreteDataType::Vector(_) => Arc::new(BinaryVector::from_vec(values.binary_values)),
846        ConcreteDataType::Null(_)
847        | ConcreteDataType::List(_)
848        | ConcreteDataType::Struct(_)
849        | ConcreteDataType::Dictionary(_)
850        | ConcreteDataType::Duration(_)
851        | ConcreteDataType::Json(_) => {
852            unreachable!()
853        }
854    }
855}
856
857pub fn pb_values_to_values(data_type: &ConcreteDataType, values: Values) -> Vec<Value> {
858    match data_type {
859        ConcreteDataType::Int64(_) => values
860            .i64_values
861            .into_iter()
862            .map(|val| val.into())
863            .collect(),
864        ConcreteDataType::Float64(_) => values
865            .f64_values
866            .into_iter()
867            .map(|val| val.into())
868            .collect(),
869        ConcreteDataType::String(_) => values
870            .string_values
871            .into_iter()
872            .map(|val| val.into())
873            .collect(),
874        ConcreteDataType::Boolean(_) => values
875            .bool_values
876            .into_iter()
877            .map(|val| val.into())
878            .collect(),
879        ConcreteDataType::Int8(_) => values
880            .i8_values
881            .into_iter()
882            // Safety: Since i32 only stores i8 data here, so i32 as i8 is safe.
883            .map(|val| (val as i8).into())
884            .collect(),
885        ConcreteDataType::Int16(_) => values
886            .i16_values
887            .into_iter()
888            // Safety: Since i32 only stores i16 data here, so i32 as i16 is safe.
889            .map(|val| (val as i16).into())
890            .collect(),
891        ConcreteDataType::Int32(_) => values
892            .i32_values
893            .into_iter()
894            .map(|val| val.into())
895            .collect(),
896        ConcreteDataType::UInt8(_) => values
897            .u8_values
898            .into_iter()
899            // Safety: Since i32 only stores u8 data here, so i32 as u8 is safe.
900            .map(|val| (val as u8).into())
901            .collect(),
902        ConcreteDataType::UInt16(_) => values
903            .u16_values
904            .into_iter()
905            // Safety: Since i32 only stores u16 data here, so i32 as u16 is safe.
906            .map(|val| (val as u16).into())
907            .collect(),
908        ConcreteDataType::UInt32(_) => values
909            .u32_values
910            .into_iter()
911            .map(|val| val.into())
912            .collect(),
913        ConcreteDataType::UInt64(_) => values
914            .u64_values
915            .into_iter()
916            .map(|val| val.into())
917            .collect(),
918        ConcreteDataType::Float32(_) => values
919            .f32_values
920            .into_iter()
921            .map(|val| val.into())
922            .collect(),
923        ConcreteDataType::Binary(_) => values
924            .binary_values
925            .into_iter()
926            .map(|val| val.into())
927            .collect(),
928        ConcreteDataType::Date(_) => values
929            .date_values
930            .into_iter()
931            .map(|v| Value::Date(v.into()))
932            .collect(),
933        ConcreteDataType::Timestamp(TimestampType::Second(_)) => values
934            .timestamp_second_values
935            .into_iter()
936            .map(|v| Value::Timestamp(Timestamp::new_second(v)))
937            .collect(),
938        ConcreteDataType::Timestamp(TimestampType::Millisecond(_)) => values
939            .timestamp_millisecond_values
940            .into_iter()
941            .map(|v| Value::Timestamp(Timestamp::new_millisecond(v)))
942            .collect(),
943        ConcreteDataType::Timestamp(TimestampType::Microsecond(_)) => values
944            .timestamp_microsecond_values
945            .into_iter()
946            .map(|v| Value::Timestamp(Timestamp::new_microsecond(v)))
947            .collect(),
948        ConcreteDataType::Timestamp(TimestampType::Nanosecond(_)) => values
949            .timestamp_nanosecond_values
950            .into_iter()
951            .map(|v| Value::Timestamp(Timestamp::new_nanosecond(v)))
952            .collect(),
953        ConcreteDataType::Time(TimeType::Second(_)) => values
954            .time_second_values
955            .into_iter()
956            .map(|v| Value::Time(Time::new_second(v)))
957            .collect(),
958        ConcreteDataType::Time(TimeType::Millisecond(_)) => values
959            .time_millisecond_values
960            .into_iter()
961            .map(|v| Value::Time(Time::new_millisecond(v)))
962            .collect(),
963        ConcreteDataType::Time(TimeType::Microsecond(_)) => values
964            .time_microsecond_values
965            .into_iter()
966            .map(|v| Value::Time(Time::new_microsecond(v)))
967            .collect(),
968        ConcreteDataType::Time(TimeType::Nanosecond(_)) => values
969            .time_nanosecond_values
970            .into_iter()
971            .map(|v| Value::Time(Time::new_nanosecond(v)))
972            .collect(),
973
974        ConcreteDataType::Interval(IntervalType::YearMonth(_)) => values
975            .interval_year_month_values
976            .into_iter()
977            .map(|v| Value::IntervalYearMonth(IntervalYearMonth::from_i32(v)))
978            .collect(),
979        ConcreteDataType::Interval(IntervalType::DayTime(_)) => values
980            .interval_day_time_values
981            .into_iter()
982            .map(|v| Value::IntervalDayTime(IntervalDayTime::from_i64(v)))
983            .collect(),
984        ConcreteDataType::Interval(IntervalType::MonthDayNano(_)) => values
985            .interval_month_day_nano_values
986            .into_iter()
987            .map(|v| {
988                Value::IntervalMonthDayNano(IntervalMonthDayNano::new(
989                    v.months,
990                    v.days,
991                    v.nanoseconds,
992                ))
993            })
994            .collect(),
995        ConcreteDataType::Decimal128(d) => values
996            .decimal128_values
997            .into_iter()
998            .map(|v| {
999                Value::Decimal128(Decimal128::from_value_precision_scale(
1000                    v.hi,
1001                    v.lo,
1002                    d.precision(),
1003                    d.scale(),
1004                ))
1005            })
1006            .collect(),
1007        ConcreteDataType::Vector(_) => values.binary_values.into_iter().map(|v| v.into()).collect(),
1008        ConcreteDataType::Null(_)
1009        | ConcreteDataType::List(_)
1010        | ConcreteDataType::Struct(_)
1011        | ConcreteDataType::Dictionary(_)
1012        | ConcreteDataType::Duration(_)
1013        | ConcreteDataType::Json(_) => {
1014            unreachable!()
1015        }
1016    }
1017}
1018
1019/// Returns true if the pb semantic type is valid.
1020pub fn is_semantic_type_eq(type_value: i32, semantic_type: SemanticType) -> bool {
1021    type_value == semantic_type as i32
1022}
1023
1024/// Returns true if the pb type value is valid.
1025pub fn is_column_type_value_eq(
1026    type_value: i32,
1027    type_extension: Option<ColumnDataTypeExtension>,
1028    expect_type: &ConcreteDataType,
1029) -> bool {
1030    ColumnDataTypeWrapper::try_new(type_value, type_extension)
1031        .map(|wrapper| {
1032            let datatype = ConcreteDataType::from(wrapper);
1033            expect_type == &datatype
1034        })
1035        .unwrap_or(false)
1036}
1037
1038/// Convert value into proto's value.
1039pub fn to_proto_value(value: Value) -> v1::Value {
1040    match value {
1041        Value::Null => v1::Value { value_data: None },
1042        Value::Boolean(v) => v1::Value {
1043            value_data: Some(ValueData::BoolValue(v)),
1044        },
1045        Value::UInt8(v) => v1::Value {
1046            value_data: Some(ValueData::U8Value(v.into())),
1047        },
1048        Value::UInt16(v) => v1::Value {
1049            value_data: Some(ValueData::U16Value(v.into())),
1050        },
1051        Value::UInt32(v) => v1::Value {
1052            value_data: Some(ValueData::U32Value(v)),
1053        },
1054        Value::UInt64(v) => v1::Value {
1055            value_data: Some(ValueData::U64Value(v)),
1056        },
1057        Value::Int8(v) => v1::Value {
1058            value_data: Some(ValueData::I8Value(v.into())),
1059        },
1060        Value::Int16(v) => v1::Value {
1061            value_data: Some(ValueData::I16Value(v.into())),
1062        },
1063        Value::Int32(v) => v1::Value {
1064            value_data: Some(ValueData::I32Value(v)),
1065        },
1066        Value::Int64(v) => v1::Value {
1067            value_data: Some(ValueData::I64Value(v)),
1068        },
1069        Value::Float32(v) => v1::Value {
1070            value_data: Some(ValueData::F32Value(*v)),
1071        },
1072        Value::Float64(v) => v1::Value {
1073            value_data: Some(ValueData::F64Value(*v)),
1074        },
1075        Value::String(v) => v1::Value {
1076            value_data: Some(ValueData::StringValue(v.as_utf8().to_string())),
1077        },
1078        Value::Binary(v) => v1::Value {
1079            value_data: Some(ValueData::BinaryValue(v.to_vec())),
1080        },
1081        Value::Date(v) => v1::Value {
1082            value_data: Some(ValueData::DateValue(v.val())),
1083        },
1084        Value::Timestamp(v) => match v.unit() {
1085            TimeUnit::Second => v1::Value {
1086                value_data: Some(ValueData::TimestampSecondValue(v.value())),
1087            },
1088            TimeUnit::Millisecond => v1::Value {
1089                value_data: Some(ValueData::TimestampMillisecondValue(v.value())),
1090            },
1091            TimeUnit::Microsecond => v1::Value {
1092                value_data: Some(ValueData::TimestampMicrosecondValue(v.value())),
1093            },
1094            TimeUnit::Nanosecond => v1::Value {
1095                value_data: Some(ValueData::TimestampNanosecondValue(v.value())),
1096            },
1097        },
1098        Value::Time(v) => match v.unit() {
1099            TimeUnit::Second => v1::Value {
1100                value_data: Some(ValueData::TimeSecondValue(v.value())),
1101            },
1102            TimeUnit::Millisecond => v1::Value {
1103                value_data: Some(ValueData::TimeMillisecondValue(v.value())),
1104            },
1105            TimeUnit::Microsecond => v1::Value {
1106                value_data: Some(ValueData::TimeMicrosecondValue(v.value())),
1107            },
1108            TimeUnit::Nanosecond => v1::Value {
1109                value_data: Some(ValueData::TimeNanosecondValue(v.value())),
1110            },
1111        },
1112        Value::IntervalYearMonth(v) => v1::Value {
1113            value_data: Some(ValueData::IntervalYearMonthValue(v.to_i32())),
1114        },
1115        Value::IntervalDayTime(v) => v1::Value {
1116            value_data: Some(ValueData::IntervalDayTimeValue(v.to_i64())),
1117        },
1118        Value::IntervalMonthDayNano(v) => v1::Value {
1119            value_data: Some(ValueData::IntervalMonthDayNanoValue(
1120                convert_month_day_nano_to_pb(v),
1121            )),
1122        },
1123        Value::Decimal128(v) => v1::Value {
1124            value_data: Some(ValueData::Decimal128Value(convert_to_pb_decimal128(v))),
1125        },
1126        Value::List(list_value) => v1::Value {
1127            value_data: Some(ValueData::ListValue(v1::ListValue {
1128                items: convert_list_to_pb_values(list_value),
1129            })),
1130        },
1131        Value::Struct(struct_value) => v1::Value {
1132            value_data: Some(ValueData::StructValue(v1::StructValue {
1133                items: convert_struct_to_pb_values(struct_value),
1134            })),
1135        },
1136        Value::Duration(_) => v1::Value { value_data: None },
1137    }
1138}
1139
1140fn convert_list_to_pb_values(list_value: ListValue) -> Vec<v1::Value> {
1141    list_value
1142        .take_items()
1143        .into_iter()
1144        .map(to_proto_value)
1145        .collect()
1146}
1147
1148fn convert_struct_to_pb_values(struct_value: StructValue) -> Vec<v1::Value> {
1149    struct_value
1150        .take_items()
1151        .into_iter()
1152        .map(to_proto_value)
1153        .collect()
1154}
1155
1156/// Returns the [ColumnDataTypeWrapper] of the value.
1157///
1158/// If value is null, returns `None`.
1159pub fn proto_value_type(value: &v1::Value) -> Option<ColumnDataType> {
1160    let value_type = match value.value_data.as_ref()? {
1161        ValueData::I8Value(_) => ColumnDataType::Int8,
1162        ValueData::I16Value(_) => ColumnDataType::Int16,
1163        ValueData::I32Value(_) => ColumnDataType::Int32,
1164        ValueData::I64Value(_) => ColumnDataType::Int64,
1165        ValueData::U8Value(_) => ColumnDataType::Uint8,
1166        ValueData::U16Value(_) => ColumnDataType::Uint16,
1167        ValueData::U32Value(_) => ColumnDataType::Uint32,
1168        ValueData::U64Value(_) => ColumnDataType::Uint64,
1169        ValueData::F32Value(_) => ColumnDataType::Float32,
1170        ValueData::F64Value(_) => ColumnDataType::Float64,
1171        ValueData::BoolValue(_) => ColumnDataType::Boolean,
1172        ValueData::BinaryValue(_) => ColumnDataType::Binary,
1173        ValueData::StringValue(_) => ColumnDataType::String,
1174        ValueData::DateValue(_) => ColumnDataType::Date,
1175        ValueData::DatetimeValue(_) => ColumnDataType::Datetime,
1176        ValueData::TimestampSecondValue(_) => ColumnDataType::TimestampSecond,
1177        ValueData::TimestampMillisecondValue(_) => ColumnDataType::TimestampMillisecond,
1178        ValueData::TimestampMicrosecondValue(_) => ColumnDataType::TimestampMicrosecond,
1179        ValueData::TimestampNanosecondValue(_) => ColumnDataType::TimestampNanosecond,
1180        ValueData::TimeSecondValue(_) => ColumnDataType::TimeSecond,
1181        ValueData::TimeMillisecondValue(_) => ColumnDataType::TimeMillisecond,
1182        ValueData::TimeMicrosecondValue(_) => ColumnDataType::TimeMicrosecond,
1183        ValueData::TimeNanosecondValue(_) => ColumnDataType::TimeNanosecond,
1184        ValueData::IntervalYearMonthValue(_) => ColumnDataType::IntervalYearMonth,
1185        ValueData::IntervalDayTimeValue(_) => ColumnDataType::IntervalDayTime,
1186        ValueData::IntervalMonthDayNanoValue(_) => ColumnDataType::IntervalMonthDayNano,
1187        ValueData::Decimal128Value(_) => ColumnDataType::Decimal128,
1188        ValueData::ListValue(_) => ColumnDataType::List,
1189        ValueData::StructValue(_) => ColumnDataType::Struct,
1190    };
1191    Some(value_type)
1192}
1193
1194pub fn vectors_to_rows<'a>(
1195    columns: impl Iterator<Item = &'a VectorRef>,
1196    row_count: usize,
1197) -> Vec<Row> {
1198    let mut rows = vec![Row { values: vec![] }; row_count];
1199    for column in columns {
1200        for (row_index, row) in rows.iter_mut().enumerate() {
1201            row.values.push(value_to_grpc_value(column.get(row_index)))
1202        }
1203    }
1204
1205    rows
1206}
1207
1208pub fn value_to_grpc_value(value: Value) -> GrpcValue {
1209    GrpcValue {
1210        value_data: match value {
1211            Value::Null => None,
1212            Value::Boolean(v) => Some(ValueData::BoolValue(v)),
1213            Value::UInt8(v) => Some(ValueData::U8Value(v as _)),
1214            Value::UInt16(v) => Some(ValueData::U16Value(v as _)),
1215            Value::UInt32(v) => Some(ValueData::U32Value(v)),
1216            Value::UInt64(v) => Some(ValueData::U64Value(v)),
1217            Value::Int8(v) => Some(ValueData::I8Value(v as _)),
1218            Value::Int16(v) => Some(ValueData::I16Value(v as _)),
1219            Value::Int32(v) => Some(ValueData::I32Value(v)),
1220            Value::Int64(v) => Some(ValueData::I64Value(v)),
1221            Value::Float32(v) => Some(ValueData::F32Value(*v)),
1222            Value::Float64(v) => Some(ValueData::F64Value(*v)),
1223            Value::String(v) => Some(ValueData::StringValue(v.into_string())),
1224            Value::Binary(v) => Some(ValueData::BinaryValue(v.to_vec())),
1225            Value::Date(v) => Some(ValueData::DateValue(v.val())),
1226            Value::Timestamp(v) => Some(match v.unit() {
1227                TimeUnit::Second => ValueData::TimestampSecondValue(v.value()),
1228                TimeUnit::Millisecond => ValueData::TimestampMillisecondValue(v.value()),
1229                TimeUnit::Microsecond => ValueData::TimestampMicrosecondValue(v.value()),
1230                TimeUnit::Nanosecond => ValueData::TimestampNanosecondValue(v.value()),
1231            }),
1232            Value::Time(v) => Some(match v.unit() {
1233                TimeUnit::Second => ValueData::TimeSecondValue(v.value()),
1234                TimeUnit::Millisecond => ValueData::TimeMillisecondValue(v.value()),
1235                TimeUnit::Microsecond => ValueData::TimeMicrosecondValue(v.value()),
1236                TimeUnit::Nanosecond => ValueData::TimeNanosecondValue(v.value()),
1237            }),
1238            Value::IntervalYearMonth(v) => Some(ValueData::IntervalYearMonthValue(v.to_i32())),
1239            Value::IntervalDayTime(v) => Some(ValueData::IntervalDayTimeValue(v.to_i64())),
1240            Value::IntervalMonthDayNano(v) => Some(ValueData::IntervalMonthDayNanoValue(
1241                convert_month_day_nano_to_pb(v),
1242            )),
1243            Value::Decimal128(v) => Some(ValueData::Decimal128Value(convert_to_pb_decimal128(v))),
1244            Value::List(list_value) => {
1245                let items = list_value
1246                    .take_items()
1247                    .into_iter()
1248                    .map(value_to_grpc_value)
1249                    .collect();
1250                Some(ValueData::ListValue(v1::ListValue { items }))
1251            }
1252            Value::Struct(struct_value) => {
1253                let items = struct_value
1254                    .take_items()
1255                    .into_iter()
1256                    .map(value_to_grpc_value)
1257                    .collect();
1258                Some(ValueData::StructValue(v1::StructValue { items }))
1259            }
1260            Value::Duration(_) => unreachable!(),
1261        },
1262    }
1263}
1264
1265pub fn from_pb_time_unit(unit: v1::TimeUnit) -> TimeUnit {
1266    match unit {
1267        v1::TimeUnit::Second => TimeUnit::Second,
1268        v1::TimeUnit::Millisecond => TimeUnit::Millisecond,
1269        v1::TimeUnit::Microsecond => TimeUnit::Microsecond,
1270        v1::TimeUnit::Nanosecond => TimeUnit::Nanosecond,
1271    }
1272}
1273
1274pub fn to_pb_time_unit(unit: TimeUnit) -> v1::TimeUnit {
1275    match unit {
1276        TimeUnit::Second => v1::TimeUnit::Second,
1277        TimeUnit::Millisecond => v1::TimeUnit::Millisecond,
1278        TimeUnit::Microsecond => v1::TimeUnit::Microsecond,
1279        TimeUnit::Nanosecond => v1::TimeUnit::Nanosecond,
1280    }
1281}
1282
1283pub fn from_pb_time_ranges(time_ranges: v1::TimeRanges) -> Result<Vec<(Timestamp, Timestamp)>> {
1284    if time_ranges.time_ranges.is_empty() {
1285        return Ok(vec![]);
1286    }
1287    let proto_time_unit = v1::TimeUnit::try_from(time_ranges.time_unit).map_err(|_| {
1288        InvalidTimeUnitSnafu {
1289            time_unit: time_ranges.time_unit,
1290        }
1291        .build()
1292    })?;
1293    let time_unit = from_pb_time_unit(proto_time_unit);
1294    Ok(time_ranges
1295        .time_ranges
1296        .into_iter()
1297        .map(|r| {
1298            (
1299                Timestamp::new(r.start, time_unit),
1300                Timestamp::new(r.end, time_unit),
1301            )
1302        })
1303        .collect())
1304}
1305
1306/// All time_ranges must be of the same time unit.
1307///
1308/// if input `time_ranges` is empty, it will return a default `TimeRanges` with `Millisecond` as the time unit.
1309pub fn to_pb_time_ranges(time_ranges: &[(Timestamp, Timestamp)]) -> Result<v1::TimeRanges> {
1310    let is_same_time_unit = time_ranges.windows(2).all(|x| {
1311        x[0].0.unit() == x[1].0.unit()
1312            && x[0].1.unit() == x[1].1.unit()
1313            && x[0].0.unit() == x[0].1.unit()
1314    });
1315
1316    if !is_same_time_unit {
1317        let all_time_units: Vec<_> = time_ranges
1318            .iter()
1319            .map(|(s, e)| [s.unit(), e.unit()])
1320            .clone()
1321            .flatten()
1322            .collect::<HashSet<_>>()
1323            .into_iter()
1324            .collect();
1325        InconsistentTimeUnitSnafu {
1326            units: all_time_units,
1327        }
1328        .fail()?
1329    }
1330
1331    let mut pb_time_ranges = v1::TimeRanges {
1332        // default time unit is Millisecond
1333        time_unit: v1::TimeUnit::Millisecond as i32,
1334        time_ranges: Vec::with_capacity(time_ranges.len()),
1335    };
1336    if let Some((start, _end)) = time_ranges.first() {
1337        pb_time_ranges.time_unit = to_pb_time_unit(start.unit()) as i32;
1338    }
1339    for (start, end) in time_ranges {
1340        pb_time_ranges.time_ranges.push(v1::TimeRange {
1341            start: start.value(),
1342            end: end.value(),
1343        });
1344    }
1345    Ok(pb_time_ranges)
1346}
1347
1348#[cfg(test)]
1349mod tests {
1350    use std::sync::Arc;
1351
1352    use common_time::interval::IntervalUnit;
1353    use datatypes::types::{
1354        Int32Type, IntervalDayTimeType, IntervalMonthDayNanoType, IntervalYearMonthType,
1355        TimeMillisecondType, TimeSecondType, TimestampMillisecondType, TimestampSecondType,
1356        UInt32Type,
1357    };
1358    use datatypes::vectors::BooleanVector;
1359    use paste::paste;
1360
1361    use super::*;
1362    use crate::v1::Column;
1363
1364    #[test]
1365    fn test_values_with_capacity() {
1366        let values = values_with_capacity(ColumnDataType::Int8, 2);
1367        let values = values.i8_values;
1368        assert_eq!(2, values.capacity());
1369
1370        let values = values_with_capacity(ColumnDataType::Int32, 2);
1371        let values = values.i32_values;
1372        assert_eq!(2, values.capacity());
1373
1374        let values = values_with_capacity(ColumnDataType::Int64, 2);
1375        let values = values.i64_values;
1376        assert_eq!(2, values.capacity());
1377
1378        let values = values_with_capacity(ColumnDataType::Uint8, 2);
1379        let values = values.u8_values;
1380        assert_eq!(2, values.capacity());
1381
1382        let values = values_with_capacity(ColumnDataType::Uint32, 2);
1383        let values = values.u32_values;
1384        assert_eq!(2, values.capacity());
1385
1386        let values = values_with_capacity(ColumnDataType::Uint64, 2);
1387        let values = values.u64_values;
1388        assert_eq!(2, values.capacity());
1389
1390        let values = values_with_capacity(ColumnDataType::Float32, 2);
1391        let values = values.f32_values;
1392        assert_eq!(2, values.capacity());
1393
1394        let values = values_with_capacity(ColumnDataType::Float64, 2);
1395        let values = values.f64_values;
1396        assert_eq!(2, values.capacity());
1397
1398        let values = values_with_capacity(ColumnDataType::Binary, 2);
1399        let values = values.binary_values;
1400        assert_eq!(2, values.capacity());
1401
1402        let values = values_with_capacity(ColumnDataType::Boolean, 2);
1403        let values = values.bool_values;
1404        assert_eq!(2, values.capacity());
1405
1406        let values = values_with_capacity(ColumnDataType::String, 2);
1407        let values = values.string_values;
1408        assert_eq!(2, values.capacity());
1409
1410        let values = values_with_capacity(ColumnDataType::Date, 2);
1411        let values = values.date_values;
1412        assert_eq!(2, values.capacity());
1413
1414        let values = values_with_capacity(ColumnDataType::Datetime, 2);
1415        let values = values.datetime_values;
1416        assert_eq!(2, values.capacity());
1417
1418        let values = values_with_capacity(ColumnDataType::TimestampMillisecond, 2);
1419        let values = values.timestamp_millisecond_values;
1420        assert_eq!(2, values.capacity());
1421
1422        let values = values_with_capacity(ColumnDataType::TimeMillisecond, 2);
1423        let values = values.time_millisecond_values;
1424        assert_eq!(2, values.capacity());
1425
1426        let values = values_with_capacity(ColumnDataType::IntervalDayTime, 2);
1427        let values = values.interval_day_time_values;
1428        assert_eq!(2, values.capacity());
1429
1430        let values = values_with_capacity(ColumnDataType::IntervalMonthDayNano, 2);
1431        let values = values.interval_month_day_nano_values;
1432        assert_eq!(2, values.capacity());
1433
1434        let values = values_with_capacity(ColumnDataType::Decimal128, 2);
1435        let values = values.decimal128_values;
1436        assert_eq!(2, values.capacity());
1437
1438        let values = values_with_capacity(ColumnDataType::Vector, 2);
1439        let values = values.binary_values;
1440        assert_eq!(2, values.capacity());
1441
1442        let values = values_with_capacity(ColumnDataType::List, 2);
1443        let values = values.list_values;
1444        assert_eq!(2, values.capacity());
1445
1446        let values = values_with_capacity(ColumnDataType::Struct, 2);
1447        let values = values.struct_values;
1448        assert_eq!(2, values.capacity());
1449    }
1450
1451    #[test]
1452    fn test_concrete_datatype_from_column_datatype() {
1453        assert_eq!(
1454            ConcreteDataType::boolean_datatype(),
1455            ColumnDataTypeWrapper::boolean_datatype().into()
1456        );
1457        assert_eq!(
1458            ConcreteDataType::int8_datatype(),
1459            ColumnDataTypeWrapper::int8_datatype().into()
1460        );
1461        assert_eq!(
1462            ConcreteDataType::int16_datatype(),
1463            ColumnDataTypeWrapper::int16_datatype().into()
1464        );
1465        assert_eq!(
1466            ConcreteDataType::int32_datatype(),
1467            ColumnDataTypeWrapper::int32_datatype().into()
1468        );
1469        assert_eq!(
1470            ConcreteDataType::int64_datatype(),
1471            ColumnDataTypeWrapper::int64_datatype().into()
1472        );
1473        assert_eq!(
1474            ConcreteDataType::uint8_datatype(),
1475            ColumnDataTypeWrapper::uint8_datatype().into()
1476        );
1477        assert_eq!(
1478            ConcreteDataType::uint16_datatype(),
1479            ColumnDataTypeWrapper::uint16_datatype().into()
1480        );
1481        assert_eq!(
1482            ConcreteDataType::uint32_datatype(),
1483            ColumnDataTypeWrapper::uint32_datatype().into()
1484        );
1485        assert_eq!(
1486            ConcreteDataType::uint64_datatype(),
1487            ColumnDataTypeWrapper::uint64_datatype().into()
1488        );
1489        assert_eq!(
1490            ConcreteDataType::float32_datatype(),
1491            ColumnDataTypeWrapper::float32_datatype().into()
1492        );
1493        assert_eq!(
1494            ConcreteDataType::float64_datatype(),
1495            ColumnDataTypeWrapper::float64_datatype().into()
1496        );
1497        assert_eq!(
1498            ConcreteDataType::binary_datatype(),
1499            ColumnDataTypeWrapper::binary_datatype().into()
1500        );
1501        assert_eq!(
1502            ConcreteDataType::string_datatype(),
1503            ColumnDataTypeWrapper::string_datatype().into()
1504        );
1505        assert_eq!(
1506            ConcreteDataType::date_datatype(),
1507            ColumnDataTypeWrapper::date_datatype().into()
1508        );
1509        assert_eq!(
1510            ConcreteDataType::timestamp_microsecond_datatype(),
1511            ColumnDataTypeWrapper::datetime_datatype().into()
1512        );
1513        assert_eq!(
1514            ConcreteDataType::timestamp_millisecond_datatype(),
1515            ColumnDataTypeWrapper::timestamp_millisecond_datatype().into()
1516        );
1517        assert_eq!(
1518            ConcreteDataType::time_datatype(TimeUnit::Millisecond),
1519            ColumnDataTypeWrapper::time_millisecond_datatype().into()
1520        );
1521        assert_eq!(
1522            ConcreteDataType::interval_datatype(IntervalUnit::DayTime),
1523            ColumnDataTypeWrapper::interval_day_time_datatype().into()
1524        );
1525        assert_eq!(
1526            ConcreteDataType::interval_datatype(IntervalUnit::YearMonth),
1527            ColumnDataTypeWrapper::interval_year_month_datatype().into()
1528        );
1529        assert_eq!(
1530            ConcreteDataType::interval_datatype(IntervalUnit::MonthDayNano),
1531            ColumnDataTypeWrapper::interval_month_day_nano_datatype().into()
1532        );
1533        assert_eq!(
1534            ConcreteDataType::decimal128_datatype(10, 2),
1535            ColumnDataTypeWrapper::decimal128_datatype(10, 2).into()
1536        );
1537        assert_eq!(
1538            ConcreteDataType::vector_datatype(3),
1539            ColumnDataTypeWrapper::vector_datatype(3).into()
1540        );
1541        assert_eq!(
1542            ConcreteDataType::list_datatype(ConcreteDataType::string_datatype()),
1543            ColumnDataTypeWrapper::list_datatype(ColumnDataTypeWrapper::string_datatype()).into()
1544        );
1545        let struct_type = StructType::new(vec![
1546            StructField::new("id".to_string(), ConcreteDataType::int64_datatype(), true),
1547            StructField::new(
1548                "name".to_string(),
1549                ConcreteDataType::string_datatype(),
1550                true,
1551            ),
1552            StructField::new("age".to_string(), ConcreteDataType::int32_datatype(), true),
1553            StructField::new(
1554                "address".to_string(),
1555                ConcreteDataType::string_datatype(),
1556                true,
1557            ),
1558        ]);
1559        assert_eq!(
1560            ConcreteDataType::struct_datatype(struct_type.clone()),
1561            ColumnDataTypeWrapper::struct_datatype(vec![
1562                ("id".to_string(), ColumnDataTypeWrapper::int64_datatype()),
1563                ("name".to_string(), ColumnDataTypeWrapper::string_datatype()),
1564                ("age".to_string(), ColumnDataTypeWrapper::int32_datatype()),
1565                (
1566                    "address".to_string(),
1567                    ColumnDataTypeWrapper::string_datatype()
1568                )
1569            ])
1570            .into()
1571        );
1572    }
1573
1574    #[test]
1575    fn test_column_datatype_from_concrete_datatype() {
1576        assert_eq!(
1577            ColumnDataTypeWrapper::boolean_datatype(),
1578            ConcreteDataType::boolean_datatype().try_into().unwrap()
1579        );
1580        assert_eq!(
1581            ColumnDataTypeWrapper::int8_datatype(),
1582            ConcreteDataType::int8_datatype().try_into().unwrap()
1583        );
1584        assert_eq!(
1585            ColumnDataTypeWrapper::int16_datatype(),
1586            ConcreteDataType::int16_datatype().try_into().unwrap()
1587        );
1588        assert_eq!(
1589            ColumnDataTypeWrapper::int32_datatype(),
1590            ConcreteDataType::int32_datatype().try_into().unwrap()
1591        );
1592        assert_eq!(
1593            ColumnDataTypeWrapper::int64_datatype(),
1594            ConcreteDataType::int64_datatype().try_into().unwrap()
1595        );
1596        assert_eq!(
1597            ColumnDataTypeWrapper::uint8_datatype(),
1598            ConcreteDataType::uint8_datatype().try_into().unwrap()
1599        );
1600        assert_eq!(
1601            ColumnDataTypeWrapper::uint16_datatype(),
1602            ConcreteDataType::uint16_datatype().try_into().unwrap()
1603        );
1604        assert_eq!(
1605            ColumnDataTypeWrapper::uint32_datatype(),
1606            ConcreteDataType::uint32_datatype().try_into().unwrap()
1607        );
1608        assert_eq!(
1609            ColumnDataTypeWrapper::uint64_datatype(),
1610            ConcreteDataType::uint64_datatype().try_into().unwrap()
1611        );
1612        assert_eq!(
1613            ColumnDataTypeWrapper::float32_datatype(),
1614            ConcreteDataType::float32_datatype().try_into().unwrap()
1615        );
1616        assert_eq!(
1617            ColumnDataTypeWrapper::float64_datatype(),
1618            ConcreteDataType::float64_datatype().try_into().unwrap()
1619        );
1620        assert_eq!(
1621            ColumnDataTypeWrapper::binary_datatype(),
1622            ConcreteDataType::binary_datatype().try_into().unwrap()
1623        );
1624        assert_eq!(
1625            ColumnDataTypeWrapper::string_datatype(),
1626            ConcreteDataType::string_datatype().try_into().unwrap()
1627        );
1628        assert_eq!(
1629            ColumnDataTypeWrapper::date_datatype(),
1630            ConcreteDataType::date_datatype().try_into().unwrap()
1631        );
1632        assert_eq!(
1633            ColumnDataTypeWrapper::timestamp_millisecond_datatype(),
1634            ConcreteDataType::timestamp_millisecond_datatype()
1635                .try_into()
1636                .unwrap()
1637        );
1638        assert_eq!(
1639            ColumnDataTypeWrapper::interval_year_month_datatype(),
1640            ConcreteDataType::interval_datatype(IntervalUnit::YearMonth)
1641                .try_into()
1642                .unwrap()
1643        );
1644        assert_eq!(
1645            ColumnDataTypeWrapper::interval_day_time_datatype(),
1646            ConcreteDataType::interval_datatype(IntervalUnit::DayTime)
1647                .try_into()
1648                .unwrap()
1649        );
1650        assert_eq!(
1651            ColumnDataTypeWrapper::interval_month_day_nano_datatype(),
1652            ConcreteDataType::interval_datatype(IntervalUnit::MonthDayNano)
1653                .try_into()
1654                .unwrap()
1655        );
1656
1657        assert_eq!(
1658            ColumnDataTypeWrapper::decimal128_datatype(10, 2),
1659            ConcreteDataType::decimal128_datatype(10, 2)
1660                .try_into()
1661                .unwrap()
1662        );
1663        assert_eq!(
1664            ColumnDataTypeWrapper::vector_datatype(3),
1665            ConcreteDataType::vector_datatype(3).try_into().unwrap()
1666        );
1667
1668        let result: Result<ColumnDataTypeWrapper> = ConcreteDataType::null_datatype().try_into();
1669        assert!(result.is_err());
1670        assert_eq!(
1671            result.unwrap_err().to_string(),
1672            "Failed to create column datatype from Null(NullType)"
1673        );
1674
1675        assert_eq!(
1676            ColumnDataTypeWrapper::list_datatype(ColumnDataTypeWrapper::int16_datatype()),
1677            ConcreteDataType::list_datatype(ConcreteDataType::int16_datatype())
1678                .try_into()
1679                .expect("Failed to create column datatype from List(ListType { item_type: Int16(Int16Type) })")
1680        );
1681
1682        assert_eq!(
1683            ColumnDataTypeWrapper::struct_datatype(vec![
1684                ("a".to_string(), ColumnDataTypeWrapper::int64_datatype()),
1685                (
1686                    "a.a".to_string(),
1687                    ColumnDataTypeWrapper::list_datatype(ColumnDataTypeWrapper::string_datatype())
1688                )
1689            ]),
1690            ConcreteDataType::struct_datatype(StructType::new(vec![
1691                StructField::new("a".to_string(), ConcreteDataType::int64_datatype(), true),
1692                StructField::new(
1693                    "a.a".to_string(),
1694                    ConcreteDataType::list_datatype(ConcreteDataType::string_datatype()), true
1695                )
1696            ])).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) }) }] })")
1697        )
1698    }
1699
1700    #[test]
1701    fn test_convert_i128_to_interval() {
1702        let i128_val = 3;
1703        let interval = convert_month_day_nano_to_pb(IntervalMonthDayNano::from_i128(i128_val));
1704        assert_eq!(interval.months, 0);
1705        assert_eq!(interval.days, 0);
1706        assert_eq!(interval.nanoseconds, 3);
1707    }
1708
1709    #[test]
1710    fn test_convert_timestamp_values() {
1711        // second
1712        let actual = pb_values_to_values(
1713            &ConcreteDataType::Timestamp(TimestampType::Second(TimestampSecondType)),
1714            Values {
1715                timestamp_second_values: vec![1_i64, 2_i64, 3_i64],
1716                ..Default::default()
1717            },
1718        );
1719        let expect = vec![
1720            Value::Timestamp(Timestamp::new_second(1_i64)),
1721            Value::Timestamp(Timestamp::new_second(2_i64)),
1722            Value::Timestamp(Timestamp::new_second(3_i64)),
1723        ];
1724        assert_eq!(expect, actual);
1725
1726        // millisecond
1727        let actual = pb_values_to_values(
1728            &ConcreteDataType::Timestamp(TimestampType::Millisecond(TimestampMillisecondType)),
1729            Values {
1730                timestamp_millisecond_values: vec![1_i64, 2_i64, 3_i64],
1731                ..Default::default()
1732            },
1733        );
1734        let expect = vec![
1735            Value::Timestamp(Timestamp::new_millisecond(1_i64)),
1736            Value::Timestamp(Timestamp::new_millisecond(2_i64)),
1737            Value::Timestamp(Timestamp::new_millisecond(3_i64)),
1738        ];
1739        assert_eq!(expect, actual);
1740    }
1741
1742    #[test]
1743    fn test_convert_time_values() {
1744        // second
1745        let actual = pb_values_to_values(
1746            &ConcreteDataType::Time(TimeType::Second(TimeSecondType)),
1747            Values {
1748                time_second_values: vec![1_i64, 2_i64, 3_i64],
1749                ..Default::default()
1750            },
1751        );
1752        let expect = vec![
1753            Value::Time(Time::new_second(1_i64)),
1754            Value::Time(Time::new_second(2_i64)),
1755            Value::Time(Time::new_second(3_i64)),
1756        ];
1757        assert_eq!(expect, actual);
1758
1759        // millisecond
1760        let actual = pb_values_to_values(
1761            &ConcreteDataType::Time(TimeType::Millisecond(TimeMillisecondType)),
1762            Values {
1763                time_millisecond_values: vec![1_i64, 2_i64, 3_i64],
1764                ..Default::default()
1765            },
1766        );
1767        let expect = vec![
1768            Value::Time(Time::new_millisecond(1_i64)),
1769            Value::Time(Time::new_millisecond(2_i64)),
1770            Value::Time(Time::new_millisecond(3_i64)),
1771        ];
1772        assert_eq!(expect, actual);
1773    }
1774
1775    #[test]
1776    fn test_convert_interval_values() {
1777        // year_month
1778        let actual = pb_values_to_values(
1779            &ConcreteDataType::Interval(IntervalType::YearMonth(IntervalYearMonthType)),
1780            Values {
1781                interval_year_month_values: vec![1_i32, 2_i32, 3_i32],
1782                ..Default::default()
1783            },
1784        );
1785        let expect = vec![
1786            Value::IntervalYearMonth(IntervalYearMonth::new(1_i32)),
1787            Value::IntervalYearMonth(IntervalYearMonth::new(2_i32)),
1788            Value::IntervalYearMonth(IntervalYearMonth::new(3_i32)),
1789        ];
1790        assert_eq!(expect, actual);
1791
1792        // day_time
1793        let actual = pb_values_to_values(
1794            &ConcreteDataType::Interval(IntervalType::DayTime(IntervalDayTimeType)),
1795            Values {
1796                interval_day_time_values: vec![1_i64, 2_i64, 3_i64],
1797                ..Default::default()
1798            },
1799        );
1800        let expect = vec![
1801            Value::IntervalDayTime(IntervalDayTime::from_i64(1_i64)),
1802            Value::IntervalDayTime(IntervalDayTime::from_i64(2_i64)),
1803            Value::IntervalDayTime(IntervalDayTime::from_i64(3_i64)),
1804        ];
1805        assert_eq!(expect, actual);
1806
1807        // month_day_nano
1808        let actual = pb_values_to_values(
1809            &ConcreteDataType::Interval(IntervalType::MonthDayNano(IntervalMonthDayNanoType)),
1810            Values {
1811                interval_month_day_nano_values: vec![
1812                    v1::IntervalMonthDayNano {
1813                        months: 1,
1814                        days: 2,
1815                        nanoseconds: 3,
1816                    },
1817                    v1::IntervalMonthDayNano {
1818                        months: 5,
1819                        days: 6,
1820                        nanoseconds: 7,
1821                    },
1822                    v1::IntervalMonthDayNano {
1823                        months: 9,
1824                        days: 10,
1825                        nanoseconds: 11,
1826                    },
1827                ],
1828                ..Default::default()
1829            },
1830        );
1831        let expect = vec![
1832            Value::IntervalMonthDayNano(IntervalMonthDayNano::new(1, 2, 3)),
1833            Value::IntervalMonthDayNano(IntervalMonthDayNano::new(5, 6, 7)),
1834            Value::IntervalMonthDayNano(IntervalMonthDayNano::new(9, 10, 11)),
1835        ];
1836        assert_eq!(expect, actual);
1837    }
1838
1839    macro_rules! test_convert_values {
1840        ($grpc_data_type: ident, $values: expr,  $concrete_data_type: ident, $expected_ret: expr) => {
1841            paste! {
1842                #[test]
1843                fn [<test_convert_ $grpc_data_type _values>]() {
1844                    let values = Values {
1845                        [<$grpc_data_type _values>]: $values,
1846                        ..Default::default()
1847                    };
1848
1849                    let data_type = ConcreteDataType::[<$concrete_data_type _datatype>]();
1850                    let result = pb_values_to_values(&data_type, values);
1851
1852                    assert_eq!(
1853                        $expected_ret,
1854                        result
1855                    );
1856                }
1857            }
1858        };
1859    }
1860
1861    test_convert_values!(
1862        i8,
1863        vec![1_i32, 2, 3],
1864        int8,
1865        vec![Value::Int8(1), Value::Int8(2), Value::Int8(3)]
1866    );
1867
1868    test_convert_values!(
1869        u8,
1870        vec![1_u32, 2, 3],
1871        uint8,
1872        vec![Value::UInt8(1), Value::UInt8(2), Value::UInt8(3)]
1873    );
1874
1875    test_convert_values!(
1876        i16,
1877        vec![1_i32, 2, 3],
1878        int16,
1879        vec![Value::Int16(1), Value::Int16(2), Value::Int16(3)]
1880    );
1881
1882    test_convert_values!(
1883        u16,
1884        vec![1_u32, 2, 3],
1885        uint16,
1886        vec![Value::UInt16(1), Value::UInt16(2), Value::UInt16(3)]
1887    );
1888
1889    test_convert_values!(
1890        i32,
1891        vec![1, 2, 3],
1892        int32,
1893        vec![Value::Int32(1), Value::Int32(2), Value::Int32(3)]
1894    );
1895
1896    test_convert_values!(
1897        u32,
1898        vec![1, 2, 3],
1899        uint32,
1900        vec![Value::UInt32(1), Value::UInt32(2), Value::UInt32(3)]
1901    );
1902
1903    test_convert_values!(
1904        i64,
1905        vec![1, 2, 3],
1906        int64,
1907        vec![Value::Int64(1), Value::Int64(2), Value::Int64(3)]
1908    );
1909
1910    test_convert_values!(
1911        u64,
1912        vec![1, 2, 3],
1913        uint64,
1914        vec![Value::UInt64(1), Value::UInt64(2), Value::UInt64(3)]
1915    );
1916
1917    test_convert_values!(
1918        f32,
1919        vec![1.0, 2.0, 3.0],
1920        float32,
1921        vec![
1922            Value::Float32(1.0.into()),
1923            Value::Float32(2.0.into()),
1924            Value::Float32(3.0.into())
1925        ]
1926    );
1927
1928    test_convert_values!(
1929        f64,
1930        vec![1.0, 2.0, 3.0],
1931        float64,
1932        vec![
1933            Value::Float64(1.0.into()),
1934            Value::Float64(2.0.into()),
1935            Value::Float64(3.0.into())
1936        ]
1937    );
1938
1939    test_convert_values!(
1940        string,
1941        vec!["1".to_string(), "2".to_string(), "3".to_string()],
1942        string,
1943        vec![
1944            Value::String("1".into()),
1945            Value::String("2".into()),
1946            Value::String("3".into())
1947        ]
1948    );
1949
1950    test_convert_values!(
1951        binary,
1952        vec!["1".into(), "2".into(), "3".into()],
1953        binary,
1954        vec![
1955            Value::Binary(b"1".to_vec().into()),
1956            Value::Binary(b"2".to_vec().into()),
1957            Value::Binary(b"3".to_vec().into())
1958        ]
1959    );
1960
1961    test_convert_values!(
1962        date,
1963        vec![1, 2, 3],
1964        date,
1965        vec![
1966            Value::Date(1.into()),
1967            Value::Date(2.into()),
1968            Value::Date(3.into())
1969        ]
1970    );
1971
1972    #[test]
1973    fn test_vectors_to_rows_for_different_types() {
1974        let boolean_vec = BooleanVector::from_vec(vec![true, false, true]);
1975        let int8_vec = PrimitiveVector::<Int8Type>::from_iter_values(vec![1, 2, 3]);
1976        let int32_vec = PrimitiveVector::<Int32Type>::from_iter_values(vec![100, 200, 300]);
1977        let uint8_vec = PrimitiveVector::<UInt8Type>::from_iter_values(vec![10, 20, 30]);
1978        let uint32_vec = PrimitiveVector::<UInt32Type>::from_iter_values(vec![1000, 2000, 3000]);
1979        let float32_vec = Float32Vector::from_vec(vec![1.1, 2.2, 3.3]);
1980        let date_vec = DateVector::from_vec(vec![10, 20, 30]);
1981        let string_vec = StringVector::from_vec(vec!["a", "b", "c"]);
1982
1983        let vector_refs: Vec<VectorRef> = vec![
1984            Arc::new(boolean_vec),
1985            Arc::new(int8_vec),
1986            Arc::new(int32_vec),
1987            Arc::new(uint8_vec),
1988            Arc::new(uint32_vec),
1989            Arc::new(float32_vec),
1990            Arc::new(date_vec),
1991            Arc::new(string_vec),
1992        ];
1993
1994        let result = vectors_to_rows(vector_refs.iter(), 3);
1995
1996        assert_eq!(result.len(), 3);
1997
1998        assert_eq!(result[0].values.len(), 8);
1999        let values = result[0]
2000            .values
2001            .iter()
2002            .map(|v| v.value_data.clone().unwrap())
2003            .collect::<Vec<_>>();
2004        assert_eq!(values[0], ValueData::BoolValue(true));
2005        assert_eq!(values[1], ValueData::I8Value(1));
2006        assert_eq!(values[2], ValueData::I32Value(100));
2007        assert_eq!(values[3], ValueData::U8Value(10));
2008        assert_eq!(values[4], ValueData::U32Value(1000));
2009        assert_eq!(values[5], ValueData::F32Value(1.1));
2010        assert_eq!(values[6], ValueData::DateValue(10));
2011        assert_eq!(values[7], ValueData::StringValue("a".to_string()));
2012
2013        assert_eq!(result[1].values.len(), 8);
2014        let values = result[1]
2015            .values
2016            .iter()
2017            .map(|v| v.value_data.clone().unwrap())
2018            .collect::<Vec<_>>();
2019        assert_eq!(values[0], ValueData::BoolValue(false));
2020        assert_eq!(values[1], ValueData::I8Value(2));
2021        assert_eq!(values[2], ValueData::I32Value(200));
2022        assert_eq!(values[3], ValueData::U8Value(20));
2023        assert_eq!(values[4], ValueData::U32Value(2000));
2024        assert_eq!(values[5], ValueData::F32Value(2.2));
2025        assert_eq!(values[6], ValueData::DateValue(20));
2026        assert_eq!(values[7], ValueData::StringValue("b".to_string()));
2027
2028        assert_eq!(result[2].values.len(), 8);
2029        let values = result[2]
2030            .values
2031            .iter()
2032            .map(|v| v.value_data.clone().unwrap())
2033            .collect::<Vec<_>>();
2034        assert_eq!(values[0], ValueData::BoolValue(true));
2035        assert_eq!(values[1], ValueData::I8Value(3));
2036        assert_eq!(values[2], ValueData::I32Value(300));
2037        assert_eq!(values[3], ValueData::U8Value(30));
2038        assert_eq!(values[4], ValueData::U32Value(3000));
2039        assert_eq!(values[5], ValueData::F32Value(3.3));
2040        assert_eq!(values[6], ValueData::DateValue(30));
2041        assert_eq!(values[7], ValueData::StringValue("c".to_string()));
2042    }
2043
2044    #[test]
2045    fn test_is_column_type_value_eq() {
2046        // test column type eq
2047        let column1 = Column {
2048            column_name: "test".to_string(),
2049            semantic_type: 0,
2050            values: Some(Values {
2051                bool_values: vec![false, true, true],
2052                ..Default::default()
2053            }),
2054            null_mask: vec![2],
2055            datatype: ColumnDataType::Boolean as i32,
2056            datatype_extension: None,
2057            options: None,
2058        };
2059        assert!(is_column_type_value_eq(
2060            column1.datatype,
2061            column1.datatype_extension,
2062            &ConcreteDataType::boolean_datatype(),
2063        ));
2064    }
2065
2066    #[test]
2067    fn test_convert_to_pb_decimal128() {
2068        let decimal = Decimal128::new(123, 3, 1);
2069        let pb_decimal = convert_to_pb_decimal128(decimal);
2070        assert_eq!(pb_decimal.lo, 123);
2071        assert_eq!(pb_decimal.hi, 0);
2072    }
2073
2074    #[test]
2075    fn test_list_to_pb_value() {
2076        let value = Value::List(ListValue::new(
2077            vec![Value::Boolean(true)],
2078            ConcreteDataType::boolean_datatype(),
2079        ));
2080
2081        let pb_value = to_proto_value(value);
2082
2083        match pb_value.value_data.unwrap() {
2084            ValueData::ListValue(pb_list_value) => {
2085                assert_eq!(pb_list_value.items.len(), 1);
2086            }
2087            _ => panic!("Unexpected value type"),
2088        }
2089    }
2090
2091    #[test]
2092    fn test_struct_to_pb_value() {
2093        let items = vec![Value::Boolean(true), Value::String("tom".into())];
2094
2095        let value = Value::Struct(
2096            StructValue::try_new(
2097                items,
2098                StructType::new(vec![
2099                    StructField::new(
2100                        "a.a".to_string(),
2101                        ConcreteDataType::boolean_datatype(),
2102                        true,
2103                    ),
2104                    StructField::new("a.b".to_string(), ConcreteDataType::string_datatype(), true),
2105                ]),
2106            )
2107            .unwrap(),
2108        );
2109
2110        let pb_value = to_proto_value(value);
2111
2112        match pb_value.value_data.unwrap() {
2113            ValueData::StructValue(pb_struct_value) => {
2114                assert_eq!(pb_struct_value.items.len(), 2);
2115            }
2116            _ => panic!("Unexpected value type"),
2117        }
2118    }
2119}
api/helper.rs

api/
helper.rs
