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