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

api/
helper.rs
