Skip to main content

arrow_schema/
datatype_display.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: See the NOTICE file distributed with this work for additional information regarding copyright ownership
3// SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements
4
5use crate::DataType;
6use crate::Field;
7use crate::Metadata;
8use std::fmt;
9use std::fmt::Display;
10
11impl Display for DataType {
12    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13        fn format_metadata(metadata: &Metadata) -> String {
14            format!("{}", FormatMetadata(metadata))
15        }
16
17        fn format_nullability(field: &crate::Field) -> &str {
18            if field.is_nullable() { "" } else { "non-null " }
19        }
20
21        fn format_field(field: &crate::Field) -> String {
22            let name = field.name();
23            let maybe_nullable = format_nullability(field);
24            let data_type = field.data_type();
25            let metadata_str = format_metadata(field.metadata());
26            format!("{name:?}: {maybe_nullable}{data_type}{metadata_str}")
27        }
28
29        fn format_list_field_name(name: &str) -> String {
30            if name == "item" {
31                String::new()
32            } else {
33                let escaped: String = name.chars().flat_map(char::escape_debug).collect();
34                format!(", field: '{escaped}'")
35            }
36        }
37
38        // A lot of these can still be improved a lot.
39        // _Some_ of these can be parsed with `FromStr`, but not all (YET!).
40        // The goal is that the formatting should always be
41        // * Terse and teadable
42        // * Reversible (contain all necessary information to reverse it perfectly)
43
44        match &self {
45            Self::Null => write!(f, "Null"),
46            Self::Boolean => write!(f, "Boolean"),
47            Self::Int8 => write!(f, "Int8"),
48            Self::Int16 => write!(f, "Int16"),
49            Self::Int32 => write!(f, "Int32"),
50            Self::Int64 => write!(f, "Int64"),
51            Self::UInt8 => write!(f, "UInt8"),
52            Self::UInt16 => write!(f, "UInt16"),
53            Self::UInt32 => write!(f, "UInt32"),
54            Self::UInt64 => write!(f, "UInt64"),
55            Self::Float16 => write!(f, "Float16"),
56            Self::Float32 => write!(f, "Float32"),
57            Self::Float64 => write!(f, "Float64"),
58            Self::Timestamp(time_unit, timezone) => {
59                if let Some(timezone) = timezone {
60                    write!(f, "Timestamp({time_unit}, {timezone:?})")
61                } else {
62                    write!(f, "Timestamp({time_unit})")
63                }
64            }
65            Self::Date32 => write!(f, "Date32"),
66            Self::Date64 => write!(f, "Date64"),
67            Self::Time32(time_unit) => write!(f, "Time32({time_unit})"),
68            Self::Time64(time_unit) => write!(f, "Time64({time_unit})"),
69            Self::Duration(time_unit) => write!(f, "Duration({time_unit})"),
70            Self::Interval(interval_unit) => write!(f, "Interval({interval_unit:?})"),
71            Self::Binary => write!(f, "Binary"),
72            Self::FixedSizeBinary(bytes_per_value) => {
73                write!(f, "FixedSizeBinary({bytes_per_value:?})")
74            }
75            Self::LargeBinary => write!(f, "LargeBinary"),
76            Self::BinaryView => write!(f, "BinaryView"),
77            Self::Utf8 => write!(f, "Utf8"),
78            Self::LargeUtf8 => write!(f, "LargeUtf8"),
79            Self::Utf8View => write!(f, "Utf8View"),
80            Self::List(field)
81            | Self::LargeList(field)
82            | Self::ListView(field)
83            | Self::LargeListView(field) => {
84                let type_name = if matches!(self, Self::List(_)) {
85                    "List"
86                } else if matches!(self, Self::ListView(_)) {
87                    "ListView"
88                } else if matches!(self, Self::LargeList(_)) {
89                    "LargeList"
90                } else {
91                    "LargeListView"
92                };
93
94                let name = field.name();
95                let maybe_nullable = format_nullability(field);
96                let data_type = field.data_type();
97                let field_name_str = format_list_field_name(name);
98                let metadata_str = format_metadata(field.metadata());
99
100                // e.g. `LargeList(non-null Uint32)
101                write!(
102                    f,
103                    "{type_name}({maybe_nullable}{data_type}{field_name_str}{metadata_str})"
104                )
105            }
106            Self::FixedSizeList(field, size) => {
107                let name = field.name();
108                let maybe_nullable = format_nullability(field);
109                let data_type = field.data_type();
110                let field_name_str = format_list_field_name(name);
111                let metadata_str = format_metadata(field.metadata());
112
113                write!(
114                    f,
115                    "FixedSizeList({size} x {maybe_nullable}{data_type}{field_name_str}{metadata_str})",
116                )
117            }
118            Self::Struct(fields) => {
119                write!(f, "Struct(")?;
120                if !fields.is_empty() {
121                    let fields_str = fields
122                        .iter()
123                        .map(|field| format_field(field))
124                        .collect::<Vec<_>>()
125                        .join(", ");
126                    write!(f, "{fields_str}")?;
127                }
128                write!(f, ")")?;
129                Ok(())
130            }
131            Self::Union(union_fields, union_mode) => {
132                write!(f, "Union({union_mode:?}")?;
133                if !union_fields.is_empty() {
134                    write!(f, ", ")?;
135                    let fields_str = union_fields
136                        .iter()
137                        .map(|v| {
138                            let type_id = v.0;
139                            let field_str = format_field(v.1);
140                            format!("{type_id:?}: ({field_str})")
141                        })
142                        .collect::<Vec<_>>()
143                        .join(", ");
144                    write!(f, "{fields_str}")?;
145                }
146                write!(f, ")")?;
147                Ok(())
148            }
149            Self::Dictionary(data_type, data_type1) => {
150                write!(f, "Dictionary({data_type}, {data_type1})")
151            }
152            Self::Decimal32(precision, scale) => write!(f, "Decimal32({precision}, {scale})"),
153            Self::Decimal64(precision, scale) => write!(f, "Decimal64({precision}, {scale})"),
154            Self::Decimal128(precision, scale) => write!(f, "Decimal128({precision}, {scale})"),
155            Self::Decimal256(precision, scale) => write!(f, "Decimal256({precision}, {scale})"),
156            Self::Map(field, sorted) => {
157                write!(f, "Map(")?;
158                let map_field_str = format_field(field);
159                let keys_are_sorted = if *sorted { "sorted" } else { "unsorted" };
160
161                write!(f, "{map_field_str}, {keys_are_sorted})")?;
162                Ok(())
163            }
164            Self::RunEndEncoded(run_ends_field, values_field) => {
165                let default_names = run_ends_field.name() == Field::REE_RUN_ENDS_FIELD_DEFAULT_NAME
166                    && values_field.name() == Field::REE_VALUES_FIELD_DEFAULT_NAME;
167                let no_metadata =
168                    run_ends_field.metadata().is_empty() && values_field.metadata().is_empty();
169                write!(f, "RunEndEncoded(")?;
170                if default_names && no_metadata {
171                    let re_null = format_nullability(run_ends_field);
172                    let v_null = format_nullability(values_field);
173                    write!(
174                        f,
175                        "{re_null}{}, {v_null}{})",
176                        run_ends_field.data_type(),
177                        values_field.data_type(),
178                    )?;
179                } else {
180                    let run_ends_str = format_field(run_ends_field);
181                    let values_str = format_field(values_field);
182                    write!(f, "{run_ends_str}, {values_str})")?;
183                }
184                Ok(())
185            }
186        }
187    }
188}
189
190/// Adapter to format [`Metadata`] consistently.
191struct FormatMetadata<'a>(&'a Metadata);
192
193impl fmt::Display for FormatMetadata<'_> {
194    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
195        let metadata = self.0;
196        if metadata.is_empty() {
197            Ok(())
198        } else {
199            // `Metadata` iterates in sorted key order
200            write!(f, ", metadata: ")?;
201            f.debug_map().entries(metadata.iter()).finish()
202        }
203    }
204}
205
206#[cfg(test)]
207mod tests {
208
209    use std::collections::HashMap;
210    use std::sync::Arc;
211
212    use crate::Field;
213
214    use super::*;
215
216    #[test]
217    fn test_display_escaped_list_field_name() {
218        let field = Arc::new(Field::new("a'b\\c\"d\n", DataType::Int32, true));
219        let data_type = DataType::List(field);
220        assert_eq!(
221            data_type.to_string(),
222            r#"List(Int32, field: 'a\'b\\c\"d\n')"#
223        );
224    }
225
226    #[test]
227    fn test_display_list() {
228        let list_data_type = DataType::List(Arc::new(Field::new_list_field(DataType::Int32, true)));
229        let list_data_type_string = list_data_type.to_string();
230        let expected_string = "List(Int32)";
231        assert_eq!(list_data_type_string, expected_string);
232    }
233
234    #[test]
235    fn test_display_list_view() {
236        let list_view_data_type =
237            DataType::ListView(Arc::new(Field::new("item", DataType::Int32, true)));
238        let list_view_data_type_string = list_view_data_type.to_string();
239        let expected_string = "ListView(Int32)";
240        assert_eq!(list_view_data_type_string, expected_string);
241    }
242
243    #[test]
244    fn test_display_list_with_named_field() {
245        let list_data_type = DataType::List(Arc::new(Field::new("foo", DataType::UInt64, false)));
246        let list_data_type_string = list_data_type.to_string();
247        let expected_string = "List(non-null UInt64, field: 'foo')";
248        assert_eq!(list_data_type_string, expected_string);
249    }
250
251    #[test]
252    fn test_display_list_view_with_named_field() {
253        let list_view_data_type =
254            DataType::ListView(Arc::new(Field::new("bar", DataType::UInt64, false)));
255        let list_view_data_type_string = list_view_data_type.to_string();
256        let expected_string = "ListView(non-null UInt64, field: 'bar')";
257        assert_eq!(list_view_data_type_string, expected_string);
258    }
259
260    #[test]
261    fn test_display_nested_list() {
262        let nested_data_type = DataType::List(Arc::new(Field::new_list_field(
263            DataType::List(Arc::new(Field::new_list_field(DataType::UInt64, false))),
264            false,
265        )));
266        let nested_data_type_string = nested_data_type.to_string();
267        let nested_expected_string = "List(non-null List(non-null UInt64))";
268        assert_eq!(nested_data_type_string, nested_expected_string);
269    }
270
271    #[test]
272    fn test_display_nested_list_view() {
273        let nested_view_data_type = DataType::ListView(Arc::new(Field::new_list_field(
274            DataType::ListView(Arc::new(Field::new_list_field(DataType::UInt64, false))),
275            false,
276        )));
277        let nested_view_data_type_string = nested_view_data_type.to_string();
278        let nested_view_expected_string = "ListView(non-null ListView(non-null UInt64))";
279        assert_eq!(nested_view_data_type_string, nested_view_expected_string);
280    }
281
282    #[test]
283    fn test_display_list_with_metadata() {
284        let mut field = Field::new_list_field(DataType::Int32, true);
285        let metadata = HashMap::from([("foo1".to_string(), "value1".to_string())]);
286        field.set_metadata(metadata);
287        let list_data_type = DataType::List(Arc::new(field));
288        let list_data_type_string = list_data_type.to_string();
289        let expected_string = "List(Int32, metadata: {\"foo1\": \"value1\"})";
290
291        assert_eq!(list_data_type_string, expected_string);
292    }
293
294    #[test]
295    fn test_display_list_view_with_metadata() {
296        let mut field = Field::new_list_field(DataType::Int32, true);
297        let metadata = HashMap::from([("foo2".to_string(), "value2".to_string())]);
298        field.set_metadata(metadata);
299        let list_view_data_type = DataType::ListView(Arc::new(field));
300        let list_view_data_type_string = list_view_data_type.to_string();
301        let expected_string = "ListView(Int32, metadata: {\"foo2\": \"value2\"})";
302        assert_eq!(list_view_data_type_string, expected_string);
303    }
304
305    #[test]
306    fn test_display_large_list() {
307        let large_list_data_type =
308            DataType::LargeList(Arc::new(Field::new_list_field(DataType::Int32, true)));
309        let large_list_data_type_string = large_list_data_type.to_string();
310        let expected_string = "LargeList(Int32)";
311        assert_eq!(large_list_data_type_string, expected_string);
312
313        // Test with named field
314        let large_list_named =
315            DataType::LargeList(Arc::new(Field::new("bar", DataType::UInt64, false)));
316        let large_list_named_string = large_list_named.to_string();
317        let expected_named_string = "LargeList(non-null UInt64, field: 'bar')";
318        assert_eq!(large_list_named_string, expected_named_string);
319
320        // Test with metadata
321        let mut field = Field::new_list_field(DataType::Int32, true);
322        let metadata = HashMap::from([("key1".to_string(), "value1".to_string())]);
323        field.set_metadata(metadata);
324        let large_list_metadata = DataType::LargeList(Arc::new(field));
325        let large_list_metadata_string = large_list_metadata.to_string();
326        let expected_metadata_string = "LargeList(Int32, metadata: {\"key1\": \"value1\"})";
327        assert_eq!(large_list_metadata_string, expected_metadata_string);
328    }
329
330    #[test]
331    fn test_display_large_list_view() {
332        let large_list_view_data_type =
333            DataType::LargeListView(Arc::new(Field::new("item", DataType::Int32, true)));
334        let large_list_view_data_type_string = large_list_view_data_type.to_string();
335        let expected_string = "LargeListView(Int32)";
336        assert_eq!(large_list_view_data_type_string, expected_string);
337
338        // Test with named field
339        let large_list_view_named =
340            DataType::LargeListView(Arc::new(Field::new("bar", DataType::UInt64, false)));
341        let large_list_view_named_string = large_list_view_named.to_string();
342        let expected_named_string = "LargeListView(non-null UInt64, field: 'bar')";
343        assert_eq!(large_list_view_named_string, expected_named_string);
344
345        // Test with metadata
346        let mut field = Field::new_list_field(DataType::Int32, true);
347        let metadata = HashMap::from([("key1".to_string(), "value1".to_string())]);
348        field.set_metadata(metadata);
349        let large_list_view_metadata = DataType::LargeListView(Arc::new(field));
350        let large_list_view_metadata_string = large_list_view_metadata.to_string();
351        let expected_metadata_string = "LargeListView(Int32, metadata: {\"key1\": \"value1\"})";
352        assert_eq!(large_list_view_metadata_string, expected_metadata_string);
353    }
354
355    #[test]
356    fn test_display_fixed_size_list() {
357        let fixed_size_list =
358            DataType::FixedSizeList(Arc::new(Field::new_list_field(DataType::Int32, true)), 5);
359        let fixed_size_list_string = fixed_size_list.to_string();
360        let expected_string = "FixedSizeList(5 x Int32)";
361        assert_eq!(fixed_size_list_string, expected_string);
362
363        // Test with named field
364        let fixed_size_named =
365            DataType::FixedSizeList(Arc::new(Field::new("baz", DataType::UInt64, false)), 3);
366        let fixed_size_named_string = fixed_size_named.to_string();
367        let expected_named_string = "FixedSizeList(3 x non-null UInt64, field: 'baz')";
368        assert_eq!(fixed_size_named_string, expected_named_string);
369
370        // Test with metadata
371        let mut field = Field::new_list_field(DataType::Int32, true);
372        let metadata = HashMap::from([("key2".to_string(), "value2".to_string())]);
373        field.set_metadata(metadata);
374        let fixed_size_metadata = DataType::FixedSizeList(Arc::new(field), 4);
375        let fixed_size_metadata_string = fixed_size_metadata.to_string();
376        let expected_metadata_string = "FixedSizeList(4 x Int32, metadata: {\"key2\": \"value2\"})";
377        assert_eq!(fixed_size_metadata_string, expected_metadata_string);
378    }
379
380    #[test]
381    fn test_display_struct() {
382        let fields = vec![
383            Field::new("a", DataType::Int32, false),
384            Field::new("b", DataType::Utf8, true),
385        ];
386        let struct_data_type = DataType::Struct(fields.into());
387        let struct_data_type_string = struct_data_type.to_string();
388        let expected_string = "Struct(\"a\": non-null Int32, \"b\": Utf8)";
389        assert_eq!(struct_data_type_string, expected_string);
390
391        // Test with metadata
392        let mut field_with_metadata = Field::new("b", DataType::Utf8, true);
393        let metadata = HashMap::from([
394            ("key".to_string(), "value".to_string()),
395            ("key2".to_string(), "value2".to_string()),
396        ]);
397        field_with_metadata.set_metadata(metadata);
398        let struct_fields_with_metadata =
399            vec![Field::new("a", DataType::Int32, false), field_with_metadata];
400        let struct_data_type_with_metadata = DataType::Struct(struct_fields_with_metadata.into());
401        let struct_data_type_with_metadata_string = struct_data_type_with_metadata.to_string();
402        let expected_string_with_metadata = "Struct(\"a\": non-null Int32, \"b\": Utf8, metadata: {\"key\": \"value\", \"key2\": \"value2\"})";
403        assert_eq!(
404            struct_data_type_with_metadata_string,
405            expected_string_with_metadata
406        );
407    }
408
409    #[test]
410    fn test_display_union() {
411        let fields = vec![
412            Field::new("a", DataType::Int32, false),
413            Field::new("b", DataType::Utf8, true),
414        ];
415        let type_ids = vec![0, 1];
416        let union_fields = type_ids
417            .into_iter()
418            .zip(fields.into_iter().map(Arc::new))
419            .collect();
420
421        let union_data_type = DataType::Union(union_fields, crate::UnionMode::Sparse);
422        let union_data_type_string = union_data_type.to_string();
423        let expected_string = "Union(Sparse, 0: (\"a\": non-null Int32), 1: (\"b\": Utf8))";
424        assert_eq!(union_data_type_string, expected_string);
425
426        // Test with metadata
427        let mut field_with_metadata = Field::new("b", DataType::Utf8, true);
428        let metadata = HashMap::from([("key".to_string(), "value".to_string())]);
429        field_with_metadata.set_metadata(metadata);
430        let union_fields_with_metadata = vec![
431            (0, Arc::new(Field::new("a", DataType::Int32, false))),
432            (1, Arc::new(field_with_metadata)),
433        ]
434        .into_iter()
435        .collect();
436        let union_data_type_with_metadata =
437            DataType::Union(union_fields_with_metadata, crate::UnionMode::Sparse);
438        let union_data_type_with_metadata_string = union_data_type_with_metadata.to_string();
439        let expected_string_with_metadata = "Union(Sparse, 0: (\"a\": non-null Int32), 1: (\"b\": Utf8, metadata: {\"key\": \"value\"}))";
440        assert_eq!(
441            union_data_type_with_metadata_string,
442            expected_string_with_metadata
443        );
444    }
445
446    #[test]
447    fn test_display_map() {
448        let entry_field = Field::new(
449            Field::MAP_ENTRIES_FIELD_DEFAULT_NAME,
450            DataType::Struct(
451                vec![
452                    Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false),
453                    Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true),
454                ]
455                .into(),
456            ),
457            false,
458        );
459        let map_data_type = DataType::Map(Arc::new(entry_field), true);
460        let map_data_type_string = map_data_type.to_string();
461        let expected_string =
462            "Map(\"entries\": non-null Struct(\"key\": non-null Utf8, \"value\": Int32), sorted)";
463        assert_eq!(map_data_type_string, expected_string);
464
465        // Test with metadata
466        let mut entry_field_with_metadata = Field::new(
467            Field::MAP_ENTRIES_FIELD_DEFAULT_NAME,
468            DataType::Struct(
469                vec![
470                    Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false),
471                    Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true),
472                ]
473                .into(),
474            ),
475            false,
476        );
477        let metadata = HashMap::from([("key".to_string(), "value".to_string())]);
478        entry_field_with_metadata.set_metadata(metadata);
479        let map_data_type_with_metadata = DataType::Map(Arc::new(entry_field_with_metadata), true);
480        let map_data_type_with_metadata_string = map_data_type_with_metadata.to_string();
481        let expected_string_with_metadata = "Map(\"entries\": non-null Struct(\"key\": non-null Utf8, \"value\": Int32), metadata: {\"key\": \"value\"}, sorted)";
482        assert_eq!(
483            map_data_type_with_metadata_string,
484            expected_string_with_metadata
485        );
486    }
487
488    #[test]
489    fn test_display_run_end_encoded() {
490        // Compact form: default field names
491        let run_ends_field = Arc::new(Field::new(
492            Field::REE_RUN_ENDS_FIELD_DEFAULT_NAME,
493            DataType::UInt32,
494            false,
495        ));
496        let values_field = Arc::new(Field::new(
497            Field::REE_VALUES_FIELD_DEFAULT_NAME,
498            DataType::Int32,
499            true,
500        ));
501        let ree = DataType::RunEndEncoded(run_ends_field.clone(), values_field.clone());
502        assert_eq!(ree.to_string(), "RunEndEncoded(non-null UInt32, Int32)");
503
504        // Compact form: non-null values
505        let run_ends_field = Arc::new(Field::new(
506            Field::REE_RUN_ENDS_FIELD_DEFAULT_NAME,
507            DataType::Int32,
508            false,
509        ));
510        let values_field_str = Arc::new(Field::new(
511            Field::REE_VALUES_FIELD_DEFAULT_NAME,
512            DataType::Utf8,
513            false,
514        ));
515        let ree2 = DataType::RunEndEncoded(run_ends_field, values_field_str);
516        assert_eq!(
517            ree2.to_string(),
518            "RunEndEncoded(non-null Int32, non-null Utf8)"
519        );
520
521        // Verbose form: metadata on values field triggers verbose form
522        let run_ends_field = Arc::new(Field::new(
523            Field::REE_RUN_ENDS_FIELD_DEFAULT_NAME,
524            DataType::Int32,
525            false,
526        ));
527        let mut values_with_meta =
528            Field::new(Field::REE_VALUES_FIELD_DEFAULT_NAME, DataType::Utf8, true);
529        values_with_meta.set_metadata(HashMap::from([("k".to_string(), "v".to_string())]));
530        let ree_meta = DataType::RunEndEncoded(run_ends_field, Arc::new(values_with_meta));
531        assert_eq!(
532            ree_meta.to_string(),
533            "RunEndEncoded(\"run_ends\": non-null Int32, \"values\": Utf8, metadata: {\"k\": \"v\"})"
534        );
535
536        // Verbose form: non-default field name on values
537        let run_ends_field = Arc::new(Field::new(
538            Field::REE_RUN_ENDS_FIELD_DEFAULT_NAME,
539            DataType::Int32,
540            false,
541        ));
542        let named_values = Arc::new(Field::new("named_values", DataType::Utf8, false));
543        let ree3 = DataType::RunEndEncoded(run_ends_field, named_values);
544        assert_eq!(
545            ree3.to_string(),
546            "RunEndEncoded(\"run_ends\": non-null Int32, \"named_values\": non-null Utf8)"
547        );
548
549        // Verbose form: non-default field name on run_ends
550        let custom_re = Arc::new(Field::new("re", DataType::Int32, false));
551        let values_field = Arc::new(Field::new(
552            Field::REE_VALUES_FIELD_DEFAULT_NAME,
553            DataType::Int32,
554            true,
555        ));
556        let ree4 = DataType::RunEndEncoded(custom_re, values_field);
557        assert_eq!(
558            ree4.to_string(),
559            "RunEndEncoded(\"re\": non-null Int32, \"values\": Int32)"
560        );
561
562        // Verbose form: metadata on both fields
563        let mut run_ends_with_meta = Field::new(
564            Field::REE_RUN_ENDS_FIELD_DEFAULT_NAME,
565            DataType::Int32,
566            false,
567        );
568        run_ends_with_meta.set_metadata(HashMap::from([(
569            "source".to_string(),
570            "encoder".to_string(),
571        )]));
572        let mut values_with_meta2 =
573            Field::new(Field::REE_VALUES_FIELD_DEFAULT_NAME, DataType::Utf8, true);
574        values_with_meta2.set_metadata(HashMap::from([("locale".to_string(), "en".to_string())]));
575        let ree5 =
576            DataType::RunEndEncoded(Arc::new(run_ends_with_meta), Arc::new(values_with_meta2));
577        assert_eq!(
578            ree5.to_string(),
579            "RunEndEncoded(\"run_ends\": non-null Int32, metadata: {\"source\": \"encoder\"}, \"values\": Utf8, metadata: {\"locale\": \"en\"})"
580        );
581    }
582
583    #[test]
584    fn test_display_dictionary() {
585        let dict_data_type =
586            DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8));
587        let dict_data_type_string = dict_data_type.to_string();
588        let expected_string = "Dictionary(Int8, Utf8)";
589        assert_eq!(dict_data_type_string, expected_string);
590
591        // Test with complex index and value types
592        let complex_dict_data_type = DataType::Dictionary(
593            Box::new(DataType::Int16),
594            Box::new(DataType::Struct(
595                vec![
596                    Field::new("a", DataType::Int32, false),
597                    Field::new("b", DataType::Utf8, true),
598                ]
599                .into(),
600            )),
601        );
602        let complex_dict_data_type_string = complex_dict_data_type.to_string();
603        let expected_complex_string =
604            "Dictionary(Int16, Struct(\"a\": non-null Int32, \"b\": Utf8))";
605        assert_eq!(complex_dict_data_type_string, expected_complex_string);
606    }
607
608    #[test]
609    fn test_display_interval() {
610        let interval_year_month = DataType::Interval(crate::IntervalUnit::YearMonth);
611        let interval_year_month_string = interval_year_month.to_string();
612        let expected_year_month_string = "Interval(YearMonth)";
613        assert_eq!(interval_year_month_string, expected_year_month_string);
614
615        let interval_day_time = DataType::Interval(crate::IntervalUnit::DayTime);
616        let interval_day_time_string = interval_day_time.to_string();
617        let expected_day_time_string = "Interval(DayTime)";
618        assert_eq!(interval_day_time_string, expected_day_time_string);
619
620        let interval_month_day_nano = DataType::Interval(crate::IntervalUnit::MonthDayNano);
621        let interval_month_day_nano_string = interval_month_day_nano.to_string();
622        let expected_month_day_nano_string = "Interval(MonthDayNano)";
623        assert_eq!(
624            interval_month_day_nano_string,
625            expected_month_day_nano_string
626        );
627    }
628
629    #[test]
630    fn test_display_timestamp() {
631        let timestamp_without_tz = DataType::Timestamp(crate::TimeUnit::Microsecond, None);
632        let timestamp_without_tz_string = timestamp_without_tz.to_string();
633        let expected_without_tz_string = "Timestamp(µs)";
634        assert_eq!(timestamp_without_tz_string, expected_without_tz_string);
635
636        let timestamp_with_tz =
637            DataType::Timestamp(crate::TimeUnit::Nanosecond, Some(Arc::from("UTC")));
638        let timestamp_with_tz_string = timestamp_with_tz.to_string();
639        let expected_with_tz_string = "Timestamp(ns, \"UTC\")";
640        assert_eq!(timestamp_with_tz_string, expected_with_tz_string);
641    }
642}