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

api/
helper.rs
