suharev7 / clickhouse-rs / 247

pending completion

Build # 247

Build Type

push

travis-ci-com

Committed by

suharev7

Commit Message

<a href="https://github.com/suharev7/clickhouse-rs/commit/<a class=hub.com/suharev7/clickhouse-rs/commit/8b79c04447885a223bf456af2dc0254d55a95ca3">8b79c0444<a href="https://github.com/suharev7/clickhouse-rs/commit/8b79c04447885a223bf456af2dc0254d55a95ca3">&quot;&gt;Support Decimal{32,64}(x) column type specifiers

(cherry picked from commit </a><a class="double-link" href="https://github.com/suharev7/clickhouse-rs/commit/<a class="double-link" href="https://github.com/suharev7/clickhouse-rs/commit/78423efcb7ff29b7713717eeffade4f66bd72520">78423efcb</a>">78423efcb</a><a href="https://github.com/suharev7/clickhouse-rs/commit/8b79c04447885a223bf456af2dc0254d55a95ca3">)

Run Details

4353 of 5173 relevant lines covered (84.15%)

2.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.26

src/types/column/factory.rs

use chrono_tz::Tz;

use crate::{
    binary::ReadEx,
    errors::Result,
    types::column::{
        array::ArrayColumnData, column_data::ColumnData, date::DateColumnData,
        decimal::DecimalColumnData, fixed_string::FixedStringColumnData, list::List,
        nullable::NullableColumnData, numeric::VectorColumnData, string::StringColumnData,
        ip::{IpColumnData, Ipv4, Ipv6, Uuid},
        BoxColumnWrapper, ColumnWrapper,
    },
    types::decimal::NoBits,
    SqlType,
};

macro_rules! match_str {
    ($arg:ident, {
        $( $($var:literal)|* => $doit:expr,)*
        _ => $dothat:block
    }) => {
        $(
            $(
                if $arg.eq_ignore_ascii_case($var) {
                    $doit
                } else
            )*
        )*
        $dothat
    }
}

impl dyn ColumnData {
    #[allow(clippy::cognitive_complexity)]
    pub(crate) fn load_data<W: ColumnWrapper, T: ReadEx>(
        reader: &mut T,
        type_name: &str,
        size: usize,
        tz: Tz,
    ) -> Result<W::Wrapper> {
        Ok(match_str!(type_name, {
            "UInt8" => W::wrap(VectorColumnData::<u8>::load(reader, size)?),
            "UInt16" => W::wrap(VectorColumnData::<u16>::load(reader, size)?),
            "UInt32" => W::wrap(VectorColumnData::<u32>::load(reader, size)?),
            "UInt64" => W::wrap(VectorColumnData::<u64>::load(reader, size)?),
            "Int8" | "TinyInt" => W::wrap(VectorColumnData::<i8>::load(reader, size)?),
            "Int16" | "SmallInt" => W::wrap(VectorColumnData::<i16>::load(reader, size)?),
            "Int32" | "Int" | "Integer" => W::wrap(VectorColumnData::<i32>::load(reader, size)?),
            "Int64" | "BigInt" => W::wrap(VectorColumnData::<i64>::load(reader, size)?),
            "Float32" | "Float" => W::wrap(VectorColumnData::<f32>::load(reader, size)?),
            "Float64" | "Double" => W::wrap(VectorColumnData::<f64>::load(reader, size)?),
            "String" | "Char" | "Varchar" | "Text" | "TinyText" | "MediumText" | "LongText" | "Blob" | "TinyBlob" | "MediumBlob" | "LongBlob" => W::wrap(StringColumnData::load(reader, size)?),
            "Date" => W::wrap(DateColumnData::<u16>::load(reader, size, tz)?),
            "DateTime" | "Timestamp" => W::wrap(DateColumnData::<u32>::load(reader, size, tz)?),
            "IPv4" => W::wrap(IpColumnData::<Ipv4>::load(reader, size)?),
            "IPv6" => W::wrap(IpColumnData::<Ipv6>::load(reader, size)?),
            "UUID" => W::wrap(IpColumnData::<Uuid>::load(reader, size)?),
            _ => {
                if let Some(inner_type) = parse_nullable_type(type_name) {
                    W::wrap(NullableColumnData::load(reader, inner_type, size, tz)?)
                } else if let Some(str_len) = parse_fixed_string(type_name) {
                    W::wrap(FixedStringColumnData::load(reader, size, str_len)?)
                } else if let Some(inner_type) = parse_array_type(type_name) {
                    W::wrap(ArrayColumnData::load(reader, inner_type, size, tz)?)
                } else if let Some((precision, scale, nobits)) = parse_decimal(type_name) {
                    W::wrap(DecimalColumnData::load(
                        reader, precision, scale, nobits, size, tz,
                    )?)
                } else {
                    let message = format!("Unsupported column type \"{}\".", type_name);
                    return Err(message.into());
                }
            }
        }))
    }

    pub(crate) fn from_type<W: ColumnWrapper>(
        sql_type: SqlType,
        timezone: Tz,
        capacity: usize,
    ) -> Result<W::Wrapper> {
        Ok(match sql_type {
            SqlType::UInt8 => W::wrap(VectorColumnData::<u8>::with_capacity(capacity)),
            SqlType::UInt16 => W::wrap(VectorColumnData::<u16>::with_capacity(capacity)),
            SqlType::UInt32 => W::wrap(VectorColumnData::<u32>::with_capacity(capacity)),
            SqlType::UInt64 => W::wrap(VectorColumnData::<u64>::with_capacity(capacity)),
            SqlType::Int8 => W::wrap(VectorColumnData::<i8>::with_capacity(capacity)),
            SqlType::Int16 => W::wrap(VectorColumnData::<i16>::with_capacity(capacity)),
            SqlType::Int32 => W::wrap(VectorColumnData::<i32>::with_capacity(capacity)),
            SqlType::Int64 => W::wrap(VectorColumnData::<i64>::with_capacity(capacity)),
            SqlType::String => W::wrap(StringColumnData::with_capacity(capacity)),
            SqlType::FixedString(len) => {
                W::wrap(FixedStringColumnData::with_capacity(capacity, len))
            }
            SqlType::Float32 => W::wrap(VectorColumnData::<f32>::with_capacity(capacity)),
            SqlType::Float64 => W::wrap(VectorColumnData::<f64>::with_capacity(capacity)),

            SqlType::Ipv4 => W::wrap(IpColumnData::<Ipv4>::with_capacity(capacity)),
            SqlType::Ipv6 => W::wrap(IpColumnData::<Ipv6>::with_capacity(capacity)),
            SqlType::Uuid => W::wrap(IpColumnData::<Uuid>::with_capacity(capacity)),

            SqlType::Date => W::wrap(DateColumnData::<u16>::with_capacity(capacity, timezone)),
            SqlType::DateTime => W::wrap(DateColumnData::<u32>::with_capacity(capacity, timezone)),
            SqlType::Nullable(inner_type) => W::wrap(NullableColumnData {
                inner: ColumnData::from_type::<BoxColumnWrapper>(*inner_type, timezone, capacity)?,
                nulls: Vec::new(),
            }),
            SqlType::Array(inner_type) => W::wrap(ArrayColumnData {
                inner: ColumnData::from_type::<BoxColumnWrapper>(*inner_type, timezone, capacity)?,
                offsets: List::with_capacity(capacity),
            }),
            SqlType::Decimal(precision, scale) => {
                let nobits = NoBits::from_precision(precision).unwrap();

                let inner_type = match nobits {
                    NoBits::N32 => SqlType::Int32,
                    NoBits::N64 => SqlType::Int64,
                };

                W::wrap(DecimalColumnData {
                    inner: ColumnData::from_type::<BoxColumnWrapper>(
                        inner_type, timezone, capacity,
                    )?,
                    precision,
                    scale,
                    nobits,
                })
            }
        })
    }
}

fn parse_fixed_string(source: &str) -> Option<usize> {
    if !source.starts_with("FixedString") {
        return None;
    }

    let inner_size = &source[12..source.len() - 1];
    match inner_size.parse::<usize>() {
        Err(_) => None,
        Ok(value) => Some(value),
    }
}

fn parse_nullable_type(source: &str) -> Option<&str> {
    if !source.starts_with("Nullable") {
        return None;
    }

    let inner_type = &source[9..source.len() - 1];

    if inner_type.starts_with("Nullable") {
        return None;
    }

    Some(inner_type)
}

fn parse_array_type(source: &str) -> Option<&str> {
    if !source.starts_with("Array") {
        return None;
    }

    let inner_type = &source[6..source.len() - 1];
    Some(inner_type)
}

fn parse_decimal(source: &str) -> Option<(u8, u8, NoBits)> {
    if source.len() < 12 {
        return None;
    }

    if !source.starts_with("Decimal") {
        return None;
    }

    let mut nobits = None;
    let mut precision = None;
    let mut scale = None;

    let mut params_indexes = (None, None);

    for (idx, byte) in source.as_bytes().iter().enumerate() {
        if *byte == b'(' {
            match &source.as_bytes()[..idx] {
                b"Decimal" => {}
                b"Decimal32" => {
                    nobits = Some(NoBits::N32);
                }
                b"Decimal64" => {
                    nobits = Some(NoBits::N64);
                }
                _ => return None,
            }
            params_indexes.0 = Some(idx);
        }
        if *byte == b')' {
            params_indexes.1 = Some(idx);
        }
    }

    let params_indexes = match params_indexes {
        (Some(start), Some(end)) => (start, end),
        _ => return None,
    };

    match nobits {
        Some(_) => {
            scale = std::str::from_utf8(&source.as_bytes()[params_indexes.0 + 1..params_indexes.1])
                .unwrap()
                .parse()
                .ok()
        }
        None => {
            for (idx, cell) in
                std::str::from_utf8(&source.as_bytes()[params_indexes.0 + 1..params_indexes.1])
                    .unwrap()
                    .split(',')
                    .map(|s| s.trim())
                    .enumerate()
            {
                match idx {
                    0 => precision = cell.parse().ok(),
                    1 => scale = cell.parse().ok(),
                    _ => return None,
                }
            }
        }
    }

    match (precision, scale, nobits) {
        (Some(precision), Some(scale), None) => {
            if scale > precision {
                return None;
            }

            if let Some(nobits) = NoBits::from_precision(precision) {
                Some((precision, scale, nobits))
            } else {
                None
            }
        }
        (None, Some(scale), Some(bits)) => {
            let precision = match bits {
                NoBits::N32 => 9,
                NoBits::N64 => 18,
            };
            Some((precision, scale, bits))
        }
        _ => None,
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_parse_decimal() {
        assert_eq!(parse_decimal("Decimal(9, 4)"), Some((9, 4, NoBits::N32)));
        assert_eq!(parse_decimal("Decimal(10, 4)"), Some((10, 4, NoBits::N64)));
        assert_eq!(parse_decimal("Decimal(20, 4)"), None);
        assert_eq!(parse_decimal("Decimal(2000, 4)"), None);
        assert_eq!(parse_decimal("Decimal(3, 4)"), None);
        assert_eq!(parse_decimal("Decimal(20, -4)"), None);
        assert_eq!(parse_decimal("Decimal(0)"), None);
        assert_eq!(parse_decimal("Decimal(1, 2, 3)"), None);
        assert_eq!(parse_decimal("Decimal64(9)"), Some((18, 9, NoBits::N64)));
    }

    #[test]
    fn test_parse_array_type() {
        assert_eq!(parse_array_type("Array(UInt8)"), Some("UInt8"));
    }

    #[test]
    fn test_parse_nullable_type() {
        assert_eq!(parse_nullable_type("Nullable(Int8)"), Some("Int8"));
        assert_eq!(parse_nullable_type("Int8"), None);
        assert_eq!(parse_nullable_type("Nullable(Nullable(Int8))"), None);
    }

    #[test]
    fn test_parse_fixed_string() {
        assert_eq!(parse_fixed_string("FixedString(8)"), Some(8_usize));
        assert_eq!(parse_fixed_string("FixedString(zz)"), None);
        assert_eq!(parse_fixed_string("Int8"), None);
    }
}

1	use chrono_tz::Tz;
2
3	use crate::{
4	binary::ReadEx,
5	errors::Result,
6	types::column::{
7	array::ArrayColumnData, column_data::ColumnData, date::DateColumnData,
8	decimal::DecimalColumnData, fixed_string::FixedStringColumnData, list::List,
9	nullable::NullableColumnData, numeric::VectorColumnData, string::StringColumnData,
10	ip::{IpColumnData, Ipv4, Ipv6, Uuid},
11	BoxColumnWrapper, ColumnWrapper,
12	},
13	types::decimal::NoBits,
14	SqlType,
15	};
16
17	macro_rules! match_str {
18	($arg:ident, {
19	$( $($var:literal)\|* => $doit:expr,)*
20	_ => $dothat:block
21	}) => {
22	$(
23	$(
24	if $arg.eq_ignore_ascii_case($var) {
25	$doit
26	} else
27	)*
28	)*
29	$dothat
30	}
31	}
32
33	impl dyn ColumnData {
34	#[allow(clippy::cognitive_complexity)]
35	pub(crate) fn load_data<W: ColumnWrapper, T: ReadEx>(	3✔
36	reader: &mut T,
37	type_name: &str,
38	size: usize,
39	tz: Tz,
40	) -> Result<W::Wrapper> {
41	Ok(match_str!(type_name, {	3✔
42	"UInt8" => W::wrap(VectorColumnData::<u8>::load(reader, size)?),	3✔
43	"UInt16" => W::wrap(VectorColumnData::<u16>::load(reader, size)?),	3✔
44	"UInt32" => W::wrap(VectorColumnData::<u32>::load(reader, size)?),	3✔
45	"UInt64" => W::wrap(VectorColumnData::<u64>::load(reader, size)?),	3✔
46	"Int8" \| "TinyInt" => W::wrap(VectorColumnData::<i8>::load(reader, size)?),	3✔
47	"Int16" \| "SmallInt" => W::wrap(VectorColumnData::<i16>::load(reader, size)?),	3✔
48	"Int32" \| "Int" \| "Integer" => W::wrap(VectorColumnData::<i32>::load(reader, size)?),	3✔
49	"Int64" \| "BigInt" => W::wrap(VectorColumnData::<i64>::load(reader, size)?),	3✔
50	"Float32" \| "Float" => W::wrap(VectorColumnData::<f32>::load(reader, size)?),	3✔
51	"Float64" \| "Double" => W::wrap(VectorColumnData::<f64>::load(reader, size)?),	3✔
52	"String" \| "Char" \| "Varchar" \| "Text" \| "TinyText" \| "MediumText" \| "LongText" \| "Blob" \| "TinyBlob" \| "MediumBlob" \| "LongBlob" => W::wrap(StringColumnData::load(reader, size)?),	3✔
53	"Date" => W::wrap(DateColumnData::<u16>::load(reader, size, tz)?),	3✔
54	"DateTime" \| "Timestamp" => W::wrap(DateColumnData::<u32>::load(reader, size, tz)?),	3✔
55	"IPv4" => W::wrap(IpColumnData::<Ipv4>::load(reader, size)?),	3✔
56	"IPv6" => W::wrap(IpColumnData::<Ipv6>::load(reader, size)?),	3✔
57	"UUID" => W::wrap(IpColumnData::<Uuid>::load(reader, size)?),	3✔
58	_ => {
59	if let Some(inner_type) = parse_nullable_type(type_name) {	3✔
60	W::wrap(NullableColumnData::load(reader, inner_type, size, tz)?)	3✔
61	} else if let Some(str_len) = parse_fixed_string(type_name) {	3✔
62	W::wrap(FixedStringColumnData::load(reader, size, str_len)?)	3✔
63	} else if let Some(inner_type) = parse_array_type(type_name) {	3✔
64	W::wrap(ArrayColumnData::load(reader, inner_type, size, tz)?)	3✔
65	} else if let Some((precision, scale, nobits)) = parse_decimal(type_name) {	3✔
66	W::wrap(DecimalColumnData::load(	3✔
67	reader, precision, scale, nobits, size, tz,	3✔
68	)?)	3✔
69	} else {	3✔
70	let message = format!("Unsupported column type \"{}\".", type_name);	×
71	return Err(message.into());	×
72	}
73	}
74	}))
75	}	3✔
76
77	pub(crate) fn from_type<W: ColumnWrapper>(	3✔
78	sql_type: SqlType,
79	timezone: Tz,
80	capacity: usize,
81	) -> Result<W::Wrapper> {
82	Ok(match sql_type {	3✔
83	SqlType::UInt8 => W::wrap(VectorColumnData::<u8>::with_capacity(capacity)),	3✔
84	SqlType::UInt16 => W::wrap(VectorColumnData::<u16>::with_capacity(capacity)),	3✔
85	SqlType::UInt32 => W::wrap(VectorColumnData::<u32>::with_capacity(capacity)),	3✔
86	SqlType::UInt64 => W::wrap(VectorColumnData::<u64>::with_capacity(capacity)),	3✔
87	SqlType::Int8 => W::wrap(VectorColumnData::<i8>::with_capacity(capacity)),	3✔
88	SqlType::Int16 => W::wrap(VectorColumnData::<i16>::with_capacity(capacity)),	3✔
89	SqlType::Int32 => W::wrap(VectorColumnData::<i32>::with_capacity(capacity)),	3✔
90	SqlType::Int64 => W::wrap(VectorColumnData::<i64>::with_capacity(capacity)),	3✔
91	SqlType::String => W::wrap(StringColumnData::with_capacity(capacity)),	3✔
92	SqlType::FixedString(len) => {	×
93	W::wrap(FixedStringColumnData::with_capacity(capacity, len))	×
94	}
95	SqlType::Float32 => W::wrap(VectorColumnData::<f32>::with_capacity(capacity)),	3✔
96	SqlType::Float64 => W::wrap(VectorColumnData::<f64>::with_capacity(capacity)),	3✔
97
98	SqlType::Ipv4 => W::wrap(IpColumnData::<Ipv4>::with_capacity(capacity)),	×
99	SqlType::Ipv6 => W::wrap(IpColumnData::<Ipv6>::with_capacity(capacity)),	×
100	SqlType::Uuid => W::wrap(IpColumnData::<Uuid>::with_capacity(capacity)),	×
101
102	SqlType::Date => W::wrap(DateColumnData::<u16>::with_capacity(capacity, timezone)),	3✔
103	SqlType::DateTime => W::wrap(DateColumnData::<u32>::with_capacity(capacity, timezone)),	3✔
104	SqlType::Nullable(inner_type) => W::wrap(NullableColumnData {	3✔
105	inner: ColumnData::from_type::<BoxColumnWrapper>(*inner_type, timezone, capacity)?,	3✔
106	nulls: Vec::new(),	3✔
107	}),	3✔
108	SqlType::Array(inner_type) => W::wrap(ArrayColumnData {	×
109	inner: ColumnData::from_type::<BoxColumnWrapper>(*inner_type, timezone, capacity)?,	×
110	offsets: List::with_capacity(capacity),	×
111	}),	×
112	SqlType::Decimal(precision, scale) => {	3✔
113	let nobits = NoBits::from_precision(precision).unwrap();	3✔
114
115	let inner_type = match nobits {	3✔
116	NoBits::N32 => SqlType::Int32,	3✔
117	NoBits::N64 => SqlType::Int64,	3✔
118	};
119
120	W::wrap(DecimalColumnData {	3✔
121	inner: ColumnData::from_type::<BoxColumnWrapper>(	3✔
122	inner_type, timezone, capacity,	3✔
123	)?,	3✔
124	precision,	3✔
125	scale,	3✔
126	nobits,	3✔
127	})
128	}	3✔
129	})
130	}	3✔
131	}
132
133	fn parse_fixed_string(source: &str) -> Option<usize> {	3✔
134	if !source.starts_with("FixedString") {	3✔
135	return None;	3✔
136	}
137
138	let inner_size = &source[12..source.len() - 1];	3✔
139	match inner_size.parse::<usize>() {	3✔
140	Err(_) => None,	3✔
141	Ok(value) => Some(value),	3✔
142	}
143	}	3✔
144
145	fn parse_nullable_type(source: &str) -> Option<&str> {	3✔
146	if !source.starts_with("Nullable") {	3✔
147	return None;	3✔
148	}
149
150	let inner_type = &source[9..source.len() - 1];	3✔
151
152	if inner_type.starts_with("Nullable") {	3✔
153	return None;	3✔
154	}
155
156	Some(inner_type)	3✔
157	}	3✔
158
159	fn parse_array_type(source: &str) -> Option<&str> {	3✔
160	if !source.starts_with("Array") {	3✔
161	return None;	3✔
162	}
163
164	let inner_type = &source[6..source.len() - 1];	3✔
165	Some(inner_type)	3✔
166	}	3✔
167
168	fn parse_decimal(source: &str) -> Option<(u8, u8, NoBits)> {	3✔
169	if source.len() < 12 {	3✔
170	return None;	3✔
171	}
172
173	if !source.starts_with("Decimal") {	3✔
174	return None;	×
175	}
176
177	let mut nobits = None;	3✔
178	let mut precision = None;	3✔
179	let mut scale = None;	3✔
180
181	let mut params_indexes = (None, None);	3✔
182
183	for (idx, byte) in source.as_bytes().iter().enumerate() {	3✔
184	if *byte == b'(' {	3✔
185	match &source.as_bytes()[..idx] {	3✔
186	b"Decimal" => {}	3✔
187	b"Decimal32" => {	3✔
188	nobits = Some(NoBits::N32);	×
189	}
190	b"Decimal64" => {	3✔
191	nobits = Some(NoBits::N64);	3✔
192	}
193	_ => return None,	3✔
194	}
195	params_indexes.0 = Some(idx);	3✔
196	}
197	if *byte == b')' {	3✔
198	params_indexes.1 = Some(idx);	3✔
199	}
200	}
201
202	let params_indexes = match params_indexes {
203	(Some(start), Some(end)) => (start, end),	3✔
204	_ => return None,	3✔
205	};
206
207	match nobits {	3✔
208	Some(_) => {	3✔
209	scale = std::str::from_utf8(&source.as_bytes()[params_indexes.0 + 1..params_indexes.1])	3✔
210	.unwrap()
211	.parse()
212	.ok()
213	}
214	None => {
215	for (idx, cell) in	3✔
216	std::str::from_utf8(&source.as_bytes()[params_indexes.0 + 1..params_indexes.1])	3✔
217	.unwrap()
218	.split(',')
219	.map(\|s\| s.trim())	3✔
220	.enumerate()
221	{
222	match idx {	3✔
223	0 => precision = cell.parse().ok(),	3✔
224	1 => scale = cell.parse().ok(),	3✔
225	_ => return None,	3✔
226	}
227	}	3✔
228	}
229	}
230
231	match (precision, scale, nobits) {	3✔
232	(Some(precision), Some(scale), None) => {	3✔
233	if scale > precision {	3✔
234	return None;	3✔
235	}
236
237	if let Some(nobits) = NoBits::from_precision(precision) {	3✔
238	Some((precision, scale, nobits))	3✔
239	} else {
240	None	3✔
241	}
242	}
243	(None, Some(scale), Some(bits)) => {	3✔
244	let precision = match bits {	3✔
245	NoBits::N32 => 9,	3✔
246	NoBits::N64 => 18,	3✔
247	};
248	Some((precision, scale, bits))	3✔
249	}
250	_ => None,	3✔
251	}
252	}	3✔
253
254	#[cfg(test)]
255	mod test {
256	use super::*;
257
258	#[test]
259	fn test_parse_decimal() {	3✔
260	assert_eq!(parse_decimal("Decimal(9, 4)"), Some((9, 4, NoBits::N32)));	3✔
261	assert_eq!(parse_decimal("Decimal(10, 4)"), Some((10, 4, NoBits::N64)));	3✔
262	assert_eq!(parse_decimal("Decimal(20, 4)"), None);	3✔
263	assert_eq!(parse_decimal("Decimal(2000, 4)"), None);	3✔
264	assert_eq!(parse_decimal("Decimal(3, 4)"), None);	3✔
265	assert_eq!(parse_decimal("Decimal(20, -4)"), None);	3✔
266	assert_eq!(parse_decimal("Decimal(0)"), None);	3✔
267	assert_eq!(parse_decimal("Decimal(1, 2, 3)"), None);	3✔
268	assert_eq!(parse_decimal("Decimal64(9)"), Some((18, 9, NoBits::N64)));	3✔
269	}	3✔
270
271	#[test]
272	fn test_parse_array_type() {	3✔
273	assert_eq!(parse_array_type("Array(UInt8)"), Some("UInt8"));	3✔
274	}	3✔
275
276	#[test]
277	fn test_parse_nullable_type() {	3✔
278	assert_eq!(parse_nullable_type("Nullable(Int8)"), Some("Int8"));	3✔
279	assert_eq!(parse_nullable_type("Int8"), None);	3✔
280	assert_eq!(parse_nullable_type("Nullable(Nullable(Int8))"), None);	3✔
281	}	3✔
282
283	#[test]
284	fn test_parse_fixed_string() {	3✔
285	assert_eq!(parse_fixed_string("FixedString(8)"), Some(8_usize));	3✔
286	assert_eq!(parse_fixed_string("FixedString(zz)"), None);	3✔
287	assert_eq!(parse_fixed_string("Int8"), None);	3✔
288	}	3✔
289	}

suharev7 / clickhouse-rs / 247

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous