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

api/
helper.rs
