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::Native(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        None => "ddl.empty",
712    }
713}
714
715/// Converts an interval to google protobuf type [IntervalMonthDayNano].
716pub fn convert_month_day_nano_to_pb(v: IntervalMonthDayNano) -> v1::IntervalMonthDayNano {
717    v1::IntervalMonthDayNano {
718        months: v.months,
719        days: v.days,
720        nanoseconds: v.nanoseconds,
721    }
722}
723
724/// Convert common decimal128 to grpc decimal128 without precision and scale.
725pub fn convert_to_pb_decimal128(v: Decimal128) -> v1::Decimal128 {
726    let (hi, lo) = v.split_value();
727    v1::Decimal128 { hi, lo }
728}
729
730pub fn pb_value_to_value_ref<'a>(
731    value: &'a v1::Value,
732    datatype_ext: Option<&'a ColumnDataTypeExtension>,
733) -> ValueRef<'a> {
734    let Some(value) = &value.value_data else {
735        return ValueRef::Null;
736    };
737
738    match value {
739        ValueData::I8Value(v) => ValueRef::Int8(*v as i8),
740        ValueData::I16Value(v) => ValueRef::Int16(*v as i16),
741        ValueData::I32Value(v) => ValueRef::Int32(*v),
742        ValueData::I64Value(v) => ValueRef::Int64(*v),
743        ValueData::U8Value(v) => ValueRef::UInt8(*v as u8),
744        ValueData::U16Value(v) => ValueRef::UInt16(*v as u16),
745        ValueData::U32Value(v) => ValueRef::UInt32(*v),
746        ValueData::U64Value(v) => ValueRef::UInt64(*v),
747        ValueData::F32Value(f) => ValueRef::Float32(OrderedF32::from(*f)),
748        ValueData::F64Value(f) => ValueRef::Float64(OrderedF64::from(*f)),
749        ValueData::BoolValue(b) => ValueRef::Boolean(*b),
750        ValueData::BinaryValue(bytes) => ValueRef::Binary(bytes.as_slice()),
751        ValueData::StringValue(string) => ValueRef::String(string.as_str()),
752        ValueData::DateValue(d) => ValueRef::Date(Date::from(*d)),
753        ValueData::TimestampSecondValue(t) => ValueRef::Timestamp(Timestamp::new_second(*t)),
754        ValueData::TimestampMillisecondValue(t) => {
755            ValueRef::Timestamp(Timestamp::new_millisecond(*t))
756        }
757        ValueData::DatetimeValue(t) | ValueData::TimestampMicrosecondValue(t) => {
758            ValueRef::Timestamp(Timestamp::new_microsecond(*t))
759        }
760        ValueData::TimestampNanosecondValue(t) => {
761            ValueRef::Timestamp(Timestamp::new_nanosecond(*t))
762        }
763        ValueData::TimeSecondValue(t) => ValueRef::Time(Time::new_second(*t)),
764        ValueData::TimeMillisecondValue(t) => ValueRef::Time(Time::new_millisecond(*t)),
765        ValueData::TimeMicrosecondValue(t) => ValueRef::Time(Time::new_microsecond(*t)),
766        ValueData::TimeNanosecondValue(t) => ValueRef::Time(Time::new_nanosecond(*t)),
767        ValueData::IntervalYearMonthValue(v) => {
768            ValueRef::IntervalYearMonth(IntervalYearMonth::from_i32(*v))
769        }
770        ValueData::IntervalDayTimeValue(v) => {
771            ValueRef::IntervalDayTime(IntervalDayTime::from_i64(*v))
772        }
773        ValueData::IntervalMonthDayNanoValue(v) => {
774            let interval = IntervalMonthDayNano::new(v.months, v.days, v.nanoseconds);
775            ValueRef::IntervalMonthDayNano(interval)
776        }
777        ValueData::Decimal128Value(v) => {
778            // get precision and scale from datatype_extension
779            if let Some(TypeExt::DecimalType(d)) = datatype_ext
780                .as_ref()
781                .and_then(|column_ext| column_ext.type_ext.as_ref())
782            {
783                ValueRef::Decimal128(Decimal128::from_value_precision_scale(
784                    v.hi,
785                    v.lo,
786                    d.precision as u8,
787                    d.scale as i8,
788                ))
789            } else {
790                // If the precision and scale are not set, use the default value.
791                ValueRef::Decimal128(Decimal128::from_value_precision_scale(
792                    v.hi,
793                    v.lo,
794                    DECIMAL128_MAX_PRECISION,
795                    DECIMAL128_DEFAULT_SCALE,
796                ))
797            }
798        }
799        ValueData::ListValue(list) => {
800            let list_datatype_ext = datatype_ext
801                .as_ref()
802                .and_then(|ext| {
803                    if let Some(TypeExt::ListType(l)) = &ext.type_ext {
804                        Some(l)
805                    } else {
806                        None
807                    }
808                })
809                .expect("list must contain datatype ext");
810            let item_type = ConcreteDataType::from(ColumnDataTypeWrapper::new(
811                list_datatype_ext.datatype(),
812                list_datatype_ext
813                    .datatype_extension
814                    .as_ref()
815                    .map(|ext| *ext.clone()),
816            ));
817            let items = list
818                .items
819                .iter()
820                .map(|item| {
821                    pb_value_to_value_ref(item, list_datatype_ext.datatype_extension.as_deref())
822                })
823                .collect::<Vec<_>>();
824
825            let list_value = ListValueRef::RefList {
826                val: items,
827                item_datatype: Arc::new(item_type.clone()),
828            };
829            ValueRef::List(list_value)
830        }
831
832        ValueData::StructValue(struct_value) => {
833            let struct_datatype_ext = datatype_ext
834                .as_ref()
835                .and_then(|ext| {
836                    if let Some(TypeExt::StructType(s)) = &ext.type_ext {
837                        Some(s)
838                    } else {
839                        None
840                    }
841                })
842                .expect("struct must contain datatype ext");
843
844            let struct_fields = struct_datatype_ext
845                .fields
846                .iter()
847                .map(|field| {
848                    let field_type = ConcreteDataType::from(ColumnDataTypeWrapper::new(
849                        field.datatype(),
850                        field.datatype_extension.clone(),
851                    ));
852                    let field_name = field.name.clone();
853                    StructField::new(field_name, field_type, true)
854                })
855                .collect::<Vec<_>>();
856
857            let items = struct_value
858                .items
859                .iter()
860                .zip(struct_datatype_ext.fields.iter())
861                .map(|(item, field)| pb_value_to_value_ref(item, field.datatype_extension.as_ref()))
862                .collect::<Vec<ValueRef>>();
863
864            let struct_value_ref = StructValueRef::RefList {
865                val: items,
866                fields: StructType::new(Arc::new(struct_fields)),
867            };
868            ValueRef::Struct(struct_value_ref)
869        }
870
871        ValueData::JsonValue(inner_value) => {
872            let value = decode_json_value(inner_value);
873            ValueRef::Json(Box::new(value))
874        }
875    }
876}
877
878/// Returns true if the pb semantic type is valid.
879pub fn is_semantic_type_eq(type_value: i32, semantic_type: SemanticType) -> bool {
880    type_value == semantic_type as i32
881}
882
883/// Returns true if the pb type value is valid.
884pub fn is_column_type_value_eq(
885    type_value: i32,
886    type_extension: Option<ColumnDataTypeExtension>,
887    expect_type: &ConcreteDataType,
888) -> bool {
889    ColumnDataTypeWrapper::try_new(type_value, type_extension)
890        .map(|wrapper| {
891            let datatype = ConcreteDataType::from(wrapper);
892            expect_type == &datatype
893        })
894        .unwrap_or(false)
895}
896
897fn encode_json_value(value: JsonValue) -> v1::JsonValue {
898    fn helper(json: JsonVariant) -> v1::JsonValue {
899        let value = match json {
900            JsonVariant::Null => None,
901            JsonVariant::Bool(x) => Some(json_value::Value::Boolean(x)),
902            JsonVariant::Number(x) => Some(match x {
903                JsonNumber::PosInt(i) => json_value::Value::Uint(i),
904                JsonNumber::NegInt(i) => json_value::Value::Int(i),
905                JsonNumber::Float(f) => json_value::Value::Float(f.0),
906            }),
907            JsonVariant::String(x) => Some(json_value::Value::Str(x)),
908            JsonVariant::Array(x) => Some(json_value::Value::Array(JsonList {
909                items: x.into_iter().map(helper).collect::<Vec<_>>(),
910            })),
911            JsonVariant::Object(x) => {
912                let entries = x
913                    .into_iter()
914                    .map(|(key, v)| v1::json_object::Entry {
915                        key,
916                        value: Some(helper(v)),
917                    })
918                    .collect::<Vec<_>>();
919                Some(json_value::Value::Object(JsonObject { entries }))
920            }
921        };
922        v1::JsonValue { value }
923    }
924    helper(value.into_variant())
925}
926
927fn decode_json_value(value: &v1::JsonValue) -> JsonValueRef<'_> {
928    let Some(value) = &value.value else {
929        return JsonValueRef::null();
930    };
931    match value {
932        json_value::Value::Boolean(x) => (*x).into(),
933        json_value::Value::Int(x) => (*x).into(),
934        json_value::Value::Uint(x) => (*x).into(),
935        json_value::Value::Float(x) => (*x).into(),
936        json_value::Value::Str(x) => (x.as_str()).into(),
937        json_value::Value::Array(array) => array
938            .items
939            .iter()
940            .map(|x| decode_json_value(x).into_variant())
941            .collect::<Vec<_>>()
942            .into(),
943        json_value::Value::Object(x) => x
944            .entries
945            .iter()
946            .filter_map(|entry| {
947                entry
948                    .value
949                    .as_ref()
950                    .map(|v| (entry.key.as_str(), decode_json_value(v).into_variant()))
951            })
952            .collect::<BTreeMap<_, _>>()
953            .into(),
954    }
955}
956
957/// Returns the [ColumnDataTypeWrapper] of the value.
958///
959/// If value is null, returns `None`.
960pub fn proto_value_type(value: &v1::Value) -> Option<ColumnDataType> {
961    let value_type = match value.value_data.as_ref()? {
962        ValueData::I8Value(_) => ColumnDataType::Int8,
963        ValueData::I16Value(_) => ColumnDataType::Int16,
964        ValueData::I32Value(_) => ColumnDataType::Int32,
965        ValueData::I64Value(_) => ColumnDataType::Int64,
966        ValueData::U8Value(_) => ColumnDataType::Uint8,
967        ValueData::U16Value(_) => ColumnDataType::Uint16,
968        ValueData::U32Value(_) => ColumnDataType::Uint32,
969        ValueData::U64Value(_) => ColumnDataType::Uint64,
970        ValueData::F32Value(_) => ColumnDataType::Float32,
971        ValueData::F64Value(_) => ColumnDataType::Float64,
972        ValueData::BoolValue(_) => ColumnDataType::Boolean,
973        ValueData::BinaryValue(_) => ColumnDataType::Binary,
974        ValueData::StringValue(_) => ColumnDataType::String,
975        ValueData::DateValue(_) => ColumnDataType::Date,
976        ValueData::DatetimeValue(_) => ColumnDataType::Datetime,
977        ValueData::TimestampSecondValue(_) => ColumnDataType::TimestampSecond,
978        ValueData::TimestampMillisecondValue(_) => ColumnDataType::TimestampMillisecond,
979        ValueData::TimestampMicrosecondValue(_) => ColumnDataType::TimestampMicrosecond,
980        ValueData::TimestampNanosecondValue(_) => ColumnDataType::TimestampNanosecond,
981        ValueData::TimeSecondValue(_) => ColumnDataType::TimeSecond,
982        ValueData::TimeMillisecondValue(_) => ColumnDataType::TimeMillisecond,
983        ValueData::TimeMicrosecondValue(_) => ColumnDataType::TimeMicrosecond,
984        ValueData::TimeNanosecondValue(_) => ColumnDataType::TimeNanosecond,
985        ValueData::IntervalYearMonthValue(_) => ColumnDataType::IntervalYearMonth,
986        ValueData::IntervalDayTimeValue(_) => ColumnDataType::IntervalDayTime,
987        ValueData::IntervalMonthDayNanoValue(_) => ColumnDataType::IntervalMonthDayNano,
988        ValueData::Decimal128Value(_) => ColumnDataType::Decimal128,
989        ValueData::ListValue(_) => ColumnDataType::List,
990        ValueData::StructValue(_) => ColumnDataType::Struct,
991        ValueData::JsonValue(_) => ColumnDataType::Json,
992    };
993    Some(value_type)
994}
995
996pub fn vectors_to_rows<'a>(
997    columns: impl Iterator<Item = &'a VectorRef>,
998    row_count: usize,
999) -> Vec<Row> {
1000    let mut rows = vec![Row { values: vec![] }; row_count];
1001    for column in columns {
1002        for (row_index, row) in rows.iter_mut().enumerate() {
1003            row.values.push(to_grpc_value(column.get(row_index)))
1004        }
1005    }
1006
1007    rows
1008}
1009
1010pub fn to_grpc_value(value: Value) -> GrpcValue {
1011    GrpcValue {
1012        value_data: match value {
1013            Value::Null => None,
1014            Value::Boolean(v) => Some(ValueData::BoolValue(v)),
1015            Value::UInt8(v) => Some(ValueData::U8Value(v as _)),
1016            Value::UInt16(v) => Some(ValueData::U16Value(v as _)),
1017            Value::UInt32(v) => Some(ValueData::U32Value(v)),
1018            Value::UInt64(v) => Some(ValueData::U64Value(v)),
1019            Value::Int8(v) => Some(ValueData::I8Value(v as _)),
1020            Value::Int16(v) => Some(ValueData::I16Value(v as _)),
1021            Value::Int32(v) => Some(ValueData::I32Value(v)),
1022            Value::Int64(v) => Some(ValueData::I64Value(v)),
1023            Value::Float32(v) => Some(ValueData::F32Value(*v)),
1024            Value::Float64(v) => Some(ValueData::F64Value(*v)),
1025            Value::String(v) => Some(ValueData::StringValue(v.into_string())),
1026            Value::Binary(v) => Some(ValueData::BinaryValue(v.to_vec())),
1027            Value::Date(v) => Some(ValueData::DateValue(v.val())),
1028            Value::Timestamp(v) => Some(match v.unit() {
1029                TimeUnit::Second => ValueData::TimestampSecondValue(v.value()),
1030                TimeUnit::Millisecond => ValueData::TimestampMillisecondValue(v.value()),
1031                TimeUnit::Microsecond => ValueData::TimestampMicrosecondValue(v.value()),
1032                TimeUnit::Nanosecond => ValueData::TimestampNanosecondValue(v.value()),
1033            }),
1034            Value::Time(v) => Some(match v.unit() {
1035                TimeUnit::Second => ValueData::TimeSecondValue(v.value()),
1036                TimeUnit::Millisecond => ValueData::TimeMillisecondValue(v.value()),
1037                TimeUnit::Microsecond => ValueData::TimeMicrosecondValue(v.value()),
1038                TimeUnit::Nanosecond => ValueData::TimeNanosecondValue(v.value()),
1039            }),
1040            Value::IntervalYearMonth(v) => Some(ValueData::IntervalYearMonthValue(v.to_i32())),
1041            Value::IntervalDayTime(v) => Some(ValueData::IntervalDayTimeValue(v.to_i64())),
1042            Value::IntervalMonthDayNano(v) => Some(ValueData::IntervalMonthDayNanoValue(
1043                convert_month_day_nano_to_pb(v),
1044            )),
1045            Value::Decimal128(v) => Some(ValueData::Decimal128Value(convert_to_pb_decimal128(v))),
1046            Value::List(list_value) => {
1047                let items = list_value
1048                    .take_items()
1049                    .into_iter()
1050                    .map(to_grpc_value)
1051                    .collect();
1052                Some(ValueData::ListValue(v1::ListValue { items }))
1053            }
1054            Value::Struct(struct_value) => {
1055                let items = struct_value
1056                    .take_items()
1057                    .into_iter()
1058                    .map(to_grpc_value)
1059                    .collect();
1060                Some(ValueData::StructValue(v1::StructValue { items }))
1061            }
1062            Value::Json(v) => Some(ValueData::JsonValue(encode_json_value(*v))),
1063            Value::Duration(_) => unreachable!(),
1064        },
1065    }
1066}
1067
1068pub fn from_pb_time_unit(unit: v1::TimeUnit) -> TimeUnit {
1069    match unit {
1070        v1::TimeUnit::Second => TimeUnit::Second,
1071        v1::TimeUnit::Millisecond => TimeUnit::Millisecond,
1072        v1::TimeUnit::Microsecond => TimeUnit::Microsecond,
1073        v1::TimeUnit::Nanosecond => TimeUnit::Nanosecond,
1074    }
1075}
1076
1077pub fn to_pb_time_unit(unit: TimeUnit) -> v1::TimeUnit {
1078    match unit {
1079        TimeUnit::Second => v1::TimeUnit::Second,
1080        TimeUnit::Millisecond => v1::TimeUnit::Millisecond,
1081        TimeUnit::Microsecond => v1::TimeUnit::Microsecond,
1082        TimeUnit::Nanosecond => v1::TimeUnit::Nanosecond,
1083    }
1084}
1085
1086pub fn from_pb_time_ranges(time_ranges: v1::TimeRanges) -> Result<Vec<(Timestamp, Timestamp)>> {
1087    if time_ranges.time_ranges.is_empty() {
1088        return Ok(vec![]);
1089    }
1090    let proto_time_unit = v1::TimeUnit::try_from(time_ranges.time_unit).map_err(|_| {
1091        InvalidTimeUnitSnafu {
1092            time_unit: time_ranges.time_unit,
1093        }
1094        .build()
1095    })?;
1096    let time_unit = from_pb_time_unit(proto_time_unit);
1097    Ok(time_ranges
1098        .time_ranges
1099        .into_iter()
1100        .map(|r| {
1101            (
1102                Timestamp::new(r.start, time_unit),
1103                Timestamp::new(r.end, time_unit),
1104            )
1105        })
1106        .collect())
1107}
1108
1109/// All time_ranges must be of the same time unit.
1110///
1111/// if input `time_ranges` is empty, it will return a default `TimeRanges` with `Millisecond` as the time unit.
1112pub fn to_pb_time_ranges(time_ranges: &[(Timestamp, Timestamp)]) -> Result<v1::TimeRanges> {
1113    let is_same_time_unit = time_ranges.windows(2).all(|x| {
1114        x[0].0.unit() == x[1].0.unit()
1115            && x[0].1.unit() == x[1].1.unit()
1116            && x[0].0.unit() == x[0].1.unit()
1117    });
1118
1119    if !is_same_time_unit {
1120        let all_time_units: Vec<_> = time_ranges
1121            .iter()
1122            .map(|(s, e)| [s.unit(), e.unit()])
1123            .clone()
1124            .flatten()
1125            .collect::<HashSet<_>>()
1126            .into_iter()
1127            .collect();
1128        InconsistentTimeUnitSnafu {
1129            units: all_time_units,
1130        }
1131        .fail()?
1132    }
1133
1134    let mut pb_time_ranges = v1::TimeRanges {
1135        // default time unit is Millisecond
1136        time_unit: v1::TimeUnit::Millisecond as i32,
1137        time_ranges: Vec::with_capacity(time_ranges.len()),
1138    };
1139    if let Some((start, _end)) = time_ranges.first() {
1140        pb_time_ranges.time_unit = to_pb_time_unit(start.unit()) as i32;
1141    }
1142    for (start, end) in time_ranges {
1143        pb_time_ranges.time_ranges.push(v1::TimeRange {
1144            start: start.value(),
1145            end: end.value(),
1146        });
1147    }
1148    Ok(pb_time_ranges)
1149}
1150
1151#[cfg(test)]
1152mod tests {
1153    use std::sync::Arc;
1154
1155    use common_time::interval::IntervalUnit;
1156    use datatypes::scalars::ScalarVector;
1157    use datatypes::types::{Int8Type, Int32Type, UInt8Type, UInt32Type};
1158    use datatypes::value::{ListValue, StructValue};
1159    use datatypes::vectors::{
1160        BooleanVector, DateVector, Float32Vector, PrimitiveVector, StringVector,
1161    };
1162
1163    use super::*;
1164    use crate::v1::Column;
1165
1166    #[test]
1167    fn test_values_with_capacity() {
1168        let values = values_with_capacity(ColumnDataType::Int8, 2);
1169        let values = values.i8_values;
1170        assert_eq!(2, values.capacity());
1171
1172        let values = values_with_capacity(ColumnDataType::Int32, 2);
1173        let values = values.i32_values;
1174        assert_eq!(2, values.capacity());
1175
1176        let values = values_with_capacity(ColumnDataType::Int64, 2);
1177        let values = values.i64_values;
1178        assert_eq!(2, values.capacity());
1179
1180        let values = values_with_capacity(ColumnDataType::Uint8, 2);
1181        let values = values.u8_values;
1182        assert_eq!(2, values.capacity());
1183
1184        let values = values_with_capacity(ColumnDataType::Uint32, 2);
1185        let values = values.u32_values;
1186        assert_eq!(2, values.capacity());
1187
1188        let values = values_with_capacity(ColumnDataType::Uint64, 2);
1189        let values = values.u64_values;
1190        assert_eq!(2, values.capacity());
1191
1192        let values = values_with_capacity(ColumnDataType::Float32, 2);
1193        let values = values.f32_values;
1194        assert_eq!(2, values.capacity());
1195
1196        let values = values_with_capacity(ColumnDataType::Float64, 2);
1197        let values = values.f64_values;
1198        assert_eq!(2, values.capacity());
1199
1200        let values = values_with_capacity(ColumnDataType::Binary, 2);
1201        let values = values.binary_values;
1202        assert_eq!(2, values.capacity());
1203
1204        let values = values_with_capacity(ColumnDataType::Boolean, 2);
1205        let values = values.bool_values;
1206        assert_eq!(2, values.capacity());
1207
1208        let values = values_with_capacity(ColumnDataType::String, 2);
1209        let values = values.string_values;
1210        assert_eq!(2, values.capacity());
1211
1212        let values = values_with_capacity(ColumnDataType::Date, 2);
1213        let values = values.date_values;
1214        assert_eq!(2, values.capacity());
1215
1216        let values = values_with_capacity(ColumnDataType::Datetime, 2);
1217        let values = values.datetime_values;
1218        assert_eq!(2, values.capacity());
1219
1220        let values = values_with_capacity(ColumnDataType::TimestampMillisecond, 2);
1221        let values = values.timestamp_millisecond_values;
1222        assert_eq!(2, values.capacity());
1223
1224        let values = values_with_capacity(ColumnDataType::TimeMillisecond, 2);
1225        let values = values.time_millisecond_values;
1226        assert_eq!(2, values.capacity());
1227
1228        let values = values_with_capacity(ColumnDataType::IntervalDayTime, 2);
1229        let values = values.interval_day_time_values;
1230        assert_eq!(2, values.capacity());
1231
1232        let values = values_with_capacity(ColumnDataType::IntervalMonthDayNano, 2);
1233        let values = values.interval_month_day_nano_values;
1234        assert_eq!(2, values.capacity());
1235
1236        let values = values_with_capacity(ColumnDataType::Decimal128, 2);
1237        let values = values.decimal128_values;
1238        assert_eq!(2, values.capacity());
1239
1240        let values = values_with_capacity(ColumnDataType::Vector, 2);
1241        let values = values.binary_values;
1242        assert_eq!(2, values.capacity());
1243
1244        let values = values_with_capacity(ColumnDataType::List, 2);
1245        let values = values.list_values;
1246        assert_eq!(2, values.capacity());
1247
1248        let values = values_with_capacity(ColumnDataType::Struct, 2);
1249        let values = values.struct_values;
1250        assert_eq!(2, values.capacity());
1251
1252        let values = values_with_capacity(ColumnDataType::Json, 2);
1253        assert_eq!(2, values.json_values.capacity());
1254        assert_eq!(2, values.string_values.capacity());
1255
1256        let values = values_with_capacity(ColumnDataType::Dictionary, 2);
1257        assert!(values.bool_values.is_empty());
1258    }
1259
1260    #[test]
1261    fn test_concrete_datatype_from_column_datatype() {
1262        assert_eq!(
1263            ConcreteDataType::boolean_datatype(),
1264            ColumnDataTypeWrapper::boolean_datatype().into()
1265        );
1266        assert_eq!(
1267            ConcreteDataType::int8_datatype(),
1268            ColumnDataTypeWrapper::int8_datatype().into()
1269        );
1270        assert_eq!(
1271            ConcreteDataType::int16_datatype(),
1272            ColumnDataTypeWrapper::int16_datatype().into()
1273        );
1274        assert_eq!(
1275            ConcreteDataType::int32_datatype(),
1276            ColumnDataTypeWrapper::int32_datatype().into()
1277        );
1278        assert_eq!(
1279            ConcreteDataType::int64_datatype(),
1280            ColumnDataTypeWrapper::int64_datatype().into()
1281        );
1282        assert_eq!(
1283            ConcreteDataType::uint8_datatype(),
1284            ColumnDataTypeWrapper::uint8_datatype().into()
1285        );
1286        assert_eq!(
1287            ConcreteDataType::uint16_datatype(),
1288            ColumnDataTypeWrapper::uint16_datatype().into()
1289        );
1290        assert_eq!(
1291            ConcreteDataType::uint32_datatype(),
1292            ColumnDataTypeWrapper::uint32_datatype().into()
1293        );
1294        assert_eq!(
1295            ConcreteDataType::uint64_datatype(),
1296            ColumnDataTypeWrapper::uint64_datatype().into()
1297        );
1298        assert_eq!(
1299            ConcreteDataType::float32_datatype(),
1300            ColumnDataTypeWrapper::float32_datatype().into()
1301        );
1302        assert_eq!(
1303            ConcreteDataType::float64_datatype(),
1304            ColumnDataTypeWrapper::float64_datatype().into()
1305        );
1306        assert_eq!(
1307            ConcreteDataType::binary_datatype(),
1308            ColumnDataTypeWrapper::binary_datatype().into()
1309        );
1310        assert_eq!(
1311            ConcreteDataType::string_datatype(),
1312            ColumnDataTypeWrapper::string_datatype().into()
1313        );
1314        assert_eq!(
1315            ConcreteDataType::date_datatype(),
1316            ColumnDataTypeWrapper::date_datatype().into()
1317        );
1318        assert_eq!(
1319            ConcreteDataType::timestamp_microsecond_datatype(),
1320            ColumnDataTypeWrapper::datetime_datatype().into()
1321        );
1322        assert_eq!(
1323            ConcreteDataType::timestamp_millisecond_datatype(),
1324            ColumnDataTypeWrapper::timestamp_millisecond_datatype().into()
1325        );
1326        assert_eq!(
1327            ConcreteDataType::time_datatype(TimeUnit::Millisecond),
1328            ColumnDataTypeWrapper::time_millisecond_datatype().into()
1329        );
1330        assert_eq!(
1331            ConcreteDataType::interval_datatype(IntervalUnit::DayTime),
1332            ColumnDataTypeWrapper::interval_day_time_datatype().into()
1333        );
1334        assert_eq!(
1335            ConcreteDataType::interval_datatype(IntervalUnit::YearMonth),
1336            ColumnDataTypeWrapper::interval_year_month_datatype().into()
1337        );
1338        assert_eq!(
1339            ConcreteDataType::interval_datatype(IntervalUnit::MonthDayNano),
1340            ColumnDataTypeWrapper::interval_month_day_nano_datatype().into()
1341        );
1342        assert_eq!(
1343            ConcreteDataType::decimal128_datatype(10, 2),
1344            ColumnDataTypeWrapper::decimal128_datatype(10, 2).into()
1345        );
1346        assert_eq!(
1347            ConcreteDataType::vector_datatype(3),
1348            ColumnDataTypeWrapper::vector_datatype(3).into()
1349        );
1350        assert_eq!(
1351            ConcreteDataType::list_datatype(Arc::new(ConcreteDataType::string_datatype())),
1352            ColumnDataTypeWrapper::list_datatype(ColumnDataTypeWrapper::string_datatype()).into()
1353        );
1354        assert_eq!(
1355            ConcreteDataType::dictionary_datatype(
1356                ConcreteDataType::int32_datatype(),
1357                ConcreteDataType::string_datatype()
1358            ),
1359            ColumnDataTypeWrapper::dictionary_datatype(
1360                ColumnDataTypeWrapper::int32_datatype(),
1361                ColumnDataTypeWrapper::string_datatype()
1362            )
1363            .into()
1364        );
1365        let struct_type = StructType::new(Arc::new(vec![
1366            StructField::new("id".to_string(), ConcreteDataType::int64_datatype(), true),
1367            StructField::new(
1368                "name".to_string(),
1369                ConcreteDataType::string_datatype(),
1370                true,
1371            ),
1372            StructField::new("age".to_string(), ConcreteDataType::int32_datatype(), true),
1373            StructField::new(
1374                "address".to_string(),
1375                ConcreteDataType::string_datatype(),
1376                true,
1377            ),
1378        ]));
1379        assert_eq!(
1380            ConcreteDataType::struct_datatype(struct_type.clone()),
1381            ColumnDataTypeWrapper::struct_datatype(vec![
1382                ("id".to_string(), ColumnDataTypeWrapper::int64_datatype()),
1383                ("name".to_string(), ColumnDataTypeWrapper::string_datatype()),
1384                ("age".to_string(), ColumnDataTypeWrapper::int32_datatype()),
1385                (
1386                    "address".to_string(),
1387                    ColumnDataTypeWrapper::string_datatype()
1388                )
1389            ])
1390            .into()
1391        );
1392        assert_eq!(
1393            ConcreteDataType::json_native_datatype(ConcreteDataType::struct_datatype(
1394                struct_type.clone()
1395            )),
1396            ColumnDataTypeWrapper::new(
1397                ColumnDataType::Json,
1398                Some(ColumnDataTypeExtension {
1399                    type_ext: Some(TypeExt::JsonNativeType(Box::new(JsonNativeTypeExtension {
1400                        datatype: ColumnDataType::Struct.into(),
1401                        datatype_extension: Some(Box::new(ColumnDataTypeExtension {
1402                            type_ext: Some(TypeExt::StructType(StructTypeExtension {
1403                                fields: vec![
1404                                    v1::StructField {
1405                                        name: "id".to_string(),
1406                                        datatype: ColumnDataTypeWrapper::int64_datatype()
1407                                            .datatype()
1408                                            .into(),
1409                                        datatype_extension: None
1410                                    },
1411                                    v1::StructField {
1412                                        name: "name".to_string(),
1413                                        datatype: ColumnDataTypeWrapper::string_datatype()
1414                                            .datatype()
1415                                            .into(),
1416                                        datatype_extension: None
1417                                    },
1418                                    v1::StructField {
1419                                        name: "age".to_string(),
1420                                        datatype: ColumnDataTypeWrapper::int32_datatype()
1421                                            .datatype()
1422                                            .into(),
1423                                        datatype_extension: None
1424                                    },
1425                                    v1::StructField {
1426                                        name: "address".to_string(),
1427                                        datatype: ColumnDataTypeWrapper::string_datatype()
1428                                            .datatype()
1429                                            .into(),
1430                                        datatype_extension: None
1431                                    }
1432                                ]
1433                            }))
1434                        }))
1435                    })))
1436                })
1437            )
1438            .into()
1439        )
1440    }
1441
1442    #[test]
1443    fn test_column_datatype_from_concrete_datatype() {
1444        assert_eq!(
1445            ColumnDataTypeWrapper::boolean_datatype(),
1446            ConcreteDataType::boolean_datatype().try_into().unwrap()
1447        );
1448        assert_eq!(
1449            ColumnDataTypeWrapper::int8_datatype(),
1450            ConcreteDataType::int8_datatype().try_into().unwrap()
1451        );
1452        assert_eq!(
1453            ColumnDataTypeWrapper::int16_datatype(),
1454            ConcreteDataType::int16_datatype().try_into().unwrap()
1455        );
1456        assert_eq!(
1457            ColumnDataTypeWrapper::int32_datatype(),
1458            ConcreteDataType::int32_datatype().try_into().unwrap()
1459        );
1460        assert_eq!(
1461            ColumnDataTypeWrapper::int64_datatype(),
1462            ConcreteDataType::int64_datatype().try_into().unwrap()
1463        );
1464        assert_eq!(
1465            ColumnDataTypeWrapper::uint8_datatype(),
1466            ConcreteDataType::uint8_datatype().try_into().unwrap()
1467        );
1468        assert_eq!(
1469            ColumnDataTypeWrapper::uint16_datatype(),
1470            ConcreteDataType::uint16_datatype().try_into().unwrap()
1471        );
1472        assert_eq!(
1473            ColumnDataTypeWrapper::uint32_datatype(),
1474            ConcreteDataType::uint32_datatype().try_into().unwrap()
1475        );
1476        assert_eq!(
1477            ColumnDataTypeWrapper::uint64_datatype(),
1478            ConcreteDataType::uint64_datatype().try_into().unwrap()
1479        );
1480        assert_eq!(
1481            ColumnDataTypeWrapper::float32_datatype(),
1482            ConcreteDataType::float32_datatype().try_into().unwrap()
1483        );
1484        assert_eq!(
1485            ColumnDataTypeWrapper::float64_datatype(),
1486            ConcreteDataType::float64_datatype().try_into().unwrap()
1487        );
1488        assert_eq!(
1489            ColumnDataTypeWrapper::binary_datatype(),
1490            ConcreteDataType::binary_datatype().try_into().unwrap()
1491        );
1492        assert_eq!(
1493            ColumnDataTypeWrapper::string_datatype(),
1494            ConcreteDataType::string_datatype().try_into().unwrap()
1495        );
1496        assert_eq!(
1497            ColumnDataTypeWrapper::date_datatype(),
1498            ConcreteDataType::date_datatype().try_into().unwrap()
1499        );
1500        assert_eq!(
1501            ColumnDataTypeWrapper::timestamp_millisecond_datatype(),
1502            ConcreteDataType::timestamp_millisecond_datatype()
1503                .try_into()
1504                .unwrap()
1505        );
1506        assert_eq!(
1507            ColumnDataTypeWrapper::interval_year_month_datatype(),
1508            ConcreteDataType::interval_datatype(IntervalUnit::YearMonth)
1509                .try_into()
1510                .unwrap()
1511        );
1512        assert_eq!(
1513            ColumnDataTypeWrapper::interval_day_time_datatype(),
1514            ConcreteDataType::interval_datatype(IntervalUnit::DayTime)
1515                .try_into()
1516                .unwrap()
1517        );
1518        assert_eq!(
1519            ColumnDataTypeWrapper::interval_month_day_nano_datatype(),
1520            ConcreteDataType::interval_datatype(IntervalUnit::MonthDayNano)
1521                .try_into()
1522                .unwrap()
1523        );
1524
1525        assert_eq!(
1526            ColumnDataTypeWrapper::decimal128_datatype(10, 2),
1527            ConcreteDataType::decimal128_datatype(10, 2)
1528                .try_into()
1529                .unwrap()
1530        );
1531        assert_eq!(
1532            ColumnDataTypeWrapper::vector_datatype(3),
1533            ConcreteDataType::vector_datatype(3).try_into().unwrap()
1534        );
1535        assert_eq!(
1536            ColumnDataTypeWrapper::dictionary_datatype(
1537                ColumnDataTypeWrapper::int32_datatype(),
1538                ColumnDataTypeWrapper::string_datatype()
1539            ),
1540            ConcreteDataType::dictionary_datatype(
1541                ConcreteDataType::int32_datatype(),
1542                ConcreteDataType::string_datatype()
1543            )
1544            .try_into()
1545            .unwrap()
1546        );
1547
1548        let result: Result<ColumnDataTypeWrapper> = ConcreteDataType::null_datatype().try_into();
1549        assert!(result.is_err());
1550        assert_eq!(
1551            result.unwrap_err().to_string(),
1552            "Failed to create column datatype from Null(NullType)"
1553        );
1554
1555        assert_eq!(
1556            ColumnDataTypeWrapper::list_datatype(ColumnDataTypeWrapper::int16_datatype()),
1557            ConcreteDataType::list_datatype(Arc::new(ConcreteDataType::int16_datatype()))
1558                .try_into()
1559                .expect("Failed to create column datatype from List(ListType { item_type: Int16(Int16Type) })")
1560        );
1561
1562        assert_eq!(
1563            ColumnDataTypeWrapper::struct_datatype(vec![
1564                ("a".to_string(), ColumnDataTypeWrapper::int64_datatype()),
1565                (
1566                    "a.a".to_string(),
1567                    ColumnDataTypeWrapper::list_datatype(ColumnDataTypeWrapper::string_datatype())
1568                )
1569            ]),
1570            ConcreteDataType::struct_datatype(StructType::new(Arc::new(vec![
1571                StructField::new("a".to_string(), ConcreteDataType::int64_datatype(), true),
1572                StructField::new(
1573                    "a.a".to_string(),
1574                    ConcreteDataType::list_datatype(Arc::new(ConcreteDataType::string_datatype())), true
1575                )
1576            ]))).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) }) }] })")
1577        );
1578
1579        let struct_type = StructType::new(Arc::new(vec![
1580            StructField::new("id".to_string(), ConcreteDataType::int64_datatype(), true),
1581            StructField::new(
1582                "name".to_string(),
1583                ConcreteDataType::string_datatype(),
1584                true,
1585            ),
1586            StructField::new("age".to_string(), ConcreteDataType::int32_datatype(), true),
1587            StructField::new(
1588                "address".to_string(),
1589                ConcreteDataType::string_datatype(),
1590                true,
1591            ),
1592        ]));
1593        assert_eq!(
1594            ColumnDataTypeWrapper::new(
1595                ColumnDataType::Json,
1596                Some(ColumnDataTypeExtension {
1597                    type_ext: Some(TypeExt::JsonNativeType(Box::new(JsonNativeTypeExtension {
1598                        datatype: ColumnDataType::Struct.into(),
1599                        datatype_extension: Some(Box::new(ColumnDataTypeExtension {
1600                            type_ext: Some(TypeExt::StructType(StructTypeExtension {
1601                                fields: vec![
1602                                    v1::StructField {
1603                                        name: "address".to_string(),
1604                                        datatype: ColumnDataTypeWrapper::string_datatype()
1605                                            .datatype()
1606                                            .into(),
1607                                        datatype_extension: None
1608                                    },
1609                                    v1::StructField {
1610                                        name: "age".to_string(),
1611                                        datatype: ColumnDataTypeWrapper::int64_datatype()
1612                                            .datatype()
1613                                            .into(),
1614                                        datatype_extension: None
1615                                    },
1616                                    v1::StructField {
1617                                        name: "id".to_string(),
1618                                        datatype: ColumnDataTypeWrapper::int64_datatype()
1619                                            .datatype()
1620                                            .into(),
1621                                        datatype_extension: None
1622                                    },
1623                                    v1::StructField {
1624                                        name: "name".to_string(),
1625                                        datatype: ColumnDataTypeWrapper::string_datatype()
1626                                            .datatype()
1627                                            .into(),
1628                                        datatype_extension: None
1629                                    },
1630                                ]
1631                            }))
1632                        }))
1633                    })))
1634                })
1635            ),
1636            ConcreteDataType::json_native_datatype(ConcreteDataType::struct_datatype(
1637                struct_type.clone()
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}
api/helper.rs

api/
helper.rs
