Skip to main content

api/
helper.rs

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