clickhouse_data_type/
type_name.rs

1use core::str::FromStr;
2
3use chrono_tz::Tz;
4use pest::{iterators::Pair, Parser as _};
5
6use crate::{
7    array, date_time,
8    date_time64::{self, DateTime64Precision},
9    decimal::{self, DecimalPrecision, DecimalScale},
10    fixed_string::{self, FixedStringN},
11    low_cardinality::{self, LowCardinalityDataType},
12    map::{self, MapKey, MapValue},
13    nullable::{self, NullableTypeName},
14    r#enum::{self, Enum16, Enum8},
15    type_name_parser::{Rule, TypeNameParser},
16    ParseError,
17};
18
19#[derive(PartialEq, Eq, Debug, Clone)]
20pub enum TypeName {
21    UInt8,
22    UInt16,
23    UInt32,
24    UInt64,
25    UInt256,
26    Int8,
27    Int16,
28    Int32,
29    Int64,
30    Int128,
31    Int256,
32    Float32,
33    Float64,
34    Decimal(DecimalPrecision, DecimalScale),
35    String,
36    FixedString(FixedStringN),
37    Uuid,
38    Date,
39    DateTime(Option<Tz>),
40    DateTime64(DateTime64Precision, Option<Tz>),
41    Enum8(Enum8),
42    Enum16(Enum16),
43    Ipv4,
44    Ipv6,
45    //
46    //
47    //
48    LowCardinality(LowCardinalityDataType),
49    Nullable(NullableTypeName),
50    Point,
51    Ring,
52    Polygon,
53    MultiPolygon,
54    //
55    //
56    //
57    Array(Box<Self>),
58    Tuple(Vec<Self>),
59    Map(MapKey, MapValue),
60}
61
62impl FromStr for TypeName {
63    type Err = ParseError;
64
65    fn from_str(s: &str) -> Result<Self, Self::Err> {
66        let pair = TypeNameParser::parse(Rule::type_name, s)
67            .map_err(|err| ParseError::FormatMismatch(err.to_string()))?
68            .next()
69            .ok_or(ParseError::Unknown)?
70            .into_inner()
71            .next()
72            .ok_or(ParseError::Unknown)?;
73
74        Self::from_pair(pair)
75    }
76}
77
78impl TypeName {
79    pub(crate) fn from_pair(pair: Pair<'_, Rule>) -> Result<TypeName, ParseError> {
80        match pair.as_rule() {
81            Rule::UInt8 => Ok(Self::UInt8),
82            Rule::UInt16 => Ok(Self::UInt16),
83            Rule::UInt32 => Ok(Self::UInt32),
84            Rule::UInt64 => Ok(Self::UInt64),
85            Rule::UInt256 => Ok(Self::UInt256),
86            Rule::Int8 => Ok(Self::Int8),
87            Rule::Int16 => Ok(Self::Int16),
88            Rule::Int32 => Ok(Self::Int32),
89            Rule::Int64 => Ok(Self::Int64),
90            Rule::Int128 => Ok(Self::Int128),
91            Rule::Int256 => Ok(Self::Int256),
92            Rule::Float32 => Ok(Self::Float32),
93            Rule::Float64 => Ok(Self::Float64),
94            Rule::Decimal => {
95                let (precision, scale) = decimal::get_precision_and_scale(pair.into_inner())?;
96
97                Ok(Self::Decimal(precision, scale))
98            }
99            Rule::String => Ok(Self::String),
100            Rule::FixedString => {
101                let n = fixed_string::get_n(pair.into_inner())?;
102
103                Ok(Self::FixedString(n))
104            }
105            Rule::UUID => Ok(Self::Uuid),
106            Rule::Date => Ok(Self::Date),
107            Rule::DateTime => {
108                let timezone = date_time::get_timezone(pair.into_inner())?;
109
110                Ok(Self::DateTime(timezone))
111            }
112            Rule::DateTime64 => {
113                let (precision, timezone) =
114                    date_time64::get_precision_and_timezone(pair.into_inner())?;
115
116                Ok(Self::DateTime64(precision, timezone))
117            }
118            Rule::Enum8 => {
119                let inner = r#enum::get_enum8(pair.into_inner())?;
120
121                Ok(Self::Enum8(inner))
122            }
123            Rule::Enum16 => {
124                let inner = r#enum::get_enum16(pair.into_inner())?;
125
126                Ok(Self::Enum16(inner))
127            }
128            Rule::IPv4 => Ok(Self::Ipv4),
129            Rule::IPv6 => Ok(Self::Ipv6),
130            //
131            //
132            //
133            Rule::LowCardinality => {
134                let data_type = low_cardinality::get_data_type(pair.into_inner())?;
135
136                Ok(Self::LowCardinality(data_type))
137            }
138            Rule::Nullable => {
139                let type_name = nullable::get_type_name(pair.into_inner())?;
140
141                Ok(Self::Nullable(type_name))
142            }
143            Rule::Point => Ok(Self::Point),
144            Rule::Ring => Ok(Self::Ring),
145            Rule::Polygon => Ok(Self::Polygon),
146            Rule::MultiPolygon => Ok(Self::MultiPolygon),
147            //
148            //
149            //
150            Rule::Array => {
151                let data_type = array::get_data_type(pair.into_inner())?;
152
153                Ok(Self::Array(data_type.into()))
154            }
155            Rule::Tuple => {
156                let pairs: Vec<_> = pair.into_inner().collect();
157
158                if pairs.is_empty() {
159                    return Err(ParseError::Unknown);
160                }
161
162                let mut type_names = vec![];
163                for pair in pairs {
164                    let this =
165                        Self::from_pair(pair.into_inner().next().ok_or(ParseError::Unknown)?)?;
166                    type_names.push(this);
167                }
168                Ok(Self::Tuple(type_names))
169            }
170            Rule::Map => {
171                let (map_key, map_value) = map::get_map_key_and_map_value(pair.into_inner())?;
172
173                Ok(Self::Map(map_key, map_value))
174            }
175            _ => Err(ParseError::Unknown),
176        }
177    }
178}
179
180#[cfg(test)]
181mod tests {
182    use super::*;
183
184    use crate::map::{MapKey, MapValue};
185
186    #[test]
187    fn test_parse_int_uint() -> Result<(), Box<dyn std::error::Error>> {
188        let content = include_str!("../tests/files/int_uint.txt");
189        let line = content.lines().nth(2).unwrap();
190
191        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
192
193        assert_eq!(TypeName::UInt8, iter.next().unwrap().parse()?);
194        assert_eq!(TypeName::UInt16, iter.next().unwrap().parse()?);
195        assert_eq!(TypeName::UInt32, iter.next().unwrap().parse()?);
196        assert_eq!(TypeName::UInt64, iter.next().unwrap().parse()?);
197        assert_eq!(TypeName::UInt256, iter.next().unwrap().parse()?);
198        assert_eq!(TypeName::Int8, iter.next().unwrap().parse()?);
199        assert_eq!(TypeName::Int16, iter.next().unwrap().parse()?);
200        assert_eq!(TypeName::Int32, iter.next().unwrap().parse()?);
201        assert_eq!(TypeName::Int64, iter.next().unwrap().parse()?);
202        assert_eq!(TypeName::Int128, iter.next().unwrap().parse()?);
203        assert_eq!(TypeName::Int256, iter.next().unwrap().parse()?);
204
205        assert_eq!(iter.next(), None);
206
207        Ok(())
208    }
209
210    #[test]
211    fn test_parse_float() -> Result<(), Box<dyn std::error::Error>> {
212        let content = include_str!("../tests/files/float.txt");
213        let line = content.lines().nth(2).unwrap();
214
215        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
216
217        assert_eq!(TypeName::Float32, iter.next().unwrap().parse()?);
218        assert_eq!(TypeName::Float64, iter.next().unwrap().parse()?);
219
220        assert_eq!(iter.next(), None);
221
222        Ok(())
223    }
224
225    #[test]
226    fn test_parse_decimal() -> Result<(), Box<dyn std::error::Error>> {
227        let content = include_str!("../tests/files/decimal.txt");
228        let line = content.lines().nth(2).unwrap();
229
230        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
231
232        for (precision, scale) in vec![
233            (9, 9),
234            (9, 1),
235            (18, 18),
236            (18, 2),
237            (38, 38),
238            (38, 3),
239            (76, 76),
240            (76, 4),
241        ]
242        .into_iter()
243        {
244            assert_eq!(
245                TypeName::Decimal(DecimalPrecision(precision), DecimalScale(scale)),
246                iter.next().unwrap().parse()?
247            );
248        }
249
250        assert_eq!(iter.next(), None);
251
252        Ok(())
253    }
254
255    #[test]
256    fn test_parse_string() -> Result<(), Box<dyn std::error::Error>> {
257        let content = include_str!("../tests/files/string.txt");
258        let line = content.lines().nth(2).unwrap();
259
260        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
261
262        assert_eq!(TypeName::String, iter.next().unwrap().parse()?);
263
264        assert_eq!(iter.next(), None);
265
266        Ok(())
267    }
268
269    #[test]
270    fn test_parse_fixedstring() -> Result<(), Box<dyn std::error::Error>> {
271        let content = include_str!("../tests/files/fixedstring.txt");
272        let line = content.lines().nth(2).unwrap();
273
274        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
275
276        assert_eq!(
277            TypeName::FixedString(FixedStringN(8)),
278            iter.next().unwrap().parse()?
279        );
280
281        assert_eq!(iter.next(), None);
282
283        Ok(())
284    }
285
286    #[test]
287    fn test_parse_uuid() -> Result<(), Box<dyn std::error::Error>> {
288        let content = include_str!("../tests/files/uuid.txt");
289        let line = content.lines().nth(2).unwrap();
290
291        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
292
293        assert_eq!(TypeName::Uuid, iter.next().unwrap().parse()?);
294
295        assert_eq!(iter.next(), None);
296
297        Ok(())
298    }
299
300    #[test]
301    fn test_parse_date() -> Result<(), Box<dyn std::error::Error>> {
302        let content = include_str!("../tests/files/date.txt");
303        let line = content.lines().nth(2).unwrap();
304
305        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
306
307        assert_eq!(TypeName::Date, iter.next().unwrap().parse()?);
308
309        assert_eq!(iter.next(), None);
310
311        Ok(())
312    }
313
314    #[test]
315    fn test_parse_datetime() -> Result<(), Box<dyn std::error::Error>> {
316        let content = include_str!("../tests/files/datetime.txt");
317        let line = content.lines().nth(2).unwrap();
318
319        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
320
321        assert_eq!(TypeName::DateTime(None), iter.next().unwrap().parse()?);
322        assert_eq!(
323            TypeName::DateTime(Some(Tz::UTC)),
324            iter.next().unwrap().parse()?
325        );
326        assert_eq!(
327            TypeName::DateTime(Some(Tz::Asia__Shanghai)),
328            iter.next().unwrap().parse()?
329        );
330
331        assert_eq!(iter.next(), None);
332
333        Ok(())
334    }
335
336    #[test]
337    fn test_parse_datetime64() -> Result<(), Box<dyn std::error::Error>> {
338        let content = include_str!("../tests/files/datetime64.txt");
339        let line = content.lines().nth(2).unwrap();
340
341        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
342
343        assert_eq!(
344            TypeName::DateTime64(DateTime64Precision(0), None),
345            iter.next().unwrap().parse()?
346        );
347        assert_eq!(
348            TypeName::DateTime64(DateTime64Precision(3), Some(Tz::UTC)),
349            iter.next().unwrap().parse()?
350        );
351        assert_eq!(
352            TypeName::DateTime64(DateTime64Precision(9), Some(Tz::Asia__Shanghai)),
353            iter.next().unwrap().parse()?
354        );
355
356        assert_eq!(iter.next(), None);
357
358        Ok(())
359    }
360
361    #[test]
362    fn test_parse_enum() -> Result<(), Box<dyn std::error::Error>> {
363        let content = include_str!("../tests/files/enum.txt");
364        let line = content.lines().nth(2).unwrap();
365
366        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
367
368        assert_eq!(
369            TypeName::Enum8(
370                vec![("a".to_owned(), -128), ("b".to_owned(), 127)]
371                    .into_iter()
372                    .collect()
373            ),
374            iter.next().unwrap().parse()?
375        );
376        assert_eq!(
377            TypeName::Enum16(
378                vec![("a".to_owned(), -32768), ("b".to_owned(), 32767)]
379                    .into_iter()
380                    .collect()
381            ),
382            iter.next().unwrap().parse()?
383        );
384        assert_eq!(
385            TypeName::Enum8(
386                vec![("0".to_owned(), 0), ("1".to_owned(), 1)]
387                    .into_iter()
388                    .collect()
389            ),
390            iter.next().unwrap().parse()?
391        );
392
393        assert_eq!(iter.next(), None);
394
395        Ok(())
396    }
397
398    #[test]
399    fn test_parse_lowcardinality() -> Result<(), Box<dyn std::error::Error>> {
400        let content = include_str!("../tests/files/lowcardinality.txt");
401        let line = content.lines().nth(2).unwrap();
402
403        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
404
405        assert_eq!(
406            TypeName::LowCardinality(LowCardinalityDataType::String),
407            iter.next().unwrap().parse()?
408        );
409        assert_eq!(
410            TypeName::LowCardinality(LowCardinalityDataType::FixedString(FixedStringN(1))),
411            iter.next().unwrap().parse()?
412        );
413        assert_eq!(
414            TypeName::LowCardinality(LowCardinalityDataType::Date),
415            iter.next().unwrap().parse()?
416        );
417        assert_eq!(
418            TypeName::LowCardinality(LowCardinalityDataType::DateTime(None)),
419            iter.next().unwrap().parse()?
420        );
421        assert_eq!(
422            TypeName::LowCardinality(LowCardinalityDataType::UInt8),
423            iter.next().unwrap().parse()?
424        );
425        assert_eq!(
426            TypeName::LowCardinality(LowCardinalityDataType::UInt16),
427            iter.next().unwrap().parse()?
428        );
429        assert_eq!(
430            TypeName::LowCardinality(LowCardinalityDataType::UInt32),
431            iter.next().unwrap().parse()?
432        );
433        assert_eq!(
434            TypeName::LowCardinality(LowCardinalityDataType::UInt64),
435            iter.next().unwrap().parse()?
436        );
437        assert_eq!(
438            TypeName::LowCardinality(LowCardinalityDataType::Int8),
439            iter.next().unwrap().parse()?
440        );
441        assert_eq!(
442            TypeName::LowCardinality(LowCardinalityDataType::Int16),
443            iter.next().unwrap().parse()?
444        );
445        assert_eq!(
446            TypeName::LowCardinality(LowCardinalityDataType::Int32),
447            iter.next().unwrap().parse()?
448        );
449        assert_eq!(
450            TypeName::LowCardinality(LowCardinalityDataType::Int64),
451            iter.next().unwrap().parse()?
452        );
453        assert_eq!(
454            TypeName::LowCardinality(LowCardinalityDataType::Float32),
455            iter.next().unwrap().parse()?
456        );
457        assert_eq!(
458            TypeName::LowCardinality(LowCardinalityDataType::Float64),
459            iter.next().unwrap().parse()?
460        );
461        assert_eq!(
462            TypeName::LowCardinality(LowCardinalityDataType::Nullable(NullableTypeName::String)),
463            iter.next().unwrap().parse()?
464        );
465        assert_eq!(
466            TypeName::LowCardinality(LowCardinalityDataType::Nullable(NullableTypeName::String)),
467            iter.next().unwrap().parse()?
468        );
469        assert_eq!(
470            TypeName::LowCardinality(LowCardinalityDataType::Ipv4),
471            iter.next().unwrap().parse()?
472        );
473        assert_eq!(
474            TypeName::LowCardinality(LowCardinalityDataType::Ipv6),
475            iter.next().unwrap().parse()?
476        );
477
478        assert_eq!(iter.next(), None);
479
480        Ok(())
481    }
482
483    #[test]
484    fn test_parse_nullable() -> Result<(), Box<dyn std::error::Error>> {
485        let content = include_str!("../tests/files/nullable.txt");
486        let line = content.lines().nth(2).unwrap();
487
488        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
489
490        assert_eq!(
491            TypeName::Nullable(NullableTypeName::UInt8),
492            iter.next().unwrap().parse()?
493        );
494        assert_eq!(
495            TypeName::Nullable(NullableTypeName::UInt256),
496            iter.next().unwrap().parse()?
497        );
498        assert_eq!(
499            TypeName::Nullable(NullableTypeName::Int8),
500            iter.next().unwrap().parse()?
501        );
502        assert_eq!(
503            TypeName::Nullable(NullableTypeName::Int256),
504            iter.next().unwrap().parse()?
505        );
506        assert_eq!(
507            TypeName::Nullable(NullableTypeName::Float64),
508            iter.next().unwrap().parse()?
509        );
510        assert_eq!(
511            TypeName::Nullable(NullableTypeName::Decimal(
512                DecimalPrecision(76),
513                DecimalScale(4)
514            )),
515            iter.next().unwrap().parse()?
516        );
517        assert_eq!(
518            TypeName::Nullable(NullableTypeName::String),
519            iter.next().unwrap().parse()?
520        );
521        assert_eq!(
522            TypeName::Nullable(NullableTypeName::FixedString(FixedStringN(1))),
523            iter.next().unwrap().parse()?
524        );
525        assert_eq!(
526            TypeName::Nullable(NullableTypeName::Uuid),
527            iter.next().unwrap().parse()?
528        );
529        assert_eq!(
530            TypeName::Nullable(NullableTypeName::Date),
531            iter.next().unwrap().parse()?
532        );
533        assert_eq!(
534            TypeName::Nullable(NullableTypeName::DateTime(None)),
535            iter.next().unwrap().parse()?
536        );
537        assert_eq!(
538            TypeName::Nullable(NullableTypeName::DateTime64(DateTime64Precision(0), None)),
539            iter.next().unwrap().parse()?
540        );
541        assert_eq!(
542            TypeName::Nullable(NullableTypeName::Enum8(
543                vec![("a".to_owned(), -128), ("b".to_owned(), 127)]
544                    .into_iter()
545                    .collect()
546            )),
547            iter.next().unwrap().parse()?
548        );
549        assert_eq!(
550            TypeName::Nullable(NullableTypeName::Nothing),
551            iter.next().unwrap().parse()?
552        );
553        assert_eq!(
554            TypeName::Nullable(NullableTypeName::Ipv4),
555            iter.next().unwrap().parse()?
556        );
557        assert_eq!(
558            TypeName::Nullable(NullableTypeName::Ipv6),
559            iter.next().unwrap().parse()?
560        );
561
562        assert_eq!(iter.next(), None);
563
564        Ok(())
565    }
566
567    #[test]
568    fn test_parse_array() -> Result<(), Box<dyn std::error::Error>> {
569        let content = include_str!("../tests/files/array.txt");
570        let line = content.lines().nth(2).unwrap();
571
572        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
573
574        assert_eq!(
575            TypeName::Array(TypeName::UInt8.into()),
576            iter.next().unwrap().parse()?
577        );
578        assert_eq!(
579            TypeName::Array(TypeName::UInt8.into()),
580            iter.next().unwrap().parse()?
581        );
582        assert_eq!(
583            TypeName::Array(TypeName::Nullable(NullableTypeName::UInt8).into()),
584            iter.next().unwrap().parse()?
585        );
586        assert_eq!(
587            TypeName::Array(TypeName::Array(TypeName::UInt8.into()).into()),
588            iter.next().unwrap().parse()?
589        );
590        assert_eq!(
591            TypeName::Array(
592                TypeName::Tuple(vec![
593                    TypeName::UInt8,
594                    TypeName::Nullable(NullableTypeName::Nothing)
595                ])
596                .into()
597            ),
598            iter.next().unwrap().parse()?
599        );
600
601        assert_eq!(iter.next(), None);
602
603        Ok(())
604    }
605
606    #[test]
607    fn test_parse_tuple() -> Result<(), Box<dyn std::error::Error>> {
608        let content = include_str!("../tests/files/tuple.txt");
609        let line = content.lines().nth(2).unwrap();
610
611        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
612
613        assert_eq!(
614            TypeName::Tuple(vec![TypeName::String, TypeName::UInt8]),
615            iter.next().unwrap().parse()?
616        );
617        assert_eq!(
618            TypeName::Tuple(vec![TypeName::String, TypeName::UInt8]),
619            iter.next().unwrap().parse()?
620        );
621        assert_eq!(
622            TypeName::Tuple(vec![
623                TypeName::String,
624                TypeName::Nullable(NullableTypeName::UInt8)
625            ]),
626            iter.next().unwrap().parse()?
627        );
628        assert_eq!(
629            TypeName::Tuple(vec![
630                TypeName::String,
631                TypeName::Array(TypeName::UInt8.into()),
632            ]),
633            iter.next().unwrap().parse()?
634        );
635        assert_eq!(
636            TypeName::Tuple(vec![
637                TypeName::String,
638                TypeName::Tuple(vec![
639                    TypeName::UInt8,
640                    TypeName::Nullable(NullableTypeName::Nothing)
641                ]),
642            ]),
643            iter.next().unwrap().parse()?
644        );
645
646        assert_eq!(iter.next(), None);
647
648        Ok(())
649    }
650
651    #[test]
652    fn test_parse_ipv4() -> Result<(), Box<dyn std::error::Error>> {
653        let content = include_str!("../tests/files/ipv4.txt");
654        let line = content.lines().nth(2).unwrap();
655
656        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
657
658        assert_eq!(TypeName::Ipv4, iter.next().unwrap().parse()?);
659
660        assert_eq!(iter.next(), None);
661
662        Ok(())
663    }
664
665    #[test]
666    fn test_parse_ipv6() -> Result<(), Box<dyn std::error::Error>> {
667        let content = include_str!("../tests/files/ipv6.txt");
668        let line = content.lines().nth(2).unwrap();
669
670        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
671
672        assert_eq!(TypeName::Ipv6, iter.next().unwrap().parse()?);
673
674        assert_eq!(iter.next(), None);
675
676        Ok(())
677    }
678
679    #[test]
680    fn test_parse_geo() -> Result<(), Box<dyn std::error::Error>> {
681        assert_eq!(TypeName::Point, "Point".parse()?);
682        assert_eq!(TypeName::Ring, "Ring".parse()?);
683        assert_eq!(TypeName::Polygon, "Polygon".parse()?);
684        assert_eq!(TypeName::MultiPolygon, "MultiPolygon".parse()?);
685
686        Ok(())
687    }
688
689    #[test]
690    fn test_parse_map() -> Result<(), Box<dyn std::error::Error>> {
691        let content = include_str!("../tests/files/map.txt");
692        let line = content.lines().nth(2).unwrap();
693
694        let mut iter = serde_json::from_str::<Vec<String>>(line)?.into_iter();
695
696        assert_eq!(
697            TypeName::Map(MapKey::String, MapValue::String),
698            iter.next().unwrap().parse()?
699        );
700        assert_eq!(
701            TypeName::Map(MapKey::FixedString(FixedStringN(2)), MapValue::String),
702            iter.next().unwrap().parse()?
703        );
704        assert_eq!(
705            TypeName::Map(MapKey::UInt256, MapValue::String),
706            iter.next().unwrap().parse()?
707        );
708        assert_eq!(
709            TypeName::Map(MapKey::Int256, MapValue::String),
710            iter.next().unwrap().parse()?
711        );
712        assert_eq!(
713            TypeName::Map(MapKey::Float64, MapValue::String),
714            iter.next().unwrap().parse()?
715        );
716        assert_eq!(
717            TypeName::Map(
718                MapKey::Decimal(DecimalPrecision(9), DecimalScale(9)),
719                MapValue::String
720            ),
721            iter.next().unwrap().parse()?
722        );
723        assert_eq!(
724            TypeName::Map(MapKey::String, MapValue::Array(TypeName::String.into())),
725            iter.next().unwrap().parse()?
726        );
727
728        assert_eq!(iter.next(), None);
729
730        Ok(())
731    }
732}
clickhouse_data_type/type_name.rs

clickhouse_data_type/
type_name.rs
