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

api/
helper.rs
