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

api/
helper.rs
