Skip to main content

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