1use 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 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 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
190struct 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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}