datatypes/
data_type.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::fmt;
16use std::sync::Arc;
17
18use arrow::datatypes::{
19    DataType as ArrowDataType, IntervalUnit as ArrowIntervalUnit, TimeUnit as ArrowTimeUnit,
20};
21use arrow_schema::DECIMAL_DEFAULT_SCALE;
22use common_decimal::decimal128::DECIMAL128_MAX_PRECISION;
23use common_time::interval::IntervalUnit;
24use common_time::timestamp::TimeUnit;
25use enum_dispatch::enum_dispatch;
26use paste::paste;
27use serde::{Deserialize, Serialize};
28
29use crate::error::{self, Error, Result};
30use crate::type_id::LogicalTypeId;
31use crate::types::json_type::JsonNativeType;
32use crate::types::{
33    BinaryType, BooleanType, DateType, Decimal128Type, DictionaryType, DurationMicrosecondType,
34    DurationMillisecondType, DurationNanosecondType, DurationSecondType, DurationType, Float32Type,
35    Float64Type, Int8Type, Int16Type, Int32Type, Int64Type, IntervalDayTimeType,
36    IntervalMonthDayNanoType, IntervalType, IntervalYearMonthType, JsonType, ListType, NullType,
37    StringType, StructType, TimeMillisecondType, TimeType, TimestampMicrosecondType,
38    TimestampMillisecondType, TimestampNanosecondType, TimestampSecondType, TimestampType,
39    UInt8Type, UInt16Type, UInt32Type, UInt64Type, VectorType,
40};
41use crate::value::Value;
42use crate::vectors::MutableVector;
43
44#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
45#[enum_dispatch(DataType)]
46pub enum ConcreteDataType {
47    Null(NullType),
48    Boolean(BooleanType),
49
50    // Numeric types:
51    Int8(Int8Type),
52    Int16(Int16Type),
53    Int32(Int32Type),
54    Int64(Int64Type),
55    UInt8(UInt8Type),
56    UInt16(UInt16Type),
57    UInt32(UInt32Type),
58    UInt64(UInt64Type),
59    Float32(Float32Type),
60    Float64(Float64Type),
61
62    // Decimal128 type:
63    Decimal128(Decimal128Type),
64
65    // String types:
66    Binary(BinaryType),
67    String(StringType),
68
69    // Date and time types:
70    Date(DateType),
71    Timestamp(TimestampType),
72    Time(TimeType),
73
74    // Duration type:
75    Duration(DurationType),
76
77    // Interval type:
78    Interval(IntervalType),
79
80    // Compound types:
81    List(ListType),
82    Dictionary(DictionaryType),
83    Struct(StructType),
84
85    // JSON type:
86    Json(JsonType),
87
88    // Vector type:
89    Vector(VectorType),
90}
91
92impl fmt::Display for ConcreteDataType {
93    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
94        match self {
95            ConcreteDataType::Null(v) => write!(f, "{}", v.name()),
96            ConcreteDataType::Boolean(v) => write!(f, "{}", v.name()),
97            ConcreteDataType::Int8(v) => write!(f, "{}", v.name()),
98            ConcreteDataType::Int16(v) => write!(f, "{}", v.name()),
99            ConcreteDataType::Int32(v) => write!(f, "{}", v.name()),
100            ConcreteDataType::Int64(v) => write!(f, "{}", v.name()),
101            ConcreteDataType::UInt8(v) => write!(f, "{}", v.name()),
102            ConcreteDataType::UInt16(v) => write!(f, "{}", v.name()),
103            ConcreteDataType::UInt32(v) => write!(f, "{}", v.name()),
104            ConcreteDataType::UInt64(v) => write!(f, "{}", v.name()),
105            ConcreteDataType::Float32(v) => write!(f, "{}", v.name()),
106            ConcreteDataType::Float64(v) => write!(f, "{}", v.name()),
107            ConcreteDataType::Binary(v) => write!(f, "{}", v.name()),
108            ConcreteDataType::String(v) => write!(f, "{}", v.name()),
109            ConcreteDataType::Date(v) => write!(f, "{}", v.name()),
110            ConcreteDataType::Timestamp(t) => match t {
111                TimestampType::Second(v) => write!(f, "{}", v.name()),
112                TimestampType::Millisecond(v) => write!(f, "{}", v.name()),
113                TimestampType::Microsecond(v) => write!(f, "{}", v.name()),
114                TimestampType::Nanosecond(v) => write!(f, "{}", v.name()),
115            },
116            ConcreteDataType::Time(t) => match t {
117                TimeType::Second(v) => write!(f, "{}", v.name()),
118                TimeType::Millisecond(v) => write!(f, "{}", v.name()),
119                TimeType::Microsecond(v) => write!(f, "{}", v.name()),
120                TimeType::Nanosecond(v) => write!(f, "{}", v.name()),
121            },
122            ConcreteDataType::Interval(i) => match i {
123                IntervalType::YearMonth(v) => write!(f, "{}", v.name()),
124                IntervalType::DayTime(v) => write!(f, "{}", v.name()),
125                IntervalType::MonthDayNano(v) => write!(f, "{}", v.name()),
126            },
127            ConcreteDataType::Duration(d) => match d {
128                DurationType::Second(v) => write!(f, "{}", v.name()),
129                DurationType::Millisecond(v) => write!(f, "{}", v.name()),
130                DurationType::Microsecond(v) => write!(f, "{}", v.name()),
131                DurationType::Nanosecond(v) => write!(f, "{}", v.name()),
132            },
133            ConcreteDataType::Decimal128(v) => write!(f, "{}", v.name()),
134            ConcreteDataType::List(v) => write!(f, "{}", v.name()),
135            ConcreteDataType::Struct(v) => write!(f, "{}", v.name()),
136            ConcreteDataType::Dictionary(v) => write!(f, "{}", v.name()),
137            ConcreteDataType::Json(v) => write!(f, "{}", v.name()),
138            ConcreteDataType::Vector(v) => write!(f, "{}", v.name()),
139        }
140    }
141}
142
143// TODO(yingwen): Refactor these `is_xxx()` methods, such as adding a `properties()` method
144// returning all these properties to the `DataType` trait
145impl ConcreteDataType {
146    pub fn is_float(&self) -> bool {
147        matches!(
148            self,
149            ConcreteDataType::Float64(_) | ConcreteDataType::Float32(_)
150        )
151    }
152
153    pub fn is_boolean(&self) -> bool {
154        matches!(self, ConcreteDataType::Boolean(_))
155    }
156
157    pub fn is_string(&self) -> bool {
158        matches!(self, ConcreteDataType::String(_))
159    }
160
161    pub fn is_stringifiable(&self) -> bool {
162        matches!(
163            self,
164            ConcreteDataType::String(_)
165                | ConcreteDataType::Date(_)
166                | ConcreteDataType::Timestamp(_)
167                | ConcreteDataType::Time(_)
168                | ConcreteDataType::Interval(_)
169                | ConcreteDataType::Duration(_)
170                | ConcreteDataType::Decimal128(_)
171                | ConcreteDataType::Binary(_)
172                | ConcreteDataType::Json(_)
173                | ConcreteDataType::Vector(_)
174        )
175    }
176
177    pub fn is_signed(&self) -> bool {
178        matches!(
179            self,
180            ConcreteDataType::Int8(_)
181                | ConcreteDataType::Int16(_)
182                | ConcreteDataType::Int32(_)
183                | ConcreteDataType::Int64(_)
184                | ConcreteDataType::Date(_)
185                | ConcreteDataType::Timestamp(_)
186                | ConcreteDataType::Time(_)
187                | ConcreteDataType::Interval(_)
188                | ConcreteDataType::Duration(_)
189                | ConcreteDataType::Decimal128(_)
190        )
191    }
192
193    pub fn is_unsigned(&self) -> bool {
194        matches!(
195            self,
196            ConcreteDataType::UInt8(_)
197                | ConcreteDataType::UInt16(_)
198                | ConcreteDataType::UInt32(_)
199                | ConcreteDataType::UInt64(_)
200        )
201    }
202
203    pub fn is_numeric(&self) -> bool {
204        matches!(
205            self,
206            ConcreteDataType::Int8(_)
207                | ConcreteDataType::Int16(_)
208                | ConcreteDataType::Int32(_)
209                | ConcreteDataType::Int64(_)
210                | ConcreteDataType::UInt8(_)
211                | ConcreteDataType::UInt16(_)
212                | ConcreteDataType::UInt32(_)
213                | ConcreteDataType::UInt64(_)
214                | ConcreteDataType::Float32(_)
215                | ConcreteDataType::Float64(_)
216        )
217    }
218
219    pub fn is_timestamp(&self) -> bool {
220        matches!(self, ConcreteDataType::Timestamp(_))
221    }
222
223    pub fn is_decimal(&self) -> bool {
224        matches!(self, ConcreteDataType::Decimal128(_))
225    }
226
227    pub fn is_json(&self) -> bool {
228        matches!(self, ConcreteDataType::Json(_))
229    }
230
231    /// Returns whether this is a JSON2 data type.
232    pub fn is_json2(&self) -> bool {
233        self.as_json().is_some_and(|json_type| json_type.is_json2())
234    }
235
236    pub fn is_vector(&self) -> bool {
237        matches!(self, ConcreteDataType::Vector(_))
238    }
239
240    pub fn numerics() -> Vec<ConcreteDataType> {
241        vec![
242            ConcreteDataType::int8_datatype(),
243            ConcreteDataType::int16_datatype(),
244            ConcreteDataType::int32_datatype(),
245            ConcreteDataType::int64_datatype(),
246            ConcreteDataType::uint8_datatype(),
247            ConcreteDataType::uint16_datatype(),
248            ConcreteDataType::uint32_datatype(),
249            ConcreteDataType::uint64_datatype(),
250            ConcreteDataType::float32_datatype(),
251            ConcreteDataType::float64_datatype(),
252        ]
253    }
254
255    pub fn unsigned_integers() -> Vec<ConcreteDataType> {
256        vec![
257            ConcreteDataType::uint8_datatype(),
258            ConcreteDataType::uint16_datatype(),
259            ConcreteDataType::uint32_datatype(),
260            ConcreteDataType::uint64_datatype(),
261        ]
262    }
263
264    pub fn timestamps() -> Vec<ConcreteDataType> {
265        vec![
266            ConcreteDataType::timestamp_second_datatype(),
267            ConcreteDataType::timestamp_millisecond_datatype(),
268            ConcreteDataType::timestamp_microsecond_datatype(),
269            ConcreteDataType::timestamp_nanosecond_datatype(),
270        ]
271    }
272
273    /// Convert arrow data type to [ConcreteDataType].
274    ///
275    /// # Panics
276    /// Panic if given arrow data type is not supported.
277    pub fn from_arrow_type(dt: &ArrowDataType) -> Self {
278        ConcreteDataType::try_from(dt).expect("Unimplemented type")
279    }
280
281    pub fn is_null(&self) -> bool {
282        matches!(self, ConcreteDataType::Null(NullType))
283    }
284
285    /// Try to cast the type as a [`ListType`].
286    pub fn as_list(&self) -> Option<&ListType> {
287        match self {
288            ConcreteDataType::List(t) => Some(t),
289            _ => None,
290        }
291    }
292
293    pub fn as_struct(&self) -> Option<&StructType> {
294        match self {
295            ConcreteDataType::Struct(s) => Some(s),
296            _ => None,
297        }
298    }
299
300    /// Try to cast data type as a [`TimestampType`].
301    pub fn as_timestamp(&self) -> Option<TimestampType> {
302        match self {
303            ConcreteDataType::Timestamp(t) => Some(*t),
304            _ => None,
305        }
306    }
307
308    /// Try to get numeric precision, returns `None` if it's not numeric type
309    pub fn numeric_precision(&self) -> Option<u8> {
310        match self {
311            ConcreteDataType::Int8(_) | ConcreteDataType::UInt8(_) => Some(3),
312            ConcreteDataType::Int16(_) | ConcreteDataType::UInt16(_) => Some(5),
313            ConcreteDataType::Int32(_) | ConcreteDataType::UInt32(_) => Some(10),
314            ConcreteDataType::Int64(_) => Some(19),
315            ConcreteDataType::UInt64(_) => Some(20),
316            ConcreteDataType::Float32(_) => Some(12),
317            ConcreteDataType::Float64(_) => Some(22),
318            ConcreteDataType::Decimal128(decimal_type) => Some(decimal_type.precision()),
319            _ => None,
320        }
321    }
322
323    /// Try to get numeric scale, returns `None` if it's float or not numeric type
324    pub fn numeric_scale(&self) -> Option<i8> {
325        match self {
326            ConcreteDataType::Int8(_)
327            | ConcreteDataType::UInt8(_)
328            | ConcreteDataType::Int16(_)
329            | ConcreteDataType::UInt16(_)
330            | ConcreteDataType::Int32(_)
331            | ConcreteDataType::UInt32(_)
332            | ConcreteDataType::Int64(_)
333            | ConcreteDataType::UInt64(_) => Some(0),
334            ConcreteDataType::Float32(_) | ConcreteDataType::Float64(_) => None,
335            ConcreteDataType::Decimal128(decimal_type) => Some(decimal_type.scale()),
336            _ => None,
337        }
338    }
339
340    /// Try to cast data type as a [`TimeType`].
341    pub fn as_time(&self) -> Option<TimeType> {
342        match self {
343            ConcreteDataType::Int64(_) => Some(TimeType::Millisecond(TimeMillisecondType)),
344            ConcreteDataType::Time(t) => Some(*t),
345            _ => None,
346        }
347    }
348
349    pub fn as_decimal128(&self) -> Option<Decimal128Type> {
350        match self {
351            ConcreteDataType::Decimal128(d) => Some(*d),
352            _ => None,
353        }
354    }
355
356    pub fn as_json(&self) -> Option<&JsonType> {
357        match self {
358            ConcreteDataType::Json(j) => Some(j),
359            _ => None,
360        }
361    }
362
363    pub fn as_vector(&self) -> Option<VectorType> {
364        match self {
365            ConcreteDataType::Vector(v) => Some(*v),
366            _ => None,
367        }
368    }
369
370    /// Checks if the data type can cast to another data type.
371    pub fn can_arrow_type_cast_to(&self, to_type: &ConcreteDataType) -> bool {
372        match (self, to_type) {
373            (ConcreteDataType::Json(this), ConcreteDataType::Json(that)) => that.is_include(this),
374            _ => arrow::compute::can_cast_types(&self.as_arrow_type(), &to_type.as_arrow_type()),
375        }
376    }
377
378    /// Returns true if both types are timestamps and `to_type`'s unit is strictly
379    /// finer (e.g. `Second -> Millisecond`). Such a change is lossless for
380    /// values that fit the target unit's `i64` range; the narrowing direction
381    /// truncates values.
382    pub fn is_timestamp_unit_widening_to(&self, to_type: &ConcreteDataType) -> bool {
383        match (self.as_timestamp(), to_type.as_timestamp()) {
384            (Some(from), Some(to)) => to.unit() > from.unit(),
385            _ => false,
386        }
387    }
388
389    /// Try to cast data type as a [`DurationType`].
390    pub fn as_duration(&self) -> Option<DurationType> {
391        match self {
392            ConcreteDataType::Duration(d) => Some(*d),
393            _ => None,
394        }
395    }
396
397    /// Return the datatype name in postgres type system
398    pub fn postgres_datatype_name(&self) -> &'static str {
399        match self {
400            &ConcreteDataType::Null(_) => "UNKNOWN",
401            &ConcreteDataType::Boolean(_) => "BOOL",
402            &ConcreteDataType::Int8(_) | &ConcreteDataType::UInt8(_) => "CHAR",
403            &ConcreteDataType::Int16(_) | &ConcreteDataType::UInt16(_) => "INT2",
404            &ConcreteDataType::Int32(_) | &ConcreteDataType::UInt32(_) => "INT4",
405            &ConcreteDataType::Int64(_) | &ConcreteDataType::UInt64(_) => "INT8",
406            &ConcreteDataType::Float32(_) => "FLOAT4",
407            &ConcreteDataType::Float64(_) => "FLOAT8",
408            &ConcreteDataType::Binary(_) | &ConcreteDataType::Vector(_) => "BYTEA",
409            &ConcreteDataType::String(_) => "VARCHAR",
410            &ConcreteDataType::Date(_) => "DATE",
411            &ConcreteDataType::Timestamp(_) => "TIMESTAMP",
412            &ConcreteDataType::Time(_) => "TIME",
413            &ConcreteDataType::Interval(_) => "INTERVAL",
414            &ConcreteDataType::Decimal128(_) => "NUMERIC",
415            &ConcreteDataType::Json(_) => "JSON",
416            ConcreteDataType::List(list) => match list.item_type() {
417                &ConcreteDataType::Null(_) => "UNKNOWN",
418                &ConcreteDataType::Boolean(_) => "_BOOL",
419                &ConcreteDataType::Int8(_) | &ConcreteDataType::UInt8(_) => "_CHAR",
420                &ConcreteDataType::Int16(_) | &ConcreteDataType::UInt16(_) => "_INT2",
421                &ConcreteDataType::Int32(_) | &ConcreteDataType::UInt32(_) => "_INT4",
422                &ConcreteDataType::Int64(_) | &ConcreteDataType::UInt64(_) => "_INT8",
423                &ConcreteDataType::Float32(_) => "_FLOAT4",
424                &ConcreteDataType::Float64(_) => "_FLOAT8",
425                &ConcreteDataType::Binary(_) => "_BYTEA",
426                &ConcreteDataType::String(_) => "_VARCHAR",
427                &ConcreteDataType::Date(_) => "_DATE",
428                &ConcreteDataType::Timestamp(_) => "_TIMESTAMP",
429                &ConcreteDataType::Time(_) => "_TIME",
430                &ConcreteDataType::Interval(_) => "_INTERVAL",
431                &ConcreteDataType::Decimal128(_) => "_NUMERIC",
432                &ConcreteDataType::Json(_) => "_JSON",
433                &ConcreteDataType::Duration(_)
434                | &ConcreteDataType::Dictionary(_)
435                | &ConcreteDataType::Vector(_)
436                | &ConcreteDataType::List(_)
437                | &ConcreteDataType::Struct(_) => "UNKNOWN",
438            },
439            &ConcreteDataType::Duration(_)
440            | &ConcreteDataType::Dictionary(_)
441            | &ConcreteDataType::Struct(_) => "UNKNOWN",
442        }
443    }
444}
445
446impl From<&ConcreteDataType> for ConcreteDataType {
447    fn from(t: &ConcreteDataType) -> Self {
448        t.clone()
449    }
450}
451
452impl TryFrom<&ArrowDataType> for ConcreteDataType {
453    type Error = Error;
454
455    fn try_from(dt: &ArrowDataType) -> Result<ConcreteDataType> {
456        let concrete_type = match dt {
457            ArrowDataType::Null => Self::null_datatype(),
458            ArrowDataType::Boolean => Self::boolean_datatype(),
459            ArrowDataType::UInt8 => Self::uint8_datatype(),
460            ArrowDataType::UInt16 => Self::uint16_datatype(),
461            ArrowDataType::UInt32 => Self::uint32_datatype(),
462            ArrowDataType::UInt64 => Self::uint64_datatype(),
463            ArrowDataType::Int8 => Self::int8_datatype(),
464            ArrowDataType::Int16 => Self::int16_datatype(),
465            ArrowDataType::Int32 => Self::int32_datatype(),
466            ArrowDataType::Int64 => Self::int64_datatype(),
467            ArrowDataType::Float32 => Self::float32_datatype(),
468            ArrowDataType::Float64 => Self::float64_datatype(),
469            ArrowDataType::Date32 => Self::date_datatype(),
470            ArrowDataType::Timestamp(u, _) => ConcreteDataType::from_arrow_time_unit(u),
471            ArrowDataType::Interval(u) => ConcreteDataType::from_arrow_interval_unit(u),
472            ArrowDataType::Binary | ArrowDataType::LargeBinary => {
473                Self::Binary(BinaryType::binary())
474            }
475            ArrowDataType::BinaryView => Self::Binary(BinaryType::binary_view()),
476            ArrowDataType::Utf8 => Self::String(StringType::utf8()),
477            ArrowDataType::Utf8View => Self::String(StringType::utf8_view()),
478            ArrowDataType::LargeUtf8 => Self::String(StringType::large_utf8()),
479            ArrowDataType::List(field) => Self::List(ListType::new(Arc::new(
480                ConcreteDataType::from_arrow_type(field.data_type()),
481            ))),
482            ArrowDataType::Dictionary(key_type, value_type) => {
483                let key_type = ConcreteDataType::from_arrow_type(key_type);
484                let value_type = ConcreteDataType::from_arrow_type(value_type);
485                Self::Dictionary(DictionaryType::new(key_type, value_type))
486            }
487            ArrowDataType::Time32(u) => ConcreteDataType::Time(TimeType::from_unit(u.into())),
488            ArrowDataType::Time64(u) => ConcreteDataType::Time(TimeType::from_unit(u.into())),
489            ArrowDataType::Duration(u) => {
490                ConcreteDataType::Duration(DurationType::from_unit(u.into()))
491            }
492            ArrowDataType::Decimal128(precision, scale) => {
493                ConcreteDataType::decimal128_datatype(*precision, *scale)
494            }
495            ArrowDataType::Struct(fields) => ConcreteDataType::Struct(StructType::from(fields)),
496            ArrowDataType::Float16
497            | ArrowDataType::Date64
498            | ArrowDataType::FixedSizeBinary(_)
499            | ArrowDataType::ListView(_)
500            | ArrowDataType::FixedSizeList(_, _)
501            | ArrowDataType::LargeList(_)
502            | ArrowDataType::LargeListView(_)
503            | ArrowDataType::Union(_, _)
504            | ArrowDataType::Decimal256(_, _)
505            | ArrowDataType::Map(_, _)
506            | ArrowDataType::RunEndEncoded(_, _)
507            | ArrowDataType::Decimal32(_, _)
508            | ArrowDataType::Decimal64(_, _) => {
509                return error::UnsupportedArrowTypeSnafu {
510                    arrow_type: dt.clone(),
511                }
512                .fail();
513            }
514        };
515
516        Ok(concrete_type)
517    }
518}
519
520macro_rules! impl_new_concrete_type_functions {
521    ($($Type: ident), +) => {
522        paste! {
523            impl ConcreteDataType {
524                $(
525                    pub fn [<$Type:lower _datatype>]() -> ConcreteDataType {
526                        ConcreteDataType::$Type([<$Type Type>]::default())
527                    }
528                )+
529            }
530        }
531    }
532}
533
534impl_new_concrete_type_functions!(
535    Null, Boolean, UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64,
536    Binary, Date, String, Json
537);
538
539impl ConcreteDataType {
540    pub fn large_string_datatype() -> Self {
541        ConcreteDataType::String(StringType::large_utf8())
542    }
543
544    pub fn utf8_view_datatype() -> Self {
545        ConcreteDataType::String(StringType::utf8_view())
546    }
547
548    pub fn binary_view_datatype() -> Self {
549        ConcreteDataType::Binary(BinaryType::binary_view())
550    }
551
552    pub fn timestamp_second_datatype() -> Self {
553        ConcreteDataType::Timestamp(TimestampType::Second(TimestampSecondType))
554    }
555
556    pub fn timestamp_millisecond_datatype() -> Self {
557        ConcreteDataType::Timestamp(TimestampType::Millisecond(TimestampMillisecondType))
558    }
559
560    pub fn timestamp_microsecond_datatype() -> Self {
561        ConcreteDataType::Timestamp(TimestampType::Microsecond(TimestampMicrosecondType))
562    }
563
564    pub fn timestamp_nanosecond_datatype() -> Self {
565        ConcreteDataType::Timestamp(TimestampType::Nanosecond(TimestampNanosecondType))
566    }
567
568    /// Returns the time data type with `TimeUnit`.
569    pub fn time_datatype(unit: TimeUnit) -> Self {
570        ConcreteDataType::Time(TimeType::from_unit(unit))
571    }
572
573    /// Creates a [Time(TimeSecondType)] datatype.
574    pub fn time_second_datatype() -> Self {
575        Self::time_datatype(TimeUnit::Second)
576    }
577
578    /// Creates a [Time(TimeMillisecondType)] datatype.
579    pub fn time_millisecond_datatype() -> Self {
580        Self::time_datatype(TimeUnit::Millisecond)
581    }
582
583    /// Creates a [Time(TimeMicrosecond)] datatype.
584    pub fn time_microsecond_datatype() -> Self {
585        Self::time_datatype(TimeUnit::Microsecond)
586    }
587
588    /// Creates a [Time(TimeNanosecond)] datatype.
589    pub fn time_nanosecond_datatype() -> Self {
590        Self::time_datatype(TimeUnit::Nanosecond)
591    }
592
593    /// Creates a [Duration(DurationSecondType)] datatype.
594    pub fn duration_second_datatype() -> Self {
595        ConcreteDataType::Duration(DurationType::Second(DurationSecondType))
596    }
597
598    /// Creates a [Duration(DurationMillisecondType)] datatype.
599    pub fn duration_millisecond_datatype() -> Self {
600        ConcreteDataType::Duration(DurationType::Millisecond(DurationMillisecondType))
601    }
602
603    /// Creates a [Duration(DurationMicrosecondType)] datatype.
604    pub fn duration_microsecond_datatype() -> Self {
605        ConcreteDataType::Duration(DurationType::Microsecond(DurationMicrosecondType))
606    }
607
608    /// Creates a [Duration(DurationNanosecondType)] datatype.
609    pub fn duration_nanosecond_datatype() -> Self {
610        ConcreteDataType::Duration(DurationType::Nanosecond(DurationNanosecondType))
611    }
612
613    /// Creates a [Interval(IntervalMonthDayNanoType)] datatype.
614    pub fn interval_month_day_nano_datatype() -> Self {
615        ConcreteDataType::Interval(IntervalType::MonthDayNano(IntervalMonthDayNanoType))
616    }
617
618    /// Creates a [Interval(IntervalYearMonthType)] datatype.
619    pub fn interval_year_month_datatype() -> Self {
620        ConcreteDataType::Interval(IntervalType::YearMonth(IntervalYearMonthType))
621    }
622
623    /// Creates a [Interval(IntervalDayTimeType)] datatype.
624    pub fn interval_day_time_datatype() -> Self {
625        ConcreteDataType::Interval(IntervalType::DayTime(IntervalDayTimeType))
626    }
627
628    pub fn timestamp_datatype(unit: TimeUnit) -> Self {
629        match unit {
630            TimeUnit::Second => Self::timestamp_second_datatype(),
631            TimeUnit::Millisecond => Self::timestamp_millisecond_datatype(),
632            TimeUnit::Microsecond => Self::timestamp_microsecond_datatype(),
633            TimeUnit::Nanosecond => Self::timestamp_nanosecond_datatype(),
634        }
635    }
636
637    /// Converts from arrow timestamp unit to
638    pub fn from_arrow_time_unit(t: &ArrowTimeUnit) -> Self {
639        match t {
640            ArrowTimeUnit::Second => Self::timestamp_second_datatype(),
641            ArrowTimeUnit::Millisecond => Self::timestamp_millisecond_datatype(),
642            ArrowTimeUnit::Microsecond => Self::timestamp_microsecond_datatype(),
643            ArrowTimeUnit::Nanosecond => Self::timestamp_nanosecond_datatype(),
644        }
645    }
646
647    pub fn duration_datatype(unit: TimeUnit) -> Self {
648        match unit {
649            TimeUnit::Second => Self::duration_second_datatype(),
650            TimeUnit::Millisecond => Self::duration_millisecond_datatype(),
651            TimeUnit::Microsecond => Self::duration_microsecond_datatype(),
652            TimeUnit::Nanosecond => Self::duration_nanosecond_datatype(),
653        }
654    }
655
656    pub fn interval_datatype(unit: IntervalUnit) -> Self {
657        match unit {
658            IntervalUnit::YearMonth => Self::interval_year_month_datatype(),
659            IntervalUnit::DayTime => Self::interval_day_time_datatype(),
660            IntervalUnit::MonthDayNano => Self::interval_month_day_nano_datatype(),
661        }
662    }
663
664    pub fn from_arrow_interval_unit(u: &ArrowIntervalUnit) -> Self {
665        match u {
666            ArrowIntervalUnit::YearMonth => Self::interval_year_month_datatype(),
667            ArrowIntervalUnit::DayTime => Self::interval_day_time_datatype(),
668            ArrowIntervalUnit::MonthDayNano => Self::interval_month_day_nano_datatype(),
669        }
670    }
671
672    pub fn list_datatype(item_type: Arc<ConcreteDataType>) -> ConcreteDataType {
673        ConcreteDataType::List(ListType::new(item_type))
674    }
675
676    pub fn struct_datatype(fields: StructType) -> ConcreteDataType {
677        ConcreteDataType::Struct(fields)
678    }
679
680    pub fn dictionary_datatype(
681        key_type: ConcreteDataType,
682        value_type: ConcreteDataType,
683    ) -> ConcreteDataType {
684        ConcreteDataType::Dictionary(DictionaryType::new(key_type, value_type))
685    }
686
687    pub fn decimal128_datatype(precision: u8, scale: i8) -> ConcreteDataType {
688        ConcreteDataType::Decimal128(Decimal128Type::new(precision, scale))
689    }
690
691    pub fn decimal128_default_datatype() -> ConcreteDataType {
692        Self::decimal128_datatype(DECIMAL128_MAX_PRECISION, DECIMAL_DEFAULT_SCALE)
693    }
694
695    pub fn vector_datatype(dim: u32) -> ConcreteDataType {
696        ConcreteDataType::Vector(VectorType::new(dim))
697    }
698
699    pub fn vector_default_datatype() -> ConcreteDataType {
700        Self::vector_datatype(0)
701    }
702
703    pub fn json2(native_type: JsonNativeType) -> ConcreteDataType {
704        ConcreteDataType::Json(JsonType::json2(Arc::new(native_type)))
705    }
706}
707
708/// Data type abstraction.
709#[enum_dispatch::enum_dispatch]
710pub trait DataType: std::fmt::Debug + Send + Sync {
711    /// Name of this data type.
712    fn name(&self) -> String;
713
714    /// Returns id of the Logical data type.
715    fn logical_type_id(&self) -> LogicalTypeId;
716
717    /// Returns the default value of this type.
718    fn default_value(&self) -> Value;
719
720    /// Convert this type as [arrow::datatypes::DataType].
721    fn as_arrow_type(&self) -> ArrowDataType;
722
723    /// Creates a mutable vector with given `capacity` of this type.
724    fn create_mutable_vector(&self, capacity: usize) -> Box<dyn MutableVector>;
725
726    /// Casts the value to specific DataType.
727    /// Return None if cast failed.
728    fn try_cast(&self, from: Value) -> Option<Value>;
729}
730
731pub type DataTypeRef = Arc<dyn DataType>;
732
733#[cfg(test)]
734mod tests {
735    use arrow::datatypes::Field;
736
737    use super::*;
738
739    #[test]
740    fn test_is_timestamp_unit_widening_to() {
741        let second = ConcreteDataType::timestamp_second_datatype();
742        let milli = ConcreteDataType::timestamp_millisecond_datatype();
743        let nano = ConcreteDataType::timestamp_nanosecond_datatype();
744
745        assert!(second.is_timestamp_unit_widening_to(&milli));
746        assert!(second.is_timestamp_unit_widening_to(&nano));
747        // Same unit and narrowing are not widening.
748        assert!(!milli.is_timestamp_unit_widening_to(&milli));
749        assert!(!nano.is_timestamp_unit_widening_to(&milli));
750        // Either side being a non-timestamp type disqualifies.
751        assert!(!milli.is_timestamp_unit_widening_to(&ConcreteDataType::int64_datatype()));
752        assert!(!ConcreteDataType::int64_datatype().is_timestamp_unit_widening_to(&nano));
753    }
754
755    #[test]
756    fn test_concrete_type_as_datatype_trait() {
757        let concrete_type = ConcreteDataType::boolean_datatype();
758
759        assert_eq!("Boolean", concrete_type.to_string());
760        assert_eq!(Value::Boolean(false), concrete_type.default_value());
761        assert_eq!(LogicalTypeId::Boolean, concrete_type.logical_type_id());
762        assert_eq!(ArrowDataType::Boolean, concrete_type.as_arrow_type());
763    }
764
765    #[test]
766    fn test_from_arrow_type() {
767        assert!(matches!(
768            ConcreteDataType::from_arrow_type(&ArrowDataType::Null),
769            ConcreteDataType::Null(_)
770        ));
771        assert!(matches!(
772            ConcreteDataType::from_arrow_type(&ArrowDataType::Boolean),
773            ConcreteDataType::Boolean(_)
774        ));
775        assert!(matches!(
776            ConcreteDataType::from_arrow_type(&ArrowDataType::Binary),
777            ConcreteDataType::Binary(_)
778        ));
779        assert!(matches!(
780            ConcreteDataType::from_arrow_type(&ArrowDataType::LargeBinary),
781            ConcreteDataType::Binary(_)
782        ));
783        assert!(matches!(
784            ConcreteDataType::from_arrow_type(&ArrowDataType::Int8),
785            ConcreteDataType::Int8(_)
786        ));
787        assert!(matches!(
788            ConcreteDataType::from_arrow_type(&ArrowDataType::Int16),
789            ConcreteDataType::Int16(_)
790        ));
791        assert!(matches!(
792            ConcreteDataType::from_arrow_type(&ArrowDataType::Int32),
793            ConcreteDataType::Int32(_)
794        ));
795        assert!(matches!(
796            ConcreteDataType::from_arrow_type(&ArrowDataType::Int64),
797            ConcreteDataType::Int64(_)
798        ));
799        assert!(matches!(
800            ConcreteDataType::from_arrow_type(&ArrowDataType::UInt8),
801            ConcreteDataType::UInt8(_)
802        ));
803        assert!(matches!(
804            ConcreteDataType::from_arrow_type(&ArrowDataType::UInt16),
805            ConcreteDataType::UInt16(_)
806        ));
807        assert!(matches!(
808            ConcreteDataType::from_arrow_type(&ArrowDataType::UInt32),
809            ConcreteDataType::UInt32(_)
810        ));
811        assert!(matches!(
812            ConcreteDataType::from_arrow_type(&ArrowDataType::UInt64),
813            ConcreteDataType::UInt64(_)
814        ));
815        assert!(matches!(
816            ConcreteDataType::from_arrow_type(&ArrowDataType::Float32),
817            ConcreteDataType::Float32(_)
818        ));
819        assert!(matches!(
820            ConcreteDataType::from_arrow_type(&ArrowDataType::Float64),
821            ConcreteDataType::Float64(_)
822        ));
823        assert!(matches!(
824            ConcreteDataType::from_arrow_type(&ArrowDataType::Utf8),
825            ConcreteDataType::String(_)
826        ));
827        let utf8_view_string_type = ConcreteDataType::from_arrow_type(&ArrowDataType::Utf8View);
828        assert!(matches!(utf8_view_string_type, ConcreteDataType::String(_)));
829        assert_eq!(
830            ArrowDataType::Utf8View,
831            utf8_view_string_type.as_arrow_type()
832        );
833        // Test LargeUtf8 mapping to large String type
834        let large_string_type = ConcreteDataType::from_arrow_type(&ArrowDataType::LargeUtf8);
835        assert!(matches!(large_string_type, ConcreteDataType::String(_)));
836        if let ConcreteDataType::String(string_type) = &large_string_type {
837            assert!(string_type.is_large());
838        } else {
839            panic!("Expected a String type");
840        }
841        assert_eq!(
842            ConcreteDataType::from_arrow_type(&ArrowDataType::List(Arc::new(Field::new(
843                "item",
844                ArrowDataType::Int32,
845                true,
846            )))),
847            ConcreteDataType::List(ListType::new(Arc::new(ConcreteDataType::int32_datatype())))
848        );
849        assert!(matches!(
850            ConcreteDataType::from_arrow_type(&ArrowDataType::Date32),
851            ConcreteDataType::Date(_)
852        ));
853    }
854
855    #[test]
856    fn test_view_round_trip() {
857        let utf8_view_arrow = ArrowDataType::Utf8View;
858        let concrete_type = ConcreteDataType::from_arrow_type(&utf8_view_arrow);
859        let back_to_arrow = concrete_type.as_arrow_type();
860        assert_eq!(utf8_view_arrow, back_to_arrow);
861
862        let binary_view_arrow = ArrowDataType::BinaryView;
863        let concrete_type = ConcreteDataType::from_arrow_type(&binary_view_arrow);
864        let back_to_arrow = concrete_type.as_arrow_type();
865        assert_eq!(binary_view_arrow, back_to_arrow);
866    }
867
868    #[test]
869    fn test_large_utf8_round_trip() {
870        // Test round-trip conversion for LargeUtf8
871        let large_utf8_arrow = ArrowDataType::LargeUtf8;
872        let concrete_type = ConcreteDataType::from_arrow_type(&large_utf8_arrow);
873        let back_to_arrow = concrete_type.as_arrow_type();
874
875        assert!(matches!(concrete_type, ConcreteDataType::String(_)));
876        // Round-trip should preserve the LargeUtf8 type
877        assert_eq!(large_utf8_arrow, back_to_arrow);
878
879        // Test that Utf8 and LargeUtf8 map to different string variants
880        let utf8_concrete = ConcreteDataType::from_arrow_type(&ArrowDataType::Utf8);
881        let large_utf8_concrete = ConcreteDataType::from_arrow_type(&ArrowDataType::LargeUtf8);
882
883        assert!(matches!(utf8_concrete, ConcreteDataType::String(_)));
884        assert!(matches!(large_utf8_concrete, ConcreteDataType::String(_)));
885
886        // They should have different size types
887        if let (ConcreteDataType::String(utf8_type), ConcreteDataType::String(large_type)) =
888            (&utf8_concrete, &large_utf8_concrete)
889        {
890            assert!(!utf8_type.is_large());
891            assert!(large_type.is_large());
892        } else {
893            panic!("Expected both to be String types");
894        }
895
896        // View strings should be distinct from Utf8 and LargeUtf8.
897        let view_concrete = ConcreteDataType::from_arrow_type(&ArrowDataType::Utf8View);
898        assert_ne!(utf8_concrete, view_concrete);
899        assert_ne!(large_utf8_concrete, view_concrete);
900
901        // They should be different types
902        assert_ne!(utf8_concrete, large_utf8_concrete);
903    }
904
905    #[test]
906    fn test_from_arrow_timestamp() {
907        assert_eq!(
908            ConcreteDataType::timestamp_millisecond_datatype(),
909            ConcreteDataType::from_arrow_time_unit(&ArrowTimeUnit::Millisecond)
910        );
911        assert_eq!(
912            ConcreteDataType::timestamp_microsecond_datatype(),
913            ConcreteDataType::from_arrow_time_unit(&ArrowTimeUnit::Microsecond)
914        );
915        assert_eq!(
916            ConcreteDataType::timestamp_nanosecond_datatype(),
917            ConcreteDataType::from_arrow_time_unit(&ArrowTimeUnit::Nanosecond)
918        );
919        assert_eq!(
920            ConcreteDataType::timestamp_second_datatype(),
921            ConcreteDataType::from_arrow_time_unit(&ArrowTimeUnit::Second)
922        );
923    }
924
925    #[test]
926    fn test_is_null() {
927        assert!(ConcreteDataType::null_datatype().is_null());
928        assert!(!ConcreteDataType::int32_datatype().is_null());
929    }
930
931    #[test]
932    fn test_is_float() {
933        assert!(!ConcreteDataType::int32_datatype().is_float());
934        assert!(ConcreteDataType::float32_datatype().is_float());
935        assert!(ConcreteDataType::float64_datatype().is_float());
936    }
937
938    #[test]
939    fn test_is_boolean() {
940        assert!(!ConcreteDataType::int32_datatype().is_boolean());
941        assert!(!ConcreteDataType::float32_datatype().is_boolean());
942        assert!(ConcreteDataType::boolean_datatype().is_boolean());
943    }
944
945    #[test]
946    fn test_is_decimal() {
947        assert!(!ConcreteDataType::int32_datatype().is_decimal());
948        assert!(!ConcreteDataType::float32_datatype().is_decimal());
949        assert!(ConcreteDataType::decimal128_datatype(10, 2).is_decimal());
950        assert!(ConcreteDataType::decimal128_datatype(18, 6).is_decimal());
951    }
952
953    #[test]
954    fn test_is_stringifiable() {
955        assert!(!ConcreteDataType::int32_datatype().is_stringifiable());
956        assert!(!ConcreteDataType::float32_datatype().is_stringifiable());
957        assert!(ConcreteDataType::string_datatype().is_stringifiable());
958        assert!(ConcreteDataType::binary_datatype().is_stringifiable());
959        assert!(ConcreteDataType::date_datatype().is_stringifiable());
960        assert!(ConcreteDataType::timestamp_second_datatype().is_stringifiable());
961        assert!(ConcreteDataType::timestamp_millisecond_datatype().is_stringifiable());
962        assert!(ConcreteDataType::timestamp_microsecond_datatype().is_stringifiable());
963        assert!(ConcreteDataType::timestamp_nanosecond_datatype().is_stringifiable());
964        assert!(ConcreteDataType::time_second_datatype().is_stringifiable());
965        assert!(ConcreteDataType::time_millisecond_datatype().is_stringifiable());
966        assert!(ConcreteDataType::time_microsecond_datatype().is_stringifiable());
967        assert!(ConcreteDataType::time_nanosecond_datatype().is_stringifiable());
968
969        assert!(ConcreteDataType::interval_year_month_datatype().is_stringifiable());
970        assert!(ConcreteDataType::interval_day_time_datatype().is_stringifiable());
971        assert!(ConcreteDataType::interval_month_day_nano_datatype().is_stringifiable());
972
973        assert!(ConcreteDataType::duration_second_datatype().is_stringifiable());
974        assert!(ConcreteDataType::duration_millisecond_datatype().is_stringifiable());
975        assert!(ConcreteDataType::duration_microsecond_datatype().is_stringifiable());
976        assert!(ConcreteDataType::duration_nanosecond_datatype().is_stringifiable());
977        assert!(ConcreteDataType::decimal128_datatype(10, 2).is_stringifiable());
978        assert!(ConcreteDataType::vector_default_datatype().is_stringifiable());
979    }
980
981    #[test]
982    fn test_is_signed() {
983        assert!(ConcreteDataType::int8_datatype().is_signed());
984        assert!(ConcreteDataType::int16_datatype().is_signed());
985        assert!(ConcreteDataType::int32_datatype().is_signed());
986        assert!(ConcreteDataType::int64_datatype().is_signed());
987        assert!(ConcreteDataType::date_datatype().is_signed());
988        assert!(ConcreteDataType::timestamp_second_datatype().is_signed());
989        assert!(ConcreteDataType::timestamp_millisecond_datatype().is_signed());
990        assert!(ConcreteDataType::timestamp_microsecond_datatype().is_signed());
991        assert!(ConcreteDataType::timestamp_nanosecond_datatype().is_signed());
992        assert!(ConcreteDataType::time_second_datatype().is_signed());
993        assert!(ConcreteDataType::time_millisecond_datatype().is_signed());
994        assert!(ConcreteDataType::time_microsecond_datatype().is_signed());
995        assert!(ConcreteDataType::time_nanosecond_datatype().is_signed());
996        assert!(ConcreteDataType::interval_year_month_datatype().is_signed());
997        assert!(ConcreteDataType::interval_day_time_datatype().is_signed());
998        assert!(ConcreteDataType::interval_month_day_nano_datatype().is_signed());
999        assert!(ConcreteDataType::duration_second_datatype().is_signed());
1000        assert!(ConcreteDataType::duration_millisecond_datatype().is_signed());
1001        assert!(ConcreteDataType::duration_microsecond_datatype().is_signed());
1002        assert!(ConcreteDataType::duration_nanosecond_datatype().is_signed());
1003
1004        assert!(!ConcreteDataType::uint8_datatype().is_signed());
1005        assert!(!ConcreteDataType::uint16_datatype().is_signed());
1006        assert!(!ConcreteDataType::uint32_datatype().is_signed());
1007        assert!(!ConcreteDataType::uint64_datatype().is_signed());
1008
1009        assert!(!ConcreteDataType::float32_datatype().is_signed());
1010        assert!(!ConcreteDataType::float64_datatype().is_signed());
1011
1012        assert!(ConcreteDataType::decimal128_datatype(10, 2).is_signed());
1013    }
1014
1015    #[test]
1016    fn test_is_unsigned() {
1017        assert!(!ConcreteDataType::int8_datatype().is_unsigned());
1018        assert!(!ConcreteDataType::int16_datatype().is_unsigned());
1019        assert!(!ConcreteDataType::int32_datatype().is_unsigned());
1020        assert!(!ConcreteDataType::int64_datatype().is_unsigned());
1021        assert!(!ConcreteDataType::date_datatype().is_unsigned());
1022        assert!(!ConcreteDataType::timestamp_second_datatype().is_unsigned());
1023        assert!(!ConcreteDataType::timestamp_millisecond_datatype().is_unsigned());
1024        assert!(!ConcreteDataType::timestamp_microsecond_datatype().is_unsigned());
1025        assert!(!ConcreteDataType::timestamp_nanosecond_datatype().is_unsigned());
1026        assert!(!ConcreteDataType::time_second_datatype().is_unsigned());
1027        assert!(!ConcreteDataType::time_millisecond_datatype().is_unsigned());
1028        assert!(!ConcreteDataType::time_microsecond_datatype().is_unsigned());
1029        assert!(!ConcreteDataType::time_nanosecond_datatype().is_unsigned());
1030        assert!(!ConcreteDataType::interval_year_month_datatype().is_unsigned());
1031        assert!(!ConcreteDataType::interval_day_time_datatype().is_unsigned());
1032        assert!(!ConcreteDataType::interval_month_day_nano_datatype().is_unsigned());
1033        assert!(!ConcreteDataType::duration_second_datatype().is_unsigned());
1034        assert!(!ConcreteDataType::duration_millisecond_datatype().is_unsigned());
1035        assert!(!ConcreteDataType::duration_microsecond_datatype().is_unsigned());
1036        assert!(!ConcreteDataType::duration_nanosecond_datatype().is_unsigned());
1037        assert!(!ConcreteDataType::decimal128_datatype(10, 2).is_unsigned());
1038
1039        assert!(ConcreteDataType::uint8_datatype().is_unsigned());
1040        assert!(ConcreteDataType::uint16_datatype().is_unsigned());
1041        assert!(ConcreteDataType::uint32_datatype().is_unsigned());
1042        assert!(ConcreteDataType::uint64_datatype().is_unsigned());
1043
1044        assert!(!ConcreteDataType::float32_datatype().is_unsigned());
1045        assert!(!ConcreteDataType::float64_datatype().is_unsigned());
1046    }
1047
1048    #[test]
1049    fn test_numerics() {
1050        let nums = ConcreteDataType::numerics();
1051        assert_eq!(10, nums.len());
1052    }
1053
1054    #[test]
1055    fn test_as_list() {
1056        let list_type =
1057            ConcreteDataType::list_datatype(Arc::new(ConcreteDataType::int32_datatype()));
1058        assert_eq!(
1059            ListType::new(Arc::new(ConcreteDataType::int32_datatype())),
1060            *list_type.as_list().unwrap()
1061        );
1062        assert!(ConcreteDataType::int32_datatype().as_list().is_none());
1063    }
1064
1065    #[test]
1066    fn test_display_concrete_data_type() {
1067        assert_eq!(ConcreteDataType::null_datatype().to_string(), "Null");
1068        assert_eq!(ConcreteDataType::boolean_datatype().to_string(), "Boolean");
1069        assert_eq!(ConcreteDataType::binary_datatype().to_string(), "Binary");
1070        assert_eq!(ConcreteDataType::int8_datatype().to_string(), "Int8");
1071        assert_eq!(ConcreteDataType::int16_datatype().to_string(), "Int16");
1072        assert_eq!(ConcreteDataType::int32_datatype().to_string(), "Int32");
1073        assert_eq!(ConcreteDataType::int64_datatype().to_string(), "Int64");
1074        assert_eq!(ConcreteDataType::uint8_datatype().to_string(), "UInt8");
1075        assert_eq!(ConcreteDataType::uint16_datatype().to_string(), "UInt16");
1076        assert_eq!(ConcreteDataType::uint32_datatype().to_string(), "UInt32");
1077        assert_eq!(ConcreteDataType::uint64_datatype().to_string(), "UInt64");
1078        assert_eq!(ConcreteDataType::float32_datatype().to_string(), "Float32");
1079        assert_eq!(ConcreteDataType::float64_datatype().to_string(), "Float64");
1080        assert_eq!(ConcreteDataType::string_datatype().to_string(), "String");
1081        assert_eq!(ConcreteDataType::date_datatype().to_string(), "Date");
1082        assert_eq!(
1083            ConcreteDataType::timestamp_millisecond_datatype().to_string(),
1084            "TimestampMillisecond"
1085        );
1086        assert_eq!(
1087            ConcreteDataType::time_millisecond_datatype().to_string(),
1088            "TimeMillisecond"
1089        );
1090        assert_eq!(
1091            ConcreteDataType::interval_month_day_nano_datatype().to_string(),
1092            "IntervalMonthDayNano"
1093        );
1094        assert_eq!(
1095            ConcreteDataType::duration_second_datatype().to_string(),
1096            "DurationSecond"
1097        );
1098        assert_eq!(
1099            ConcreteDataType::decimal128_datatype(10, 2).to_string(),
1100            "Decimal(10, 2)"
1101        );
1102        // Nested types
1103        assert_eq!(
1104            ConcreteDataType::list_datatype(Arc::new(ConcreteDataType::int32_datatype()))
1105                .to_string(),
1106            "List<Int32>"
1107        );
1108        assert_eq!(
1109            ConcreteDataType::list_datatype(Arc::new(ConcreteDataType::Dictionary(
1110                DictionaryType::new(
1111                    ConcreteDataType::int32_datatype(),
1112                    ConcreteDataType::string_datatype()
1113                )
1114            )))
1115            .to_string(),
1116            "List<Dictionary<Int32, String>>"
1117        );
1118        assert_eq!(
1119            ConcreteDataType::list_datatype(Arc::new(ConcreteDataType::list_datatype(Arc::new(
1120                ConcreteDataType::list_datatype(Arc::new(ConcreteDataType::int32_datatype()))
1121            ))))
1122            .to_string(),
1123            "List<List<List<Int32>>>"
1124        );
1125        assert_eq!(
1126            ConcreteDataType::dictionary_datatype(
1127                ConcreteDataType::int32_datatype(),
1128                ConcreteDataType::string_datatype()
1129            )
1130            .to_string(),
1131            "Dictionary<Int32, String>"
1132        );
1133        assert_eq!(
1134            ConcreteDataType::vector_datatype(3).to_string(),
1135            "Vector(3)"
1136        );
1137    }
1138}
datatypes/data_type.rs

datatypes/
data_type.rs
