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::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 native_type =
455                                    ConcreteDataType::from_arrow_type(&native_type.as_arrow_type());
456                                let (datatype, datatype_extension) =
457                                    ColumnDataTypeWrapper::try_from(native_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 Some(value) = &value.value else {
935        return JsonValueRef::null();
936    };
937    match value {
938        json_value::Value::Boolean(x) => (*x).into(),
939        json_value::Value::Int(x) => (*x).into(),
940        json_value::Value::Uint(x) => (*x).into(),
941        json_value::Value::Float(x) => (*x).into(),
942        json_value::Value::Str(x) => (x.as_str()).into(),
943        json_value::Value::Array(array) => array
944            .items
945            .iter()
946            .map(|x| decode_json_value(x).into_variant())
947            .collect::<Vec<_>>()
948            .into(),
949        json_value::Value::Object(x) => x
950            .entries
951            .iter()
952            .filter_map(|entry| {
953                entry
954                    .value
955                    .as_ref()
956                    .map(|v| (entry.key.as_str(), decode_json_value(v).into_variant()))
957            })
958            .collect::<BTreeMap<_, _>>()
959            .into(),
960        json_value::Value::Variant(x) => x.as_slice().into(),
961    }
962}
963
964/// Returns the [ColumnDataTypeWrapper] of the value.
965///
966/// If value is null, returns `None`.
967pub fn proto_value_type(value: &v1::Value) -> Option<ColumnDataType> {
968    let value_type = match value.value_data.as_ref()? {
969        ValueData::I8Value(_) => ColumnDataType::Int8,
970        ValueData::I16Value(_) => ColumnDataType::Int16,
971        ValueData::I32Value(_) => ColumnDataType::Int32,
972        ValueData::I64Value(_) => ColumnDataType::Int64,
973        ValueData::U8Value(_) => ColumnDataType::Uint8,
974        ValueData::U16Value(_) => ColumnDataType::Uint16,
975        ValueData::U32Value(_) => ColumnDataType::Uint32,
976        ValueData::U64Value(_) => ColumnDataType::Uint64,
977        ValueData::F32Value(_) => ColumnDataType::Float32,
978        ValueData::F64Value(_) => ColumnDataType::Float64,
979        ValueData::BoolValue(_) => ColumnDataType::Boolean,
980        ValueData::BinaryValue(_) => ColumnDataType::Binary,
981        ValueData::StringValue(_) => ColumnDataType::String,
982        ValueData::DateValue(_) => ColumnDataType::Date,
983        ValueData::DatetimeValue(_) => ColumnDataType::Datetime,
984        ValueData::TimestampSecondValue(_) => ColumnDataType::TimestampSecond,
985        ValueData::TimestampMillisecondValue(_) => ColumnDataType::TimestampMillisecond,
986        ValueData::TimestampMicrosecondValue(_) => ColumnDataType::TimestampMicrosecond,
987        ValueData::TimestampNanosecondValue(_) => ColumnDataType::TimestampNanosecond,
988        ValueData::TimeSecondValue(_) => ColumnDataType::TimeSecond,
989        ValueData::TimeMillisecondValue(_) => ColumnDataType::TimeMillisecond,
990        ValueData::TimeMicrosecondValue(_) => ColumnDataType::TimeMicrosecond,
991        ValueData::TimeNanosecondValue(_) => ColumnDataType::TimeNanosecond,
992        ValueData::IntervalYearMonthValue(_) => ColumnDataType::IntervalYearMonth,
993        ValueData::IntervalDayTimeValue(_) => ColumnDataType::IntervalDayTime,
994        ValueData::IntervalMonthDayNanoValue(_) => ColumnDataType::IntervalMonthDayNano,
995        ValueData::Decimal128Value(_) => ColumnDataType::Decimal128,
996        ValueData::ListValue(_) => ColumnDataType::List,
997        ValueData::StructValue(_) => ColumnDataType::Struct,
998        ValueData::JsonValue(_) => ColumnDataType::Json,
999    };
1000    Some(value_type)
1001}
1002
1003pub fn vectors_to_rows<'a>(
1004    columns: impl Iterator<Item = &'a VectorRef>,
1005    row_count: usize,
1006) -> Vec<Row> {
1007    let mut rows = vec![Row { values: vec![] }; row_count];
1008    for column in columns {
1009        for (row_index, row) in rows.iter_mut().enumerate() {
1010            row.values.push(to_grpc_value(column.get(row_index)))
1011        }
1012    }
1013
1014    rows
1015}
1016
1017pub fn to_grpc_value(value: Value) -> GrpcValue {
1018    GrpcValue {
1019        value_data: match value {
1020            Value::Null => None,
1021            Value::Boolean(v) => Some(ValueData::BoolValue(v)),
1022            Value::UInt8(v) => Some(ValueData::U8Value(v as _)),
1023            Value::UInt16(v) => Some(ValueData::U16Value(v as _)),
1024            Value::UInt32(v) => Some(ValueData::U32Value(v)),
1025            Value::UInt64(v) => Some(ValueData::U64Value(v)),
1026            Value::Int8(v) => Some(ValueData::I8Value(v as _)),
1027            Value::Int16(v) => Some(ValueData::I16Value(v as _)),
1028            Value::Int32(v) => Some(ValueData::I32Value(v)),
1029            Value::Int64(v) => Some(ValueData::I64Value(v)),
1030            Value::Float32(v) => Some(ValueData::F32Value(*v)),
1031            Value::Float64(v) => Some(ValueData::F64Value(*v)),
1032            Value::String(v) => Some(ValueData::StringValue(v.into_string())),
1033            Value::Binary(v) => Some(ValueData::BinaryValue(v.to_vec())),
1034            Value::Date(v) => Some(ValueData::DateValue(v.val())),
1035            Value::Timestamp(v) => Some(match v.unit() {
1036                TimeUnit::Second => ValueData::TimestampSecondValue(v.value()),
1037                TimeUnit::Millisecond => ValueData::TimestampMillisecondValue(v.value()),
1038                TimeUnit::Microsecond => ValueData::TimestampMicrosecondValue(v.value()),
1039                TimeUnit::Nanosecond => ValueData::TimestampNanosecondValue(v.value()),
1040            }),
1041            Value::Time(v) => Some(match v.unit() {
1042                TimeUnit::Second => ValueData::TimeSecondValue(v.value()),
1043                TimeUnit::Millisecond => ValueData::TimeMillisecondValue(v.value()),
1044                TimeUnit::Microsecond => ValueData::TimeMicrosecondValue(v.value()),
1045                TimeUnit::Nanosecond => ValueData::TimeNanosecondValue(v.value()),
1046            }),
1047            Value::IntervalYearMonth(v) => Some(ValueData::IntervalYearMonthValue(v.to_i32())),
1048            Value::IntervalDayTime(v) => Some(ValueData::IntervalDayTimeValue(v.to_i64())),
1049            Value::IntervalMonthDayNano(v) => Some(ValueData::IntervalMonthDayNanoValue(
1050                convert_month_day_nano_to_pb(v),
1051            )),
1052            Value::Decimal128(v) => Some(ValueData::Decimal128Value(convert_to_pb_decimal128(v))),
1053            Value::List(list_value) => {
1054                let items = list_value
1055                    .take_items()
1056                    .into_iter()
1057                    .map(to_grpc_value)
1058                    .collect();
1059                Some(ValueData::ListValue(v1::ListValue { items }))
1060            }
1061            Value::Struct(struct_value) => {
1062                let items = struct_value
1063                    .take_items()
1064                    .into_iter()
1065                    .map(to_grpc_value)
1066                    .collect();
1067                Some(ValueData::StructValue(v1::StructValue { items }))
1068            }
1069            Value::Json(v) => Some(ValueData::JsonValue(encode_json_value(*v))),
1070            Value::Duration(_) => unreachable!(),
1071        },
1072    }
1073}
1074
1075pub fn from_pb_time_unit(unit: v1::TimeUnit) -> TimeUnit {
1076    match unit {
1077        v1::TimeUnit::Second => TimeUnit::Second,
1078        v1::TimeUnit::Millisecond => TimeUnit::Millisecond,
1079        v1::TimeUnit::Microsecond => TimeUnit::Microsecond,
1080        v1::TimeUnit::Nanosecond => TimeUnit::Nanosecond,
1081    }
1082}
1083
1084pub fn to_pb_time_unit(unit: TimeUnit) -> v1::TimeUnit {
1085    match unit {
1086        TimeUnit::Second => v1::TimeUnit::Second,
1087        TimeUnit::Millisecond => v1::TimeUnit::Millisecond,
1088        TimeUnit::Microsecond => v1::TimeUnit::Microsecond,
1089        TimeUnit::Nanosecond => v1::TimeUnit::Nanosecond,
1090    }
1091}
1092
1093pub fn from_pb_time_ranges(time_ranges: v1::TimeRanges) -> Result<Vec<(Timestamp, Timestamp)>> {
1094    if time_ranges.time_ranges.is_empty() {
1095        return Ok(vec![]);
1096    }
1097    let proto_time_unit = v1::TimeUnit::try_from(time_ranges.time_unit).map_err(|_| {
1098        InvalidTimeUnitSnafu {
1099            time_unit: time_ranges.time_unit,
1100        }
1101        .build()
1102    })?;
1103    let time_unit = from_pb_time_unit(proto_time_unit);
1104    Ok(time_ranges
1105        .time_ranges
1106        .into_iter()
1107        .map(|r| {
1108            (
1109                Timestamp::new(r.start, time_unit),
1110                Timestamp::new(r.end, time_unit),
1111            )
1112        })
1113        .collect())
1114}
1115
1116/// All time_ranges must be of the same time unit.
1117///
1118/// if input `time_ranges` is empty, it will return a default `TimeRanges` with `Millisecond` as the time unit.
1119pub fn to_pb_time_ranges(time_ranges: &[(Timestamp, Timestamp)]) -> Result<v1::TimeRanges> {
1120    let is_same_time_unit = time_ranges.windows(2).all(|x| {
1121        x[0].0.unit() == x[1].0.unit()
1122            && x[0].1.unit() == x[1].1.unit()
1123            && x[0].0.unit() == x[0].1.unit()
1124    });
1125
1126    if !is_same_time_unit {
1127        let all_time_units: Vec<_> = time_ranges
1128            .iter()
1129            .map(|(s, e)| [s.unit(), e.unit()])
1130            .clone()
1131            .flatten()
1132            .collect::<HashSet<_>>()
1133            .into_iter()
1134            .collect();
1135        InconsistentTimeUnitSnafu {
1136            units: all_time_units,
1137        }
1138        .fail()?
1139    }
1140
1141    let mut pb_time_ranges = v1::TimeRanges {
1142        // default time unit is Millisecond
1143        time_unit: v1::TimeUnit::Millisecond as i32,
1144        time_ranges: Vec::with_capacity(time_ranges.len()),
1145    };
1146    if let Some((start, _end)) = time_ranges.first() {
1147        pb_time_ranges.time_unit = to_pb_time_unit(start.unit()) as i32;
1148    }
1149    for (start, end) in time_ranges {
1150        pb_time_ranges.time_ranges.push(v1::TimeRange {
1151            start: start.value(),
1152            end: end.value(),
1153        });
1154    }
1155    Ok(pb_time_ranges)
1156}
1157
1158#[cfg(test)]
1159mod tests {
1160    use std::sync::Arc;
1161
1162    use common_time::interval::IntervalUnit;
1163    use datatypes::scalars::ScalarVector;
1164    use datatypes::types::json_type::JsonObjectType;
1165    use datatypes::types::{Int8Type, Int32Type, UInt8Type, UInt32Type};
1166    use datatypes::value::{ListValue, StructValue};
1167    use datatypes::vectors::{
1168        BooleanVector, DateVector, Float32Vector, PrimitiveVector, StringVector,
1169    };
1170
1171    use super::*;
1172    use crate::v1::Column;
1173
1174    #[test]
1175    fn test_values_with_capacity() {
1176        let values = values_with_capacity(ColumnDataType::Int8, 2);
1177        let values = values.i8_values;
1178        assert_eq!(2, values.capacity());
1179
1180        let values = values_with_capacity(ColumnDataType::Int32, 2);
1181        let values = values.i32_values;
1182        assert_eq!(2, values.capacity());
1183
1184        let values = values_with_capacity(ColumnDataType::Int64, 2);
1185        let values = values.i64_values;
1186        assert_eq!(2, values.capacity());
1187
1188        let values = values_with_capacity(ColumnDataType::Uint8, 2);
1189        let values = values.u8_values;
1190        assert_eq!(2, values.capacity());
1191
1192        let values = values_with_capacity(ColumnDataType::Uint32, 2);
1193        let values = values.u32_values;
1194        assert_eq!(2, values.capacity());
1195
1196        let values = values_with_capacity(ColumnDataType::Uint64, 2);
1197        let values = values.u64_values;
1198        assert_eq!(2, values.capacity());
1199
1200        let values = values_with_capacity(ColumnDataType::Float32, 2);
1201        let values = values.f32_values;
1202        assert_eq!(2, values.capacity());
1203
1204        let values = values_with_capacity(ColumnDataType::Float64, 2);
1205        let values = values.f64_values;
1206        assert_eq!(2, values.capacity());
1207
1208        let values = values_with_capacity(ColumnDataType::Binary, 2);
1209        let values = values.binary_values;
1210        assert_eq!(2, values.capacity());
1211
1212        let values = values_with_capacity(ColumnDataType::Boolean, 2);
1213        let values = values.bool_values;
1214        assert_eq!(2, values.capacity());
1215
1216        let values = values_with_capacity(ColumnDataType::String, 2);
1217        let values = values.string_values;
1218        assert_eq!(2, values.capacity());
1219
1220        let values = values_with_capacity(ColumnDataType::Date, 2);
1221        let values = values.date_values;
1222        assert_eq!(2, values.capacity());
1223
1224        let values = values_with_capacity(ColumnDataType::Datetime, 2);
1225        let values = values.datetime_values;
1226        assert_eq!(2, values.capacity());
1227
1228        let values = values_with_capacity(ColumnDataType::TimestampMillisecond, 2);
1229        let values = values.timestamp_millisecond_values;
1230        assert_eq!(2, values.capacity());
1231
1232        let values = values_with_capacity(ColumnDataType::TimeMillisecond, 2);
1233        let values = values.time_millisecond_values;
1234        assert_eq!(2, values.capacity());
1235
1236        let values = values_with_capacity(ColumnDataType::IntervalDayTime, 2);
1237        let values = values.interval_day_time_values;
1238        assert_eq!(2, values.capacity());
1239
1240        let values = values_with_capacity(ColumnDataType::IntervalMonthDayNano, 2);
1241        let values = values.interval_month_day_nano_values;
1242        assert_eq!(2, values.capacity());
1243
1244        let values = values_with_capacity(ColumnDataType::Decimal128, 2);
1245        let values = values.decimal128_values;
1246        assert_eq!(2, values.capacity());
1247
1248        let values = values_with_capacity(ColumnDataType::Vector, 2);
1249        let values = values.binary_values;
1250        assert_eq!(2, values.capacity());
1251
1252        let values = values_with_capacity(ColumnDataType::List, 2);
1253        let values = values.list_values;
1254        assert_eq!(2, values.capacity());
1255
1256        let values = values_with_capacity(ColumnDataType::Struct, 2);
1257        let values = values.struct_values;
1258        assert_eq!(2, values.capacity());
1259
1260        let values = values_with_capacity(ColumnDataType::Json, 2);
1261        assert_eq!(2, values.json_values.capacity());
1262        assert_eq!(2, values.string_values.capacity());
1263
1264        let values = values_with_capacity(ColumnDataType::Dictionary, 2);
1265        assert!(values.bool_values.is_empty());
1266    }
1267
1268    #[test]
1269    fn test_concrete_datatype_from_column_datatype() {
1270        assert_eq!(
1271            ConcreteDataType::boolean_datatype(),
1272            ColumnDataTypeWrapper::boolean_datatype().into()
1273        );
1274        assert_eq!(
1275            ConcreteDataType::int8_datatype(),
1276            ColumnDataTypeWrapper::int8_datatype().into()
1277        );
1278        assert_eq!(
1279            ConcreteDataType::int16_datatype(),
1280            ColumnDataTypeWrapper::int16_datatype().into()
1281        );
1282        assert_eq!(
1283            ConcreteDataType::int32_datatype(),
1284            ColumnDataTypeWrapper::int32_datatype().into()
1285        );
1286        assert_eq!(
1287            ConcreteDataType::int64_datatype(),
1288            ColumnDataTypeWrapper::int64_datatype().into()
1289        );
1290        assert_eq!(
1291            ConcreteDataType::uint8_datatype(),
1292            ColumnDataTypeWrapper::uint8_datatype().into()
1293        );
1294        assert_eq!(
1295            ConcreteDataType::uint16_datatype(),
1296            ColumnDataTypeWrapper::uint16_datatype().into()
1297        );
1298        assert_eq!(
1299            ConcreteDataType::uint32_datatype(),
1300            ColumnDataTypeWrapper::uint32_datatype().into()
1301        );
1302        assert_eq!(
1303            ConcreteDataType::uint64_datatype(),
1304            ColumnDataTypeWrapper::uint64_datatype().into()
1305        );
1306        assert_eq!(
1307            ConcreteDataType::float32_datatype(),
1308            ColumnDataTypeWrapper::float32_datatype().into()
1309        );
1310        assert_eq!(
1311            ConcreteDataType::float64_datatype(),
1312            ColumnDataTypeWrapper::float64_datatype().into()
1313        );
1314        assert_eq!(
1315            ConcreteDataType::binary_datatype(),
1316            ColumnDataTypeWrapper::binary_datatype().into()
1317        );
1318        assert_eq!(
1319            ConcreteDataType::string_datatype(),
1320            ColumnDataTypeWrapper::string_datatype().into()
1321        );
1322        assert_eq!(
1323            ConcreteDataType::date_datatype(),
1324            ColumnDataTypeWrapper::date_datatype().into()
1325        );
1326        assert_eq!(
1327            ConcreteDataType::timestamp_microsecond_datatype(),
1328            ColumnDataTypeWrapper::datetime_datatype().into()
1329        );
1330        assert_eq!(
1331            ConcreteDataType::timestamp_millisecond_datatype(),
1332            ColumnDataTypeWrapper::timestamp_millisecond_datatype().into()
1333        );
1334        assert_eq!(
1335            ConcreteDataType::time_datatype(TimeUnit::Millisecond),
1336            ColumnDataTypeWrapper::time_millisecond_datatype().into()
1337        );
1338        assert_eq!(
1339            ConcreteDataType::interval_datatype(IntervalUnit::DayTime),
1340            ColumnDataTypeWrapper::interval_day_time_datatype().into()
1341        );
1342        assert_eq!(
1343            ConcreteDataType::interval_datatype(IntervalUnit::YearMonth),
1344            ColumnDataTypeWrapper::interval_year_month_datatype().into()
1345        );
1346        assert_eq!(
1347            ConcreteDataType::interval_datatype(IntervalUnit::MonthDayNano),
1348            ColumnDataTypeWrapper::interval_month_day_nano_datatype().into()
1349        );
1350        assert_eq!(
1351            ConcreteDataType::decimal128_datatype(10, 2),
1352            ColumnDataTypeWrapper::decimal128_datatype(10, 2).into()
1353        );
1354        assert_eq!(
1355            ConcreteDataType::vector_datatype(3),
1356            ColumnDataTypeWrapper::vector_datatype(3).into()
1357        );
1358        assert_eq!(
1359            ConcreteDataType::list_datatype(Arc::new(ConcreteDataType::string_datatype())),
1360            ColumnDataTypeWrapper::list_datatype(ColumnDataTypeWrapper::string_datatype()).into()
1361        );
1362        assert_eq!(
1363            ConcreteDataType::dictionary_datatype(
1364                ConcreteDataType::int32_datatype(),
1365                ConcreteDataType::string_datatype()
1366            ),
1367            ColumnDataTypeWrapper::dictionary_datatype(
1368                ColumnDataTypeWrapper::int32_datatype(),
1369                ColumnDataTypeWrapper::string_datatype()
1370            )
1371            .into()
1372        );
1373        let struct_type = StructType::new(Arc::new(vec![
1374            StructField::new("id".to_string(), ConcreteDataType::int64_datatype(), true),
1375            StructField::new(
1376                "name".to_string(),
1377                ConcreteDataType::string_datatype(),
1378                true,
1379            ),
1380            StructField::new("age".to_string(), ConcreteDataType::int32_datatype(), true),
1381            StructField::new(
1382                "address".to_string(),
1383                ConcreteDataType::string_datatype(),
1384                true,
1385            ),
1386        ]));
1387        assert_eq!(
1388            ConcreteDataType::struct_datatype(struct_type.clone()),
1389            ColumnDataTypeWrapper::struct_datatype(vec![
1390                ("id".to_string(), ColumnDataTypeWrapper::int64_datatype()),
1391                ("name".to_string(), ColumnDataTypeWrapper::string_datatype()),
1392                ("age".to_string(), ColumnDataTypeWrapper::int32_datatype()),
1393                (
1394                    "address".to_string(),
1395                    ColumnDataTypeWrapper::string_datatype()
1396                )
1397            ])
1398            .into()
1399        );
1400        assert_eq!(
1401            ConcreteDataType::json2(JsonNativeType::Object(JsonObjectType::from([
1402                ("address".to_string(), JsonNativeType::String),
1403                ("age".to_string(), JsonNativeType::i64()),
1404                ("id".to_string(), JsonNativeType::i64()),
1405                ("name".to_string(), JsonNativeType::String),
1406            ]))),
1407            ColumnDataTypeWrapper::new(
1408                ColumnDataType::Json,
1409                Some(ColumnDataTypeExtension {
1410                    type_ext: Some(TypeExt::JsonNativeType(Box::new(JsonNativeTypeExtension {
1411                        datatype: ColumnDataType::Struct.into(),
1412                        datatype_extension: Some(Box::new(ColumnDataTypeExtension {
1413                            type_ext: Some(TypeExt::StructType(StructTypeExtension {
1414                                fields: vec![
1415                                    v1::StructField {
1416                                        name: "id".to_string(),
1417                                        datatype: ColumnDataTypeWrapper::int64_datatype()
1418                                            .datatype()
1419                                            .into(),
1420                                        datatype_extension: None
1421                                    },
1422                                    v1::StructField {
1423                                        name: "name".to_string(),
1424                                        datatype: ColumnDataTypeWrapper::string_datatype()
1425                                            .datatype()
1426                                            .into(),
1427                                        datatype_extension: None
1428                                    },
1429                                    v1::StructField {
1430                                        name: "age".to_string(),
1431                                        datatype: ColumnDataTypeWrapper::int32_datatype()
1432                                            .datatype()
1433                                            .into(),
1434                                        datatype_extension: None
1435                                    },
1436                                    v1::StructField {
1437                                        name: "address".to_string(),
1438                                        datatype: ColumnDataTypeWrapper::string_datatype()
1439                                            .datatype()
1440                                            .into(),
1441                                        datatype_extension: None
1442                                    }
1443                                ]
1444                            }))
1445                        }))
1446                    })))
1447                })
1448            )
1449            .into()
1450        )
1451    }
1452
1453    #[test]
1454    fn test_column_datatype_from_concrete_datatype() {
1455        assert_eq!(
1456            ColumnDataTypeWrapper::boolean_datatype(),
1457            ConcreteDataType::boolean_datatype().try_into().unwrap()
1458        );
1459        assert_eq!(
1460            ColumnDataTypeWrapper::int8_datatype(),
1461            ConcreteDataType::int8_datatype().try_into().unwrap()
1462        );
1463        assert_eq!(
1464            ColumnDataTypeWrapper::int16_datatype(),
1465            ConcreteDataType::int16_datatype().try_into().unwrap()
1466        );
1467        assert_eq!(
1468            ColumnDataTypeWrapper::int32_datatype(),
1469            ConcreteDataType::int32_datatype().try_into().unwrap()
1470        );
1471        assert_eq!(
1472            ColumnDataTypeWrapper::int64_datatype(),
1473            ConcreteDataType::int64_datatype().try_into().unwrap()
1474        );
1475        assert_eq!(
1476            ColumnDataTypeWrapper::uint8_datatype(),
1477            ConcreteDataType::uint8_datatype().try_into().unwrap()
1478        );
1479        assert_eq!(
1480            ColumnDataTypeWrapper::uint16_datatype(),
1481            ConcreteDataType::uint16_datatype().try_into().unwrap()
1482        );
1483        assert_eq!(
1484            ColumnDataTypeWrapper::uint32_datatype(),
1485            ConcreteDataType::uint32_datatype().try_into().unwrap()
1486        );
1487        assert_eq!(
1488            ColumnDataTypeWrapper::uint64_datatype(),
1489            ConcreteDataType::uint64_datatype().try_into().unwrap()
1490        );
1491        assert_eq!(
1492            ColumnDataTypeWrapper::float32_datatype(),
1493            ConcreteDataType::float32_datatype().try_into().unwrap()
1494        );
1495        assert_eq!(
1496            ColumnDataTypeWrapper::float64_datatype(),
1497            ConcreteDataType::float64_datatype().try_into().unwrap()
1498        );
1499        assert_eq!(
1500            ColumnDataTypeWrapper::binary_datatype(),
1501            ConcreteDataType::binary_datatype().try_into().unwrap()
1502        );
1503        assert_eq!(
1504            ColumnDataTypeWrapper::string_datatype(),
1505            ConcreteDataType::string_datatype().try_into().unwrap()
1506        );
1507        assert_eq!(
1508            ColumnDataTypeWrapper::date_datatype(),
1509            ConcreteDataType::date_datatype().try_into().unwrap()
1510        );
1511        assert_eq!(
1512            ColumnDataTypeWrapper::timestamp_millisecond_datatype(),
1513            ConcreteDataType::timestamp_millisecond_datatype()
1514                .try_into()
1515                .unwrap()
1516        );
1517        assert_eq!(
1518            ColumnDataTypeWrapper::interval_year_month_datatype(),
1519            ConcreteDataType::interval_datatype(IntervalUnit::YearMonth)
1520                .try_into()
1521                .unwrap()
1522        );
1523        assert_eq!(
1524            ColumnDataTypeWrapper::interval_day_time_datatype(),
1525            ConcreteDataType::interval_datatype(IntervalUnit::DayTime)
1526                .try_into()
1527                .unwrap()
1528        );
1529        assert_eq!(
1530            ColumnDataTypeWrapper::interval_month_day_nano_datatype(),
1531            ConcreteDataType::interval_datatype(IntervalUnit::MonthDayNano)
1532                .try_into()
1533                .unwrap()
1534        );
1535
1536        assert_eq!(
1537            ColumnDataTypeWrapper::decimal128_datatype(10, 2),
1538            ConcreteDataType::decimal128_datatype(10, 2)
1539                .try_into()
1540                .unwrap()
1541        );
1542        assert_eq!(
1543            ColumnDataTypeWrapper::vector_datatype(3),
1544            ConcreteDataType::vector_datatype(3).try_into().unwrap()
1545        );
1546        assert_eq!(
1547            ColumnDataTypeWrapper::dictionary_datatype(
1548                ColumnDataTypeWrapper::int32_datatype(),
1549                ColumnDataTypeWrapper::string_datatype()
1550            ),
1551            ConcreteDataType::dictionary_datatype(
1552                ConcreteDataType::int32_datatype(),
1553                ConcreteDataType::string_datatype()
1554            )
1555            .try_into()
1556            .unwrap()
1557        );
1558
1559        let result: Result<ColumnDataTypeWrapper> = ConcreteDataType::null_datatype().try_into();
1560        assert!(result.is_err());
1561        assert_eq!(
1562            result.unwrap_err().to_string(),
1563            "Failed to create column datatype from Null(NullType)"
1564        );
1565
1566        assert_eq!(
1567            ColumnDataTypeWrapper::list_datatype(ColumnDataTypeWrapper::int16_datatype()),
1568            ConcreteDataType::list_datatype(Arc::new(ConcreteDataType::int16_datatype()))
1569                .try_into()
1570                .expect("Failed to create column datatype from List(ListType { item_type: Int16(Int16Type) })")
1571        );
1572
1573        assert_eq!(
1574            ColumnDataTypeWrapper::struct_datatype(vec![
1575                ("a".to_string(), ColumnDataTypeWrapper::int64_datatype()),
1576                (
1577                    "a.a".to_string(),
1578                    ColumnDataTypeWrapper::list_datatype(ColumnDataTypeWrapper::string_datatype())
1579                )
1580            ]),
1581            ConcreteDataType::struct_datatype(StructType::new(Arc::new(vec![
1582                StructField::new("a".to_string(), ConcreteDataType::int64_datatype(), true),
1583                StructField::new(
1584                    "a.a".to_string(),
1585                    ConcreteDataType::list_datatype(Arc::new(ConcreteDataType::string_datatype())), true
1586                )
1587            ]))).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) }) }] })")
1588        );
1589
1590        assert_eq!(
1591            ColumnDataTypeWrapper::new(
1592                ColumnDataType::Json,
1593                Some(ColumnDataTypeExtension {
1594                    type_ext: Some(TypeExt::JsonNativeType(Box::new(JsonNativeTypeExtension {
1595                        datatype: ColumnDataType::Struct.into(),
1596                        datatype_extension: Some(Box::new(ColumnDataTypeExtension {
1597                            type_ext: Some(TypeExt::StructType(StructTypeExtension {
1598                                fields: vec![
1599                                    v1::StructField {
1600                                        name: "address".to_string(),
1601                                        datatype: ColumnDataTypeWrapper::string_datatype()
1602                                            .datatype()
1603                                            .into(),
1604                                        datatype_extension: None
1605                                    },
1606                                    v1::StructField {
1607                                        name: "age".to_string(),
1608                                        datatype: ColumnDataTypeWrapper::int64_datatype()
1609                                            .datatype()
1610                                            .into(),
1611                                        datatype_extension: None
1612                                    },
1613                                    v1::StructField {
1614                                        name: "id".to_string(),
1615                                        datatype: ColumnDataTypeWrapper::int64_datatype()
1616                                            .datatype()
1617                                            .into(),
1618                                        datatype_extension: None
1619                                    },
1620                                    v1::StructField {
1621                                        name: "name".to_string(),
1622                                        datatype: ColumnDataTypeWrapper::string_datatype()
1623                                            .datatype()
1624                                            .into(),
1625                                        datatype_extension: None
1626                                    },
1627                                ]
1628                            }))
1629                        }))
1630                    })))
1631                })
1632            ),
1633            ConcreteDataType::json2(JsonNativeType::Object(JsonObjectType::from([
1634                ("address".to_string(), JsonNativeType::String),
1635                ("age".to_string(), JsonNativeType::i64()),
1636                ("id".to_string(), JsonNativeType::i64()),
1637                ("name".to_string(), JsonNativeType::String),
1638            ])))
1639            .try_into()
1640            .expect("failed to convert json type")
1641        );
1642    }
1643
1644    #[test]
1645    fn test_convert_i128_to_interval() {
1646        let i128_val = 3;
1647        let interval = convert_month_day_nano_to_pb(IntervalMonthDayNano::from_i128(i128_val));
1648        assert_eq!(interval.months, 0);
1649        assert_eq!(interval.days, 0);
1650        assert_eq!(interval.nanoseconds, 3);
1651    }
1652
1653    #[test]
1654    fn test_vectors_to_rows_for_different_types() {
1655        let boolean_vec = BooleanVector::from_vec(vec![true, false, true]);
1656        let int8_vec = PrimitiveVector::<Int8Type>::from_iter_values(vec![1, 2, 3]);
1657        let int32_vec = PrimitiveVector::<Int32Type>::from_iter_values(vec![100, 200, 300]);
1658        let uint8_vec = PrimitiveVector::<UInt8Type>::from_iter_values(vec![10, 20, 30]);
1659        let uint32_vec = PrimitiveVector::<UInt32Type>::from_iter_values(vec![1000, 2000, 3000]);
1660        let float32_vec = Float32Vector::from_vec(vec![1.1, 2.2, 3.3]);
1661        let date_vec = DateVector::from_vec(vec![10, 20, 30]);
1662        let string_vec = StringVector::from_vec(vec!["a", "b", "c"]);
1663
1664        let vector_refs: Vec<VectorRef> = vec![
1665            Arc::new(boolean_vec),
1666            Arc::new(int8_vec),
1667            Arc::new(int32_vec),
1668            Arc::new(uint8_vec),
1669            Arc::new(uint32_vec),
1670            Arc::new(float32_vec),
1671            Arc::new(date_vec),
1672            Arc::new(string_vec),
1673        ];
1674
1675        let result = vectors_to_rows(vector_refs.iter(), 3);
1676
1677        assert_eq!(result.len(), 3);
1678
1679        assert_eq!(result[0].values.len(), 8);
1680        let values = result[0]
1681            .values
1682            .iter()
1683            .map(|v| v.value_data.clone().unwrap())
1684            .collect::<Vec<_>>();
1685        assert_eq!(values[0], ValueData::BoolValue(true));
1686        assert_eq!(values[1], ValueData::I8Value(1));
1687        assert_eq!(values[2], ValueData::I32Value(100));
1688        assert_eq!(values[3], ValueData::U8Value(10));
1689        assert_eq!(values[4], ValueData::U32Value(1000));
1690        assert_eq!(values[5], ValueData::F32Value(1.1));
1691        assert_eq!(values[6], ValueData::DateValue(10));
1692        assert_eq!(values[7], ValueData::StringValue("a".to_string()));
1693
1694        assert_eq!(result[1].values.len(), 8);
1695        let values = result[1]
1696            .values
1697            .iter()
1698            .map(|v| v.value_data.clone().unwrap())
1699            .collect::<Vec<_>>();
1700        assert_eq!(values[0], ValueData::BoolValue(false));
1701        assert_eq!(values[1], ValueData::I8Value(2));
1702        assert_eq!(values[2], ValueData::I32Value(200));
1703        assert_eq!(values[3], ValueData::U8Value(20));
1704        assert_eq!(values[4], ValueData::U32Value(2000));
1705        assert_eq!(values[5], ValueData::F32Value(2.2));
1706        assert_eq!(values[6], ValueData::DateValue(20));
1707        assert_eq!(values[7], ValueData::StringValue("b".to_string()));
1708
1709        assert_eq!(result[2].values.len(), 8);
1710        let values = result[2]
1711            .values
1712            .iter()
1713            .map(|v| v.value_data.clone().unwrap())
1714            .collect::<Vec<_>>();
1715        assert_eq!(values[0], ValueData::BoolValue(true));
1716        assert_eq!(values[1], ValueData::I8Value(3));
1717        assert_eq!(values[2], ValueData::I32Value(300));
1718        assert_eq!(values[3], ValueData::U8Value(30));
1719        assert_eq!(values[4], ValueData::U32Value(3000));
1720        assert_eq!(values[5], ValueData::F32Value(3.3));
1721        assert_eq!(values[6], ValueData::DateValue(30));
1722        assert_eq!(values[7], ValueData::StringValue("c".to_string()));
1723    }
1724
1725    #[test]
1726    fn test_is_column_type_value_eq() {
1727        // test column type eq
1728        let column1 = Column {
1729            column_name: "test".to_string(),
1730            semantic_type: 0,
1731            values: Some(Values {
1732                bool_values: vec![false, true, true],
1733                ..Default::default()
1734            }),
1735            null_mask: vec![2],
1736            datatype: ColumnDataType::Boolean as i32,
1737            datatype_extension: None,
1738            options: None,
1739        };
1740        assert!(is_column_type_value_eq(
1741            column1.datatype,
1742            column1.datatype_extension,
1743            &ConcreteDataType::boolean_datatype(),
1744        ));
1745    }
1746
1747    #[test]
1748    fn test_convert_to_pb_decimal128() {
1749        let decimal = Decimal128::new(123, 3, 1);
1750        let pb_decimal = convert_to_pb_decimal128(decimal);
1751        assert_eq!(pb_decimal.lo, 123);
1752        assert_eq!(pb_decimal.hi, 0);
1753    }
1754
1755    #[test]
1756    fn test_list_to_pb_value() {
1757        let value = Value::List(ListValue::new(
1758            vec![Value::Boolean(true)],
1759            Arc::new(ConcreteDataType::boolean_datatype()),
1760        ));
1761
1762        let pb_value = to_grpc_value(value);
1763
1764        match pb_value.value_data.unwrap() {
1765            ValueData::ListValue(pb_list_value) => {
1766                assert_eq!(pb_list_value.items.len(), 1);
1767            }
1768            _ => panic!("Unexpected value type"),
1769        }
1770    }
1771
1772    #[test]
1773    fn test_struct_to_pb_value() {
1774        let items = vec![Value::Boolean(true), Value::String("tom".into())];
1775
1776        let value = Value::Struct(
1777            StructValue::try_new(
1778                items,
1779                StructType::new(Arc::new(vec![
1780                    StructField::new(
1781                        "a.a".to_string(),
1782                        ConcreteDataType::boolean_datatype(),
1783                        true,
1784                    ),
1785                    StructField::new("a.b".to_string(), ConcreteDataType::string_datatype(), true),
1786                ])),
1787            )
1788            .unwrap(),
1789        );
1790
1791        let pb_value = to_grpc_value(value);
1792
1793        match pb_value.value_data.unwrap() {
1794            ValueData::StructValue(pb_struct_value) => {
1795                assert_eq!(pb_struct_value.items.len(), 2);
1796            }
1797            _ => panic!("Unexpected value type"),
1798        }
1799    }
1800
1801    #[test]
1802    fn test_encode_decode_json_value() {
1803        let json = JsonValue::null();
1804        let proto = encode_json_value(json.clone());
1805        assert!(proto.value.is_none());
1806        let value = decode_json_value(&proto);
1807        assert_eq!(json.as_ref(), value);
1808
1809        let json: JsonValue = true.into();
1810        let proto = encode_json_value(json.clone());
1811        assert_eq!(proto.value, Some(json_value::Value::Boolean(true)));
1812        let value = decode_json_value(&proto);
1813        assert_eq!(json.as_ref(), value);
1814
1815        let json: JsonValue = (-1i64).into();
1816        let proto = encode_json_value(json.clone());
1817        assert_eq!(proto.value, Some(json_value::Value::Int(-1)));
1818        let value = decode_json_value(&proto);
1819        assert_eq!(json.as_ref(), value);
1820
1821        let json: JsonValue = 1u64.into();
1822        let proto = encode_json_value(json.clone());
1823        assert_eq!(proto.value, Some(json_value::Value::Uint(1)));
1824        let value = decode_json_value(&proto);
1825        assert_eq!(json.as_ref(), value);
1826
1827        let json: JsonValue = 1.0f64.into();
1828        let proto = encode_json_value(json.clone());
1829        assert_eq!(proto.value, Some(json_value::Value::Float(1.0)));
1830        let value = decode_json_value(&proto);
1831        assert_eq!(json.as_ref(), value);
1832
1833        let json: JsonValue = "s".into();
1834        let proto = encode_json_value(json.clone());
1835        assert_eq!(proto.value, Some(json_value::Value::Str("s".to_string())));
1836        let value = decode_json_value(&proto);
1837        assert_eq!(json.as_ref(), value);
1838
1839        let json: JsonValue = [1i64, 2, 3].into();
1840        let proto = encode_json_value(json.clone());
1841        assert_eq!(
1842            proto.value,
1843            Some(json_value::Value::Array(JsonList {
1844                items: vec![
1845                    v1::JsonValue {
1846                        value: Some(json_value::Value::Int(1))
1847                    },
1848                    v1::JsonValue {
1849                        value: Some(json_value::Value::Int(2))
1850                    },
1851                    v1::JsonValue {
1852                        value: Some(json_value::Value::Int(3))
1853                    }
1854                ]
1855            }))
1856        );
1857        let value = decode_json_value(&proto);
1858        assert_eq!(json.as_ref(), value);
1859
1860        let json: JsonValue = [(); 0].into();
1861        let proto = encode_json_value(json.clone());
1862        assert_eq!(
1863            proto.value,
1864            Some(json_value::Value::Array(JsonList { items: vec![] }))
1865        );
1866        let value = decode_json_value(&proto);
1867        assert_eq!(json.as_ref(), value);
1868
1869        let json: JsonValue = [("k3", 3i64), ("k2", 2i64), ("k1", 1i64)].into();
1870        let proto = encode_json_value(json.clone());
1871        assert_eq!(
1872            proto.value,
1873            Some(json_value::Value::Object(JsonObject {
1874                entries: vec![
1875                    v1::json_object::Entry {
1876                        key: "k1".to_string(),
1877                        value: Some(v1::JsonValue {
1878                            value: Some(json_value::Value::Int(1))
1879                        }),
1880                    },
1881                    v1::json_object::Entry {
1882                        key: "k2".to_string(),
1883                        value: Some(v1::JsonValue {
1884                            value: Some(json_value::Value::Int(2))
1885                        }),
1886                    },
1887                    v1::json_object::Entry {
1888                        key: "k3".to_string(),
1889                        value: Some(v1::JsonValue {
1890                            value: Some(json_value::Value::Int(3))
1891                        }),
1892                    },
1893                ]
1894            }))
1895        );
1896        let value = decode_json_value(&proto);
1897        assert_eq!(json.as_ref(), value);
1898
1899        let json: JsonValue = [("null", ()); 0].into();
1900        let proto = encode_json_value(json.clone());
1901        assert_eq!(
1902            proto.value,
1903            Some(json_value::Value::Object(JsonObject { entries: vec![] }))
1904        );
1905        let value = decode_json_value(&proto);
1906        assert_eq!(json.as_ref(), value);
1907
1908        let json: JsonValue = [
1909            ("null", JsonVariant::from(())),
1910            ("bool", false.into()),
1911            ("list", ["hello", "world"].into()),
1912            (
1913                "object",
1914                [
1915                    ("positive_i", JsonVariant::from(42u64)),
1916                    ("negative_i", (-42i64).into()),
1917                    ("nested", [("what", "blah")].into()),
1918                ]
1919                .into(),
1920            ),
1921        ]
1922        .into();
1923        let proto = encode_json_value(json.clone());
1924        assert_eq!(
1925            proto.value,
1926            Some(json_value::Value::Object(JsonObject {
1927                entries: vec![
1928                    v1::json_object::Entry {
1929                        key: "bool".to_string(),
1930                        value: Some(v1::JsonValue {
1931                            value: Some(json_value::Value::Boolean(false))
1932                        }),
1933                    },
1934                    v1::json_object::Entry {
1935                        key: "list".to_string(),
1936                        value: Some(v1::JsonValue {
1937                            value: Some(json_value::Value::Array(JsonList {
1938                                items: vec![
1939                                    v1::JsonValue {
1940                                        value: Some(json_value::Value::Str("hello".to_string()))
1941                                    },
1942                                    v1::JsonValue {
1943                                        value: Some(json_value::Value::Str("world".to_string()))
1944                                    },
1945                                ]
1946                            }))
1947                        }),
1948                    },
1949                    v1::json_object::Entry {
1950                        key: "null".to_string(),
1951                        value: Some(v1::JsonValue { value: None }),
1952                    },
1953                    v1::json_object::Entry {
1954                        key: "object".to_string(),
1955                        value: Some(v1::JsonValue {
1956                            value: Some(json_value::Value::Object(JsonObject {
1957                                entries: vec![
1958                                    v1::json_object::Entry {
1959                                        key: "negative_i".to_string(),
1960                                        value: Some(v1::JsonValue {
1961                                            value: Some(json_value::Value::Int(-42))
1962                                        }),
1963                                    },
1964                                    v1::json_object::Entry {
1965                                        key: "nested".to_string(),
1966                                        value: Some(v1::JsonValue {
1967                                            value: Some(json_value::Value::Object(JsonObject {
1968                                                entries: vec![v1::json_object::Entry {
1969                                                    key: "what".to_string(),
1970                                                    value: Some(v1::JsonValue {
1971                                                        value: Some(json_value::Value::Str(
1972                                                            "blah".to_string()
1973                                                        ))
1974                                                    }),
1975                                                },]
1976                                            }))
1977                                        }),
1978                                    },
1979                                    v1::json_object::Entry {
1980                                        key: "positive_i".to_string(),
1981                                        value: Some(v1::JsonValue {
1982                                            value: Some(json_value::Value::Uint(42))
1983                                        }),
1984                                    },
1985                                ]
1986                            }))
1987                        }),
1988                    },
1989                ]
1990            }))
1991        );
1992        let value = decode_json_value(&proto);
1993        assert_eq!(json.as_ref(), value);
1994    }
1995}