1use {
2 super::{
3 date::{parse_date, parse_time, parse_timestamp},
4 Value,
5 },
6 crate::{ast::DataType, data::Point},
7 chrono::{NaiveDate, NaiveDateTime, NaiveTime},
8 rust_decimal::prelude::{Decimal, FromPrimitive, FromStr, ToPrimitive},
9 serde::Serialize,
10 std::net::IpAddr,
11 uuid::Uuid,
12};
13
14type Result<T> = std::result::Result<T, ConvertError>;
15
16#[derive(Debug, Serialize, thiserror::Error, PartialEq)]
17#[error("failed to convert value({value:?}) to data type({data_type})")]
18pub struct ConvertError {
19 pub value: Value,
20 pub data_type: DataType,
21}
22
23macro_rules! try_from_owned_value {
25 ($($target:ty), *) => {$(
26 impl TryFrom<Value> for $target {
27 type Error = ConvertError;
28
29 fn try_from(v: Value) -> Result<Self> {
30 Self::try_from(&v)
31 }
32 }
33 )*}
34}
35
36try_from_owned_value!(
37 bool, i8, i16, i32, i64, i128, f32, f64, u8, u16, u32, u64, u128, usize, Decimal
38);
39
40impl From<&Value> for String {
41 fn from(v: &Value) -> Self {
42 match v {
43 Value::Str(value) => value.to_owned(),
44 Value::Bytea(value) => hex::encode(value),
45 Value::Inet(value) => value.to_string(),
46 Value::Bool(value) => (if *value { "TRUE" } else { "FALSE" }).to_owned(),
47 Value::I8(value) => value.to_string(),
48 Value::I16(value) => value.to_string(),
49 Value::I32(value) => value.to_string(),
50 Value::I64(value) => value.to_string(),
51 Value::I128(value) => value.to_string(),
52 Value::U8(value) => value.to_string(),
53 Value::U16(value) => value.to_string(),
54 Value::U32(value) => value.to_string(),
55 Value::U64(value) => value.to_string(),
56 Value::U128(value) => value.to_string(),
57 Value::F32(value) => value.to_string(),
58 Value::F64(value) => value.to_string(),
59 Value::Date(value) => value.to_string(),
60 Value::Timestamp(value) => value.to_string(),
61 Value::Time(value) => value.to_string(),
62 Value::Interval(value) => value.to_sql_str(),
63 Value::Uuid(value) => Uuid::from_u128(*value).to_string(),
64 Value::Map(_) => TryInto::<serde_json::Value>::try_into(v.clone())
65 .unwrap_or_default()
66 .to_string(),
67 Value::List(_) => TryInto::<serde_json::Value>::try_into(v.clone())
68 .unwrap_or_default()
69 .to_string(),
70 Value::Decimal(value) => value.to_string(),
71 Value::Point(value) => value.to_string(),
72 Value::Null => "NULL".to_owned(),
73 }
74 }
75}
76
77impl From<Value> for String {
78 fn from(v: Value) -> String {
79 match v {
80 Value::Str(value) => value,
81 _ => String::from(&v),
82 }
83 }
84}
85
86impl TryFrom<&Value> for bool {
87 type Error = ConvertError;
88
89 fn try_from(v: &Value) -> Result<Self> {
90 macro_rules! int_to_bool {
91 ($num: ident) => {
92 match $num {
93 1 => true,
94 0 => false,
95 _ => {
96 return Err(ConvertError {
97 value: v.clone(),
98 data_type: DataType::Boolean,
99 })
100 }
101 }
102 };
103 }
104
105 Ok(match v {
106 Value::Bool(value) => *value,
107 Value::I8(value) => int_to_bool!(value),
108 Value::I16(value) => int_to_bool!(value),
109 Value::I32(value) => int_to_bool!(value),
110 Value::I64(value) => int_to_bool!(value),
111 Value::I128(value) => int_to_bool!(value),
112 Value::U8(value) => int_to_bool!(value),
113 Value::U16(value) => int_to_bool!(value),
114 Value::U32(value) => int_to_bool!(value),
115 Value::U64(value) => int_to_bool!(value),
116 Value::U128(value) => int_to_bool!(value),
117 Value::F32(value) => {
118 if value.eq(&1.0_f32) {
119 true
120 } else if value.eq(&0.0_f32) {
121 false
122 } else {
123 return Err(ConvertError {
124 value: v.clone(),
125 data_type: DataType::Boolean,
126 });
127 }
128 }
129 Value::F64(value) => {
130 if value.eq(&1.0) {
131 true
132 } else if value.eq(&0.0) {
133 false
134 } else {
135 return Err(ConvertError {
136 value: v.clone(),
137 data_type: DataType::Boolean,
138 });
139 }
140 }
141 Value::Str(value) => match value.to_uppercase().as_str() {
142 "TRUE" => true,
143 "FALSE" => false,
144 _ => {
145 return Err(ConvertError {
146 value: v.clone(),
147 data_type: DataType::Boolean,
148 })
149 }
150 },
151 Value::Decimal(value) => {
152 if value == &rust_decimal::Decimal::ONE {
153 true
154 } else if value == &rust_decimal::Decimal::ZERO {
155 false
156 } else {
157 return Err(ConvertError {
158 value: v.clone(),
159 data_type: DataType::Boolean,
160 });
161 }
162 }
163
164 Value::Date(_)
165 | Value::Timestamp(_)
166 | Value::Time(_)
167 | Value::Interval(_)
168 | Value::Uuid(_)
169 | Value::Map(_)
170 | Value::List(_)
171 | Value::Bytea(_)
172 | Value::Point(_)
173 | Value::Inet(_)
174 | Value::Null => {
175 return Err(ConvertError {
176 value: v.clone(),
177 data_type: DataType::Boolean,
178 })
179 }
180 })
181 }
182}
183
184impl TryFrom<&Value> for i8 {
185 type Error = ConvertError;
186
187 fn try_from(v: &Value) -> Result<i8> {
188 macro_rules! num_to_i8 {
189 ($num: ident) => {
190 $num.to_i8().ok_or_else(|| ConvertError {
191 value: v.clone(),
192 data_type: DataType::Int8,
193 })?
194 };
195 }
196
197 Ok(match v {
198 Value::Bool(value) => i8::from(*value),
199 Value::I8(value) => *value,
200 Value::I16(value) => num_to_i8!(value),
201 Value::I32(value) => num_to_i8!(value),
202 Value::I64(value) => num_to_i8!(value),
203 Value::I128(value) => num_to_i8!(value),
204 Value::U8(value) => num_to_i8!(value),
205 Value::U16(value) => num_to_i8!(value),
206 Value::U32(value) => num_to_i8!(value),
207 Value::U64(value) => num_to_i8!(value),
208 Value::U128(value) => num_to_i8!(value),
209 Value::F32(value) => num_to_i8!(value),
210 Value::F64(value) => num_to_i8!(value),
211 Value::Str(value) => value.parse::<i8>().map_err(|_| ConvertError {
212 value: v.clone(),
213 data_type: DataType::Int8,
214 })?,
215 Value::Decimal(value) => value.to_i8().ok_or_else(|| ConvertError {
216 value: v.clone(),
217 data_type: DataType::Int8,
218 })?,
219
220 Value::Date(_)
221 | Value::Timestamp(_)
222 | Value::Time(_)
223 | Value::Interval(_)
224 | Value::Uuid(_)
225 | Value::Map(_)
226 | Value::List(_)
227 | Value::Bytea(_)
228 | Value::Point(_)
229 | Value::Inet(_)
230 | Value::Null => {
231 return Err(ConvertError {
232 value: v.clone(),
233 data_type: DataType::Int8,
234 })
235 }
236 })
237 }
238}
239
240impl TryFrom<&Value> for i16 {
241 type Error = ConvertError;
242
243 fn try_from(v: &Value) -> Result<i16> {
244 macro_rules! num_to_i16 {
245 ($num: ident) => {
246 $num.to_i16().ok_or_else(|| ConvertError {
247 value: v.clone(),
248 data_type: DataType::Int16,
249 })?
250 };
251 }
252
253 Ok(match v {
254 Value::Bool(value) => i16::from(*value),
255 Value::I8(value) => *value as i16,
256 Value::I16(value) => *value,
257 Value::I32(value) => num_to_i16!(value),
258 Value::I64(value) => num_to_i16!(value),
259 Value::I128(value) => num_to_i16!(value),
260 Value::U8(value) => num_to_i16!(value),
261 Value::U16(value) => num_to_i16!(value),
262 Value::U32(value) => num_to_i16!(value),
263 Value::U64(value) => num_to_i16!(value),
264 Value::U128(value) => num_to_i16!(value),
265 Value::F32(value) => num_to_i16!(value),
266 Value::F64(value) => num_to_i16!(value),
267 Value::Str(value) => value.parse::<i16>().map_err(|_| ConvertError {
268 value: v.clone(),
269 data_type: DataType::Int16,
270 })?,
271 Value::Decimal(value) => value.to_i16().ok_or_else(|| ConvertError {
272 value: v.clone(),
273 data_type: DataType::Int16,
274 })?,
275
276 Value::Date(_)
277 | Value::Timestamp(_)
278 | Value::Time(_)
279 | Value::Interval(_)
280 | Value::Uuid(_)
281 | Value::Map(_)
282 | Value::List(_)
283 | Value::Bytea(_)
284 | Value::Point(_)
285 | Value::Inet(_)
286 | Value::Null => {
287 return Err(ConvertError {
288 value: v.clone(),
289 data_type: DataType::Int16,
290 })
291 }
292 })
293 }
294}
295
296impl TryFrom<&Value> for i32 {
297 type Error = ConvertError;
298
299 fn try_from(v: &Value) -> Result<i32> {
300 macro_rules! num_to_i32 {
301 ($num: ident) => {
302 $num.to_i32().ok_or_else(|| ConvertError {
303 value: v.clone(),
304 data_type: DataType::Int32,
305 })?
306 };
307 }
308
309 Ok(match v {
310 Value::Bool(value) => i32::from(*value),
311 Value::I8(value) => *value as i32,
312 Value::I16(value) => *value as i32,
313 Value::I32(value) => *value,
314 Value::I64(value) => num_to_i32!(value),
315 Value::I128(value) => num_to_i32!(value),
316 Value::U8(value) => num_to_i32!(value),
317 Value::U16(value) => num_to_i32!(value),
318 Value::U32(value) => num_to_i32!(value),
319 Value::U64(value) => num_to_i32!(value),
320 Value::U128(value) => num_to_i32!(value),
321 Value::F32(value) => num_to_i32!(value),
322 Value::F64(value) => num_to_i32!(value),
323 Value::Str(value) => value.parse::<i32>().map_err(|_| ConvertError {
324 value: v.clone(),
325 data_type: DataType::Int32,
326 })?,
327 Value::Decimal(value) => num_to_i32!(value),
328
329 Value::Date(_)
330 | Value::Timestamp(_)
331 | Value::Time(_)
332 | Value::Interval(_)
333 | Value::Uuid(_)
334 | Value::Map(_)
335 | Value::List(_)
336 | Value::Bytea(_)
337 | Value::Point(_)
338 | Value::Inet(_)
339 | Value::Null => {
340 return Err(ConvertError {
341 value: v.clone(),
342 data_type: DataType::Int32,
343 })
344 }
345 })
346 }
347}
348
349impl TryFrom<&Value> for i64 {
350 type Error = ConvertError;
351
352 fn try_from(v: &Value) -> Result<i64> {
353 macro_rules! num_to_i64 {
354 ($num: ident) => {
355 $num.to_i64().ok_or_else(|| ConvertError {
356 value: v.clone(),
357 data_type: DataType::Int,
358 })?
359 };
360 }
361
362 Ok(match v {
363 Value::Bool(value) => i64::from(*value),
364 Value::I8(value) => *value as i64,
365 Value::I16(value) => *value as i64,
366 Value::I32(value) => *value as i64,
367 Value::I64(value) => *value,
368 Value::I128(value) => num_to_i64!(value),
369 Value::U8(value) => num_to_i64!(value),
370 Value::U16(value) => num_to_i64!(value),
371 Value::U32(value) => num_to_i64!(value),
372 Value::U64(value) => num_to_i64!(value),
373 Value::U128(value) => num_to_i64!(value),
374 Value::F32(value) => num_to_i64!(value),
375 Value::F64(value) => num_to_i64!(value),
376 Value::Str(value) => value.parse::<i64>().map_err(|_| ConvertError {
377 value: v.clone(),
378 data_type: DataType::Int,
379 })?,
380 Value::Decimal(value) => num_to_i64!(value),
381
382 Value::Date(_)
383 | Value::Timestamp(_)
384 | Value::Time(_)
385 | Value::Interval(_)
386 | Value::Uuid(_)
387 | Value::Map(_)
388 | Value::List(_)
389 | Value::Bytea(_)
390 | Value::Point(_)
391 | Value::Inet(_)
392 | Value::Null => {
393 return Err(ConvertError {
394 value: v.clone(),
395 data_type: DataType::Int,
396 })
397 }
398 })
399 }
400}
401
402impl TryFrom<&Value> for i128 {
403 type Error = ConvertError;
404
405 fn try_from(v: &Value) -> Result<i128> {
406 macro_rules! num_to_i128 {
407 ($num: ident) => {
408 $num.to_i128().ok_or_else(|| ConvertError {
409 value: v.clone(),
410 data_type: DataType::Int128,
411 })?
412 };
413 }
414
415 Ok(match v {
416 Value::Bool(value) => i128::from(*value),
417 Value::I8(value) => *value as i128,
418 Value::I16(value) => *value as i128,
419 Value::I32(value) => *value as i128,
420 Value::I64(value) => *value as i128,
421 Value::I128(value) => *value,
422 Value::U8(value) => *value as i128,
423 Value::U16(value) => *value as i128,
424 Value::U32(value) => num_to_i128!(value),
425 Value::U64(value) => num_to_i128!(value),
426 Value::U128(value) => num_to_i128!(value),
427 Value::F32(value) => num_to_i128!(value),
428 Value::F64(value) => num_to_i128!(value),
429 Value::Str(value) => value.parse::<i128>().map_err(|_| ConvertError {
430 value: v.clone(),
431 data_type: DataType::Int128,
432 })?,
433 Value::Decimal(value) => num_to_i128!(value),
434
435 Value::Date(_)
436 | Value::Timestamp(_)
437 | Value::Time(_)
438 | Value::Interval(_)
439 | Value::Uuid(_)
440 | Value::Map(_)
441 | Value::List(_)
442 | Value::Bytea(_)
443 | Value::Point(_)
444 | Value::Inet(_)
445 | Value::Null => {
446 return Err(ConvertError {
447 value: v.clone(),
448 data_type: DataType::Int128,
449 })
450 }
451 })
452 }
453}
454
455impl TryFrom<&Value> for u8 {
456 type Error = ConvertError;
457
458 fn try_from(v: &Value) -> Result<u8> {
459 macro_rules! num_to_u8 {
460 ($num: ident) => {
461 $num.to_u8().ok_or_else(|| ConvertError {
462 value: v.clone(),
463 data_type: DataType::Uint8,
464 })?
465 };
466 }
467
468 Ok(match v {
469 Value::Bool(value) => u8::from(*value),
470 Value::I8(value) => num_to_u8!(value),
471 Value::I16(value) => num_to_u8!(value),
472 Value::I32(value) => num_to_u8!(value),
473 Value::I64(value) => num_to_u8!(value),
474 Value::I128(value) => num_to_u8!(value),
475 Value::U8(value) => *value,
476 Value::U16(value) => num_to_u8!(value),
477 Value::U32(value) => num_to_u8!(value),
478 Value::U64(value) => num_to_u8!(value),
479 Value::U128(value) => num_to_u8!(value),
480 Value::F32(value) => num_to_u8!(value),
481 Value::F64(value) => num_to_u8!(value),
482 Value::Str(value) => value.parse::<u8>().map_err(|_| ConvertError {
483 value: v.clone(),
484 data_type: DataType::Uint8,
485 })?,
486 Value::Decimal(value) => num_to_u8!(value),
487
488 Value::Date(_)
489 | Value::Timestamp(_)
490 | Value::Time(_)
491 | Value::Interval(_)
492 | Value::Uuid(_)
493 | Value::Map(_)
494 | Value::List(_)
495 | Value::Bytea(_)
496 | Value::Point(_)
497 | Value::Inet(_)
498 | Value::Null => {
499 return Err(ConvertError {
500 value: v.clone(),
501 data_type: DataType::Uint8,
502 })
503 }
504 })
505 }
506}
507impl TryFrom<&Value> for u16 {
508 type Error = ConvertError;
509
510 fn try_from(v: &Value) -> Result<u16> {
511 macro_rules! num_to_u16 {
512 ($num: ident) => {
513 $num.to_u16().ok_or_else(|| ConvertError {
514 value: v.clone(),
515 data_type: DataType::Uint16,
516 })?
517 };
518 }
519
520 Ok(match v {
521 Value::Bool(value) => u16::from(*value),
522 Value::I8(value) => num_to_u16!(value),
523 Value::I16(value) => num_to_u16!(value),
524 Value::I32(value) => num_to_u16!(value),
525 Value::I64(value) => num_to_u16!(value),
526 Value::I128(value) => num_to_u16!(value),
527 Value::U8(value) => u16::from(*value),
528 Value::U16(value) => *value,
529 Value::U32(value) => num_to_u16!(value),
530 Value::U64(value) => num_to_u16!(value),
531 Value::U128(value) => num_to_u16!(value),
532 Value::F32(value) => num_to_u16!(value),
533 Value::F64(value) => num_to_u16!(value),
534 Value::Str(value) => value.parse::<u16>().map_err(|_| ConvertError {
535 value: v.clone(),
536 data_type: DataType::Uint16,
537 })?,
538 Value::Decimal(value) => num_to_u16!(value),
539
540 Value::Date(_)
541 | Value::Timestamp(_)
542 | Value::Time(_)
543 | Value::Interval(_)
544 | Value::Uuid(_)
545 | Value::Map(_)
546 | Value::List(_)
547 | Value::Bytea(_)
548 | Value::Point(_)
549 | Value::Inet(_)
550 | Value::Null => {
551 return Err(ConvertError {
552 value: v.clone(),
553 data_type: DataType::Uint16,
554 })
555 }
556 })
557 }
558}
559
560impl TryFrom<&Value> for u32 {
561 type Error = ConvertError;
562
563 fn try_from(v: &Value) -> Result<u32> {
564 macro_rules! num_to_u32 {
565 ($num: ident) => {
566 $num.to_u32().ok_or_else(|| ConvertError {
567 value: v.clone(),
568 data_type: DataType::Uint32,
569 })?
570 };
571 }
572
573 Ok(match v {
574 Value::Bool(value) => u32::from(*value),
575 Value::I8(value) => num_to_u32!(value),
576 Value::I16(value) => num_to_u32!(value),
577 Value::I32(value) => num_to_u32!(value),
578 Value::I64(value) => num_to_u32!(value),
579 Value::I128(value) => num_to_u32!(value),
580 Value::U8(value) => u32::from(*value),
581 Value::U16(value) => u32::from(*value),
582 Value::U32(value) => *value,
583 Value::U64(value) => num_to_u32!(value),
584 Value::U128(value) => num_to_u32!(value),
585 Value::F32(value) => num_to_u32!(value),
586 Value::F64(value) => num_to_u32!(value),
587 Value::Str(value) => value.parse::<u32>().map_err(|_| ConvertError {
588 value: v.clone(),
589 data_type: DataType::Uint32,
590 })?,
591 Value::Decimal(value) => num_to_u32!(value),
592 Value::Inet(IpAddr::V4(value)) => u32::from(*value),
593
594 Value::Date(_)
595 | Value::Timestamp(_)
596 | Value::Time(_)
597 | Value::Interval(_)
598 | Value::Uuid(_)
599 | Value::Inet(_)
600 | Value::Map(_)
601 | Value::List(_)
602 | Value::Bytea(_)
603 | Value::Point(_)
604 | Value::Null => {
605 return Err(ConvertError {
606 value: v.clone(),
607 data_type: DataType::Uint32,
608 })
609 }
610 })
611 }
612}
613
614impl TryFrom<&Value> for u64 {
615 type Error = ConvertError;
616
617 fn try_from(v: &Value) -> Result<u64> {
618 macro_rules! num_to_u64 {
619 ($num: ident) => {
620 $num.to_u64().ok_or_else(|| ConvertError {
621 value: v.clone(),
622 data_type: DataType::Uint64,
623 })?
624 };
625 }
626
627 Ok(match v {
628 Value::Bool(value) => u64::from(*value),
629 Value::I8(value) => num_to_u64!(value),
630 Value::I16(value) => num_to_u64!(value),
631 Value::I32(value) => num_to_u64!(value),
632 Value::I64(value) => num_to_u64!(value),
633 Value::I128(value) => num_to_u64!(value),
634 Value::U8(value) => u64::from(*value),
635 Value::U16(value) => u64::from(*value),
636 Value::U32(value) => u64::from(*value),
637 Value::U64(value) => *value,
638 Value::U128(value) => num_to_u64!(value),
639 Value::F32(value) => num_to_u64!(value),
640 Value::F64(value) => num_to_u64!(value),
641 Value::Str(value) => value.parse::<u64>().map_err(|_| ConvertError {
642 value: v.clone(),
643 data_type: DataType::Uint64,
644 })?,
645 Value::Decimal(value) => num_to_u64!(value),
646
647 Value::Date(_)
648 | Value::Timestamp(_)
649 | Value::Time(_)
650 | Value::Interval(_)
651 | Value::Uuid(_)
652 | Value::Inet(_)
653 | Value::Map(_)
654 | Value::List(_)
655 | Value::Bytea(_)
656 | Value::Point(_)
657 | Value::Null => {
658 return Err(ConvertError {
659 value: v.clone(),
660 data_type: DataType::Uint64,
661 })
662 }
663 })
664 }
665}
666
667impl TryFrom<&Value> for u128 {
668 type Error = ConvertError;
669
670 fn try_from(v: &Value) -> Result<u128> {
671 macro_rules! num_to_u128 {
672 ($num: ident) => {
673 $num.to_u128().ok_or_else(|| ConvertError {
674 value: v.clone(),
675 data_type: DataType::Uint128,
676 })?
677 };
678 }
679
680 Ok(match v {
681 Value::Bool(value) => u128::from(*value),
682 Value::I8(value) => num_to_u128!(value),
683 Value::I16(value) => num_to_u128!(value),
684 Value::I32(value) => num_to_u128!(value),
685 Value::I64(value) => num_to_u128!(value),
686 Value::I128(value) => num_to_u128!(value),
687 Value::U8(value) => u128::from(*value),
688 Value::U16(value) => u128::from(*value),
689 Value::U32(value) => u128::from(*value),
690 Value::U64(value) => u128::from(*value),
691 Value::U128(value) => *value,
692 Value::F32(value) => num_to_u128!(value),
693 Value::F64(value) => num_to_u128!(value),
694 Value::Str(value) => value.parse::<u128>().map_err(|_| ConvertError {
695 value: v.clone(),
696 data_type: DataType::Uint128,
697 })?,
698 Value::Decimal(value) => num_to_u128!(value),
699 Value::Inet(IpAddr::V6(v)) => u128::from(*v),
700 Value::Uuid(value) => *value,
701 Value::Date(_)
702 | Value::Timestamp(_)
703 | Value::Time(_)
704 | Value::Interval(_)
705 | Value::Map(_)
706 | Value::List(_)
707 | Value::Inet(IpAddr::V4(_))
708 | Value::Bytea(_)
709 | Value::Point(_)
710 | Value::Null => {
711 return Err(ConvertError {
712 value: v.clone(),
713 data_type: DataType::Uint128,
714 })
715 }
716 })
717 }
718}
719
720impl TryFrom<&Value> for f32 {
721 type Error = ConvertError;
722
723 fn try_from(v: &Value) -> Result<f32> {
724 macro_rules! num_to_f32 {
725 ($num: ident) => {
726 $num.to_f32().ok_or_else(|| ConvertError {
727 value: v.clone(),
728 data_type: DataType::Float32,
729 })?
730 };
731 }
732
733 Ok(match v {
734 Value::Bool(value) => {
735 if *value {
736 1.0
737 } else {
738 0.0
739 }
740 }
741 Value::I8(value) => num_to_f32!(value),
742 Value::I16(value) => num_to_f32!(value),
743 Value::I32(value) => num_to_f32!(value),
744 Value::I64(value) => num_to_f32!(value),
745 Value::I128(value) => num_to_f32!(value),
746 Value::U8(value) => num_to_f32!(value),
747 Value::U16(value) => num_to_f32!(value),
748 Value::U32(value) => num_to_f32!(value),
749 Value::U64(value) => num_to_f32!(value),
750 Value::U128(value) => num_to_f32!(value),
751 Value::F32(value) => *value,
752 Value::F64(value) => num_to_f32!(value),
753 Value::Str(value) => value.parse::<f32>().map_err(|_| ConvertError {
754 value: v.clone(),
755 data_type: DataType::Float32,
756 })?,
757 Value::Decimal(value) => num_to_f32!(value),
758
759 Value::Date(_)
760 | Value::Timestamp(_)
761 | Value::Time(_)
762 | Value::Interval(_)
763 | Value::Uuid(_)
764 | Value::Map(_)
765 | Value::List(_)
766 | Value::Bytea(_)
767 | Value::Point(_)
768 | Value::Inet(_)
769 | Value::Null => {
770 return Err(ConvertError {
771 value: v.clone(),
772 data_type: DataType::Float32,
773 })
774 }
775 })
776 }
777}
778
779impl TryFrom<&Value> for f64 {
780 type Error = ConvertError;
781
782 fn try_from(v: &Value) -> Result<f64> {
783 macro_rules! num_to_f64 {
784 ($num: ident) => {
785 $num.to_f64().ok_or_else(|| ConvertError {
786 value: v.clone(),
787 data_type: DataType::Float,
788 })?
789 };
790 }
791
792 Ok(match v {
793 Value::Bool(value) => {
794 if *value {
795 1.0
796 } else {
797 0.0
798 }
799 }
800 Value::I8(value) => num_to_f64!(value),
801 Value::I16(value) => num_to_f64!(value),
802 Value::I32(value) => num_to_f64!(value),
803 Value::I64(value) => num_to_f64!(value),
804 Value::I128(value) => num_to_f64!(value),
805 Value::U8(value) => num_to_f64!(value),
806 Value::U16(value) => num_to_f64!(value),
807 Value::U32(value) => num_to_f64!(value),
808 Value::U64(value) => num_to_f64!(value),
809 Value::U128(value) => num_to_f64!(value),
810 Value::F32(value) => num_to_f64!(value),
811 Value::F64(value) => *value,
812 Value::Str(value) => value.parse::<f64>().map_err(|_| ConvertError {
813 value: v.clone(),
814 data_type: DataType::Float,
815 })?,
816 Value::Decimal(value) => num_to_f64!(value),
817
818 Value::Date(_)
819 | Value::Timestamp(_)
820 | Value::Time(_)
821 | Value::Interval(_)
822 | Value::Uuid(_)
823 | Value::Map(_)
824 | Value::List(_)
825 | Value::Bytea(_)
826 | Value::Point(_)
827 | Value::Inet(_)
828 | Value::Null => {
829 return Err(ConvertError {
830 value: v.clone(),
831 data_type: DataType::Float,
832 })
833 }
834 })
835 }
836}
837
838impl TryFrom<&Value> for usize {
839 type Error = ConvertError;
840
841 fn try_from(v: &Value) -> Result<usize> {
842 let err = || ConvertError {
843 value: v.clone(),
844 #[cfg(target_pointer_width = "64")]
845 data_type: DataType::Uint64,
846 #[cfg(target_pointer_width = "32")]
847 data_type: DataType::Uint32,
848 };
849
850 macro_rules! num_to_usize {
851 ($num: ident) => {
852 $num.to_usize().ok_or_else(err)?
853 };
854 }
855
856 Ok(match v {
857 Value::Bool(value) => usize::from(*value),
858 Value::I8(value) => num_to_usize!(value),
859 Value::I16(value) => num_to_usize!(value),
860 Value::I32(value) => num_to_usize!(value),
861 Value::I64(value) => num_to_usize!(value),
862 Value::I128(value) => num_to_usize!(value),
863 Value::U8(value) => num_to_usize!(value),
864 Value::U16(value) => num_to_usize!(value),
865 Value::U32(value) => num_to_usize!(value),
866 Value::U64(value) => num_to_usize!(value),
867 Value::U128(value) => num_to_usize!(value),
868 Value::F32(value) => num_to_usize!(value),
869 Value::F64(value) => num_to_usize!(value),
870 Value::Str(value) => value.parse::<usize>().map_err(|_| err())?,
871 Value::Decimal(value) => num_to_usize!(value),
872
873 Value::Date(_)
874 | Value::Timestamp(_)
875 | Value::Time(_)
876 | Value::Interval(_)
877 | Value::Uuid(_)
878 | Value::Map(_)
879 | Value::List(_)
880 | Value::Bytea(_)
881 | Value::Point(_)
882 | Value::Inet(_)
883 | Value::Null => return Err(err()),
884 })
885 }
886}
887
888impl TryFrom<&Value> for Decimal {
889 type Error = ConvertError;
890
891 fn try_from(v: &Value) -> Result<Decimal> {
892 macro_rules! num_to_decimal {
893 ($num: expr, $method: ident) => {
894 Decimal::$method($num).ok_or_else(|| ConvertError {
895 value: v.clone(),
896 data_type: DataType::Decimal,
897 })?
898 };
899 }
900
901 Ok(match v {
902 Value::Bool(value) => {
903 if *value {
904 Decimal::ONE
905 } else {
906 Decimal::ZERO
907 }
908 }
909 Value::I8(value) => num_to_decimal!(*value, from_i8),
910 Value::I16(value) => num_to_decimal!(*value, from_i16),
911 Value::I32(value) => num_to_decimal!(*value, from_i32),
912 Value::I64(value) => num_to_decimal!(*value, from_i64),
913 Value::I128(value) => num_to_decimal!(*value, from_i128),
914 Value::U8(value) => num_to_decimal!(*value, from_u8),
915 Value::U16(value) => num_to_decimal!(*value, from_u16),
916 Value::U32(value) => num_to_decimal!(*value, from_u32),
917 Value::U64(value) => num_to_decimal!(*value, from_u64),
918 Value::U128(value) => num_to_decimal!(*value, from_u128),
919 Value::F32(value) => num_to_decimal!(*value, from_f32),
920 Value::F64(value) => num_to_decimal!(*value, from_f64),
921 Value::Str(value) => Decimal::from_str(value).map_err(|_| ConvertError {
922 value: v.clone(),
923 data_type: DataType::Decimal,
924 })?,
925 Value::Decimal(value) => *value,
926
927 Value::Date(_)
928 | Value::Timestamp(_)
929 | Value::Time(_)
930 | Value::Interval(_)
931 | Value::Uuid(_)
932 | Value::Map(_)
933 | Value::List(_)
934 | Value::Bytea(_)
935 | Value::Point(_)
936 | Value::Inet(_)
937 | Value::Null => {
938 return Err(ConvertError {
939 value: v.clone(),
940 data_type: DataType::Decimal,
941 })
942 }
943 })
944 }
945}
946
947impl TryFrom<&Value> for NaiveDate {
948 type Error = ConvertError;
949
950 fn try_from(v: &Value) -> Result<NaiveDate> {
951 Ok(match v {
952 Value::Date(value) => *value,
953 Value::Timestamp(value) => value.date(),
954 Value::Str(value) => parse_date(value).ok_or_else(|| ConvertError {
955 value: v.clone(),
956 data_type: DataType::Date,
957 })?,
958
959 _ => {
960 return Err(ConvertError {
961 value: v.clone(),
962 data_type: DataType::Date,
963 })
964 }
965 })
966 }
967}
968
969impl TryFrom<&Value> for NaiveTime {
970 type Error = ConvertError;
971
972 fn try_from(v: &Value) -> Result<NaiveTime> {
973 Ok(match v {
974 Value::Time(value) => *value,
975 Value::Str(value) => parse_time(value).ok_or_else(|| ConvertError {
976 value: v.clone(),
977 data_type: DataType::Time,
978 })?,
979
980 _ => {
981 return Err(ConvertError {
982 value: v.clone(),
983 data_type: DataType::Time,
984 })
985 }
986 })
987 }
988}
989
990impl TryFrom<&Value> for NaiveDateTime {
991 type Error = ConvertError;
992
993 fn try_from(v: &Value) -> Result<NaiveDateTime> {
994 Ok(match v {
995 Value::Date(value) => value.and_hms_opt(0, 0, 0).ok_or_else(|| ConvertError {
996 value: v.clone(),
997 data_type: DataType::Timestamp,
998 })?,
999 Value::Str(value) => parse_timestamp(value).ok_or_else(|| ConvertError {
1000 value: v.clone(),
1001 data_type: DataType::Timestamp,
1002 })?,
1003 Value::Timestamp(value) => *value,
1004
1005 _ => {
1006 return Err(ConvertError {
1007 value: v.clone(),
1008 data_type: DataType::Timestamp,
1009 })
1010 }
1011 })
1012 }
1013}
1014
1015impl TryFrom<&Value> for IpAddr {
1016 type Error = ConvertError;
1017
1018 fn try_from(v: &Value) -> Result<IpAddr> {
1019 Ok(match v {
1020 Value::Inet(value) => *value,
1021 Value::Str(value) => IpAddr::from_str(value).map_err(|_| ConvertError {
1022 value: v.clone(),
1023 data_type: DataType::Inet,
1024 })?,
1025
1026 _ => {
1027 return Err(ConvertError {
1028 value: v.clone(),
1029 data_type: DataType::Inet,
1030 })
1031 }
1032 })
1033 }
1034}
1035
1036impl TryFrom<&Value> for Point {
1037 type Error = ConvertError;
1038
1039 fn try_from(v: &Value) -> Result<Point> {
1040 Ok(match v {
1041 Value::Point(value) => *value,
1042 Value::Str(value) => Point::from_wkt(value).map_err(|_| ConvertError {
1043 value: v.clone(),
1044 data_type: DataType::Point,
1045 })?,
1046
1047 _ => {
1048 return Err(ConvertError {
1049 value: v.clone(),
1050 data_type: DataType::Point,
1051 })
1052 }
1053 })
1054 }
1055}
1056
1057#[cfg(test)]
1058mod tests {
1059 use {
1060 super::{ConvertError, Result, Value},
1061 crate::{ast::DataType, data::point, data::Interval as I, data::Point},
1062 chrono::{self, NaiveDate, NaiveDateTime, NaiveTime},
1063 rust_decimal::Decimal,
1064 std::{
1065 collections::HashMap,
1066 net::{IpAddr, Ipv4Addr, Ipv6Addr},
1067 str::FromStr,
1068 },
1069 };
1070
1071 fn timestamp(y: i32, m: u32, d: u32, hh: u32, mm: u32, ss: u32, ms: u32) -> NaiveDateTime {
1072 NaiveDate::from_ymd_opt(y, m, d)
1073 .unwrap()
1074 .and_hms_milli_opt(hh, mm, ss, ms)
1075 .unwrap()
1076 }
1077
1078 fn time(hour: u32, min: u32, sec: u32, milli: u32) -> NaiveTime {
1079 NaiveTime::from_hms_milli_opt(hour, min, sec, milli).unwrap()
1080 }
1081
1082 fn date(year: i32, month: u32, day: u32) -> NaiveDate {
1083 NaiveDate::from_ymd_opt(year, month, day).unwrap()
1084 }
1085
1086 #[test]
1087 fn from() {
1088 macro_rules! test {
1089 ($from: expr, $to: expr) => {
1090 assert_eq!(String::from($from), $to.to_owned())
1091 };
1092 }
1093
1094 test!(Value::Str("text".to_owned()), "text");
1095 test!(Value::Bytea(hex::decode("1234").unwrap()), "1234");
1096 test!(Value::Inet(IpAddr::from_str("::1").unwrap()), "::1");
1097 test!(Value::Bool(true), "TRUE");
1098 test!(Value::I8(122), "122");
1099 test!(Value::I16(122), "122");
1100 test!(Value::I32(122), "122");
1101 test!(Value::I64(1234567890), "1234567890");
1102 test!(Value::I128(1234567890), "1234567890");
1103 test!(Value::U8(122), "122");
1104 test!(Value::U16(122), "122");
1105 test!(Value::U32(122), "122");
1106 test!(Value::U64(122), "122");
1107 test!(Value::U128(122), "122");
1108 test!(Value::F32(123456.1_f32), "123456.1");
1109 test!(Value::F64(1234567890.0987), "1234567890.0987");
1110 test!(Value::Date(date(2021, 11, 20)), "2021-11-20");
1111 test!(
1112 Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)),
1113 "2021-11-20 10:00:00"
1114 );
1115 test!(Value::Time(time(10, 0, 0, 0)), "10:00:00");
1116 test!(Value::Interval(I::Month(1)), I::Month(1).to_sql_str());
1117 test!(
1118 Value::Uuid(195965723427462096757863453463987888808),
1119 "936da01f-9abd-4d9d-80c7-02af85c822a8"
1120 );
1121 test!(Value::Map(HashMap::new()), "{}");
1122 test!(Value::List(Vec::new()), "[]");
1123
1124 let mut map = HashMap::new();
1125 map.insert("abc".to_owned(), Value::I32(123));
1126 test!(Value::Map(map), "{\"abc\":123}");
1127 test!(Value::List(vec![Value::I32(1), Value::I32(2)]), "[1,2]");
1128 test!(
1129 Value::Point(point::Point::new(1.0313, 2.0314)),
1130 "POINT(1.0313 2.0314)"
1131 );
1132 test!(Value::Decimal(Decimal::new(2000, 1)), "200.0");
1133 test!(Value::Null, "NULL");
1134 }
1135
1136 #[test]
1137 fn try_into_bool() {
1138 macro_rules! test {
1139 ($from: expr, $to: expr) => {
1140 assert_eq!((&$from).try_into() as Result<bool>, $to);
1141 assert_eq!(bool::try_from(&$from), $to);
1142 };
1143 }
1144
1145 macro_rules! err {
1146 ($from: expr) => {
1147 test!(
1148 $from,
1149 Err(ConvertError {
1150 value: $from.clone(),
1151 data_type: DataType::Boolean,
1152 })
1153 )
1154 };
1155 }
1156
1157 test!(Value::Bool(true), Ok(true));
1158 test!(Value::I8(1), Ok(true));
1159 test!(Value::I8(0), Ok(false));
1160 test!(Value::I16(1), Ok(true));
1161 test!(Value::I16(0), Ok(false));
1162 test!(Value::I32(1), Ok(true));
1163 test!(Value::I32(0), Ok(false));
1164 test!(Value::I64(1), Ok(true));
1165 test!(Value::I64(0), Ok(false));
1166 test!(Value::I128(1), Ok(true));
1167 test!(Value::I128(0), Ok(false));
1168 test!(Value::U8(1), Ok(true));
1169 test!(Value::U8(0), Ok(false));
1170
1171 test!(Value::U16(1), Ok(true));
1172 test!(Value::U16(0), Ok(false));
1173 test!(Value::U32(1), Ok(true));
1174 test!(Value::U32(0), Ok(false));
1175 test!(Value::U64(1), Ok(true));
1176 test!(Value::U64(0), Ok(false));
1177 test!(Value::U128(1), Ok(true));
1178 test!(Value::U128(0), Ok(false));
1179
1180 test!(Value::F32(1.0_f32), Ok(true));
1181 test!(Value::F32(0.0_f32), Ok(false));
1182 test!(Value::F64(1.0), Ok(true));
1183 test!(Value::F64(0.0), Ok(false));
1184 test!(Value::Str("true".to_owned()), Ok(true));
1185 test!(Value::Str("false".to_owned()), Ok(false));
1186 test!(Value::Decimal(Decimal::new(10, 1)), Ok(true));
1187 test!(Value::Decimal(Decimal::new(0, 1)), Ok(false));
1188
1189 err!(Value::I8(3));
1190 err!(Value::I16(3));
1191 err!(Value::I32(3));
1192 err!(Value::I64(3));
1193 err!(Value::I128(3));
1194 err!(Value::U8(3));
1195 err!(Value::U16(3));
1196 err!(Value::U32(3));
1197 err!(Value::U64(3));
1198 err!(Value::U128(3));
1199 err!(Value::F32(2.0_f32));
1200 err!(Value::F64(2.0));
1201 err!(Value::Decimal(Decimal::new(2, 0)));
1202 err!(Value::Str("text".to_owned()));
1203 err!(Value::Bytea(Vec::new()));
1204 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1205 err!(Value::Date(date(2021, 11, 20)));
1206 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1207 err!(Value::Time(time(10, 0, 0, 0)));
1208 err!(Value::Interval(I::Month(1)));
1209 err!(Value::Uuid(195965723427462096757863453463987888808));
1210 err!(Value::Map(HashMap::new()));
1211 err!(Value::List(Vec::new()));
1212 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1213 err!(Value::Null);
1214 }
1215
1216 #[test]
1217 fn try_into_i8() {
1218 macro_rules! test {
1219 ($from: expr, $to: expr) => {
1220 assert_eq!((&$from).try_into() as Result<i8>, $to);
1221 assert_eq!(i8::try_from(&$from), $to);
1222 };
1223 }
1224
1225 macro_rules! err {
1226 ($from: expr) => {
1227 test!(
1228 $from,
1229 Err(ConvertError {
1230 value: $from.clone(),
1231 data_type: DataType::Int8,
1232 })
1233 )
1234 };
1235 }
1236
1237 test!(Value::Bool(true), Ok(1));
1238 test!(Value::Bool(false), Ok(0));
1239 test!(Value::I8(122), Ok(122));
1240 test!(Value::I16(122), Ok(122));
1241 test!(Value::I32(122), Ok(122));
1242 test!(Value::I64(122), Ok(122));
1243 test!(Value::I128(122), Ok(122));
1244 test!(Value::U8(122), Ok(122));
1245 test!(Value::U16(122), Ok(122));
1246 test!(Value::U32(122), Ok(122));
1247 test!(Value::U64(122), Ok(122));
1248 test!(Value::U128(122), Ok(122));
1249 test!(Value::F32(122.0_f32), Ok(122));
1250 test!(Value::F64(122.0), Ok(122));
1251 test!(Value::Str("122".to_owned()), Ok(122));
1252 test!(Value::Decimal(Decimal::new(123, 0)), Ok(123));
1253
1254 err!(Value::I16(128));
1255 err!(Value::I32(128));
1256 err!(Value::I64(128));
1257 err!(Value::I128(128));
1258 err!(Value::U8(128));
1259 err!(Value::U16(128));
1260 err!(Value::U32(128));
1261 err!(Value::U64(128));
1262 err!(Value::U128(128));
1263 err!(Value::F32(128.0_f32));
1264 err!(Value::F64(128.0));
1265 err!(Value::Decimal(Decimal::new(128, 0)));
1266 err!(Value::Str("text".to_owned()));
1267 err!(Value::Bytea(Vec::new()));
1268 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1269 err!(Value::Date(date(2021, 11, 20)));
1270 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1271 err!(Value::Time(time(10, 0, 0, 0)));
1272 err!(Value::Interval(I::Month(1)));
1273 err!(Value::Uuid(195965723427462096757863453463987888808));
1274 err!(Value::Map(HashMap::new()));
1275 err!(Value::List(Vec::new()));
1276 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1277 err!(Value::Null);
1278 }
1279
1280 #[test]
1281 fn try_into_i16() {
1282 macro_rules! test {
1283 ($from: expr, $to: expr) => {
1284 assert_eq!((&$from).try_into() as Result<i16>, $to);
1285 assert_eq!(i16::try_from(&$from), $to);
1286 };
1287 }
1288
1289 macro_rules! err {
1290 ($from: expr) => {
1291 test!(
1292 $from,
1293 Err(ConvertError {
1294 value: $from.clone(),
1295 data_type: DataType::Int16,
1296 })
1297 )
1298 };
1299 }
1300
1301 test!(Value::Bool(true), Ok(1));
1302 test!(Value::Bool(false), Ok(0));
1303 test!(Value::I8(122), Ok(122));
1304 test!(Value::I16(122), Ok(122));
1305 test!(Value::I32(122), Ok(122));
1306 test!(Value::I64(122), Ok(122));
1307 test!(Value::I128(122), Ok(122));
1308 test!(Value::U8(122), Ok(122));
1309 test!(Value::U16(122), Ok(122));
1310 test!(Value::U32(122), Ok(122));
1311 test!(Value::U64(122), Ok(122));
1312 test!(Value::U128(122), Ok(122));
1313 test!(Value::F32(122.0_f32), Ok(122));
1314 test!(Value::F32(122.1_f32), Ok(122));
1315 test!(Value::F64(122.0), Ok(122));
1316 test!(Value::F64(122.1), Ok(122));
1317 test!(Value::Str("122".to_owned()), Ok(122));
1318 test!(Value::Decimal(Decimal::new(122, 0)), Ok(122));
1319
1320 err!(Value::I32(i32::MAX));
1321 err!(Value::I64(i64::MAX));
1322 err!(Value::I128(i128::MAX));
1323
1324 err!(Value::U16(u16::MAX));
1325 err!(Value::U32(u32::MAX));
1326 err!(Value::U64(u64::MAX));
1327 err!(Value::U128(u128::MAX));
1328
1329 err!(Value::F32(f32::MAX));
1330 err!(Value::F64(f64::MAX));
1331 err!(Value::Decimal(Decimal::new(i64::MAX, 0)));
1332 err!(Value::Str("text".to_owned()));
1333 err!(Value::Bytea(Vec::new()));
1334 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1335 err!(Value::Date(date(2021, 11, 20)));
1336 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1337 err!(Value::Time(time(10, 0, 0, 0)));
1338 err!(Value::Interval(I::Month(1)));
1339 err!(Value::Uuid(195965723427462096757863453463987888808));
1340 err!(Value::Map(HashMap::new()));
1341 err!(Value::List(Vec::new()));
1342 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1343 err!(Value::Null);
1344 }
1345
1346 #[test]
1347 fn try_into_i32() {
1348 macro_rules! test {
1349 ($from: expr, $to: expr) => {
1350 assert_eq!((&$from).try_into() as Result<i32>, $to);
1351 assert_eq!(i32::try_from(&$from), $to);
1352 };
1353 }
1354
1355 macro_rules! err {
1356 ($from: expr) => {
1357 test!(
1358 $from,
1359 Err(ConvertError {
1360 value: $from.clone(),
1361 data_type: DataType::Int32,
1362 })
1363 )
1364 };
1365 }
1366
1367 test!(Value::Bool(true), Ok(1));
1368 test!(Value::Bool(false), Ok(0));
1369 test!(Value::I8(122), Ok(122));
1370 test!(Value::I16(122), Ok(122));
1371 test!(Value::I32(122), Ok(122));
1372 test!(Value::I64(122), Ok(122));
1373 test!(Value::I128(122), Ok(122));
1374 test!(Value::U8(122), Ok(122));
1375 test!(Value::U16(122), Ok(122));
1376 test!(Value::U32(122), Ok(122));
1377 test!(Value::U64(122), Ok(122));
1378 test!(Value::U128(122), Ok(122));
1379 test!(Value::I64(1234567890), Ok(1234567890));
1380 test!(Value::F32(1234567890.0_f32), Ok(1234567890.0_f32 as i32));
1381 test!(Value::F32(1234567890.1_f32), Ok(1234567890.1_f32 as i32));
1382 test!(Value::F64(1234567890.0), Ok(1234567890));
1383 test!(Value::F64(1234567890.1), Ok(1234567890));
1384 test!(Value::Str("1234567890".to_owned()), Ok(1234567890));
1385 test!(Value::Decimal(Decimal::new(1234567890, 0)), Ok(1234567890));
1386
1387 err!(Value::I64(i64::MAX));
1388 err!(Value::I128(i128::MAX));
1389
1390 err!(Value::U32(u32::MAX));
1391 err!(Value::U64(u64::MAX));
1392 err!(Value::U128(u128::MAX));
1393
1394 err!(Value::F32(f32::MAX));
1395 err!(Value::F64(f64::MAX));
1396
1397 err!(Value::Decimal(Decimal::new(i64::MAX, 0)));
1398 err!(Value::Str("text".to_owned()));
1399 err!(Value::Bytea(Vec::new()));
1400 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1401 err!(Value::Date(date(2021, 11, 20)));
1402 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1403 err!(Value::Time(time(10, 0, 0, 0)));
1404 err!(Value::Interval(I::Month(1)));
1405 err!(Value::Uuid(195965723427462096757863453463987888808));
1406 err!(Value::Map(HashMap::new()));
1407 err!(Value::List(Vec::new()));
1408 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1409 err!(Value::Null);
1410 }
1411
1412 #[test]
1413 fn try_into_i64() {
1414 macro_rules! test {
1415 ($from: expr, $to: expr) => {
1416 assert_eq!((&$from).try_into() as Result<i64>, $to);
1417 assert_eq!(i64::try_from(&$from), $to);
1418 };
1419 }
1420
1421 macro_rules! err {
1422 ($from: expr) => {
1423 test!(
1424 $from,
1425 Err(ConvertError {
1426 value: $from.clone(),
1427 data_type: DataType::Int,
1428 })
1429 )
1430 };
1431 }
1432
1433 test!(Value::Bool(true), Ok(1));
1434 test!(Value::Bool(false), Ok(0));
1435 test!(Value::I8(122), Ok(122));
1436 test!(Value::I16(122), Ok(122));
1437 test!(Value::I32(122), Ok(122));
1438 test!(Value::I64(122), Ok(122));
1439 test!(Value::I128(122), Ok(122));
1440 test!(Value::U8(122), Ok(122));
1441 test!(Value::U16(122), Ok(122));
1442 test!(Value::U32(122), Ok(122));
1443 test!(Value::U64(122), Ok(122));
1444 test!(Value::U128(122), Ok(122));
1445 test!(Value::I64(1234567890), Ok(1234567890));
1446 test!(Value::F32(1234567890.0_f32), Ok(1234567890.0_f32 as i64));
1447 test!(Value::F32(1234567890.1_f32), Ok(1234567890.1_f32 as i64));
1448 test!(Value::F64(1234567890.0), Ok(1234567890));
1449 test!(Value::F64(1234567890.1), Ok(1234567890));
1450 test!(Value::Str("1234567890".to_owned()), Ok(1234567890));
1451 test!(Value::Decimal(Decimal::new(1234567890, 0)), Ok(1234567890));
1452
1453 err!(Value::I128(i128::MAX));
1454
1455 err!(Value::U64(u64::MAX));
1456 err!(Value::U128(u128::MAX));
1457
1458 err!(Value::F32(f32::MAX));
1459 err!(Value::F64(f64::MAX));
1460
1461 err!(Value::Str("text".to_owned()));
1462 err!(Value::Bytea(Vec::new()));
1463 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1464 err!(Value::Date(date(2021, 11, 20)));
1465 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1466 err!(Value::Time(time(10, 0, 0, 0)));
1467 err!(Value::Interval(I::Month(1)));
1468 err!(Value::Uuid(195965723427462096757863453463987888808));
1469 err!(Value::Map(HashMap::new()));
1470 err!(Value::List(Vec::new()));
1471 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1472 err!(Value::Null);
1473 }
1474
1475 #[test]
1476 fn try_into_i128() {
1477 macro_rules! test {
1478 ($from: expr, $to: expr) => {
1479 assert_eq!((&$from).try_into() as Result<i128>, $to);
1480 assert_eq!(i128::try_from(&$from), $to);
1481 };
1482 }
1483
1484 macro_rules! err {
1485 ($from: expr) => {
1486 test!(
1487 $from,
1488 Err(ConvertError {
1489 value: $from.clone(),
1490 data_type: DataType::Int128,
1491 })
1492 )
1493 };
1494 }
1495
1496 test!(Value::Bool(true), Ok(1));
1497 test!(Value::Bool(false), Ok(0));
1498 test!(Value::I8(122), Ok(122));
1499 test!(Value::I16(122), Ok(122));
1500 test!(Value::I32(122), Ok(122));
1501 test!(Value::I64(122), Ok(122));
1502 test!(Value::I128(122), Ok(122));
1503 test!(Value::U8(122), Ok(122));
1504 test!(Value::U16(122), Ok(122));
1505 test!(Value::U32(122), Ok(122));
1506 test!(Value::U64(122), Ok(122));
1507 test!(Value::U128(122), Ok(122));
1508 test!(Value::I64(1234567890), Ok(1234567890));
1509 test!(Value::F32(1234567890.0_f32), Ok(1234567890.0_f32 as i128));
1510 test!(Value::F32(1234567890.9_f32), Ok(1234567890.9_f32 as i128));
1511 test!(Value::F64(1234567890.0), Ok(1234567890));
1512 test!(Value::F64(1234567890.9), Ok(1234567890));
1513 test!(Value::Str("1234567890".to_owned()), Ok(1234567890));
1514 test!(Value::Decimal(Decimal::new(1234567890, 0)), Ok(1234567890));
1515
1516 err!(Value::U128(u128::MAX));
1517
1518 err!(Value::F32(f32::MAX));
1519 err!(Value::F64(f64::MAX));
1520
1521 err!(Value::Str("text".to_owned()));
1522 err!(Value::Bytea(Vec::new()));
1523 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1524 err!(Value::Date(date(2021, 11, 20)));
1525 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1526 err!(Value::Time(time(10, 0, 0, 0)));
1527 err!(Value::Interval(I::Month(1)));
1528 err!(Value::Uuid(195965723427462096757863453463987888808));
1529 err!(Value::Map(HashMap::new()));
1530 err!(Value::List(Vec::new()));
1531 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1532 err!(Value::Null);
1533 }
1534
1535 #[test]
1536 fn try_into_u8() {
1537 macro_rules! test {
1538 ($from: expr, $to: expr) => {
1539 assert_eq!((&$from).try_into() as Result<u8>, $to);
1540 assert_eq!(u8::try_from(&$from), $to);
1541 };
1542 }
1543
1544 macro_rules! err {
1545 ($from: expr) => {
1546 test!(
1547 $from,
1548 Err(ConvertError {
1549 value: $from.clone(),
1550 data_type: DataType::Uint8,
1551 })
1552 )
1553 };
1554 }
1555
1556 test!(Value::Bool(true), Ok(1));
1557 test!(Value::Bool(false), Ok(0));
1558 test!(Value::I8(122), Ok(122));
1559 test!(Value::I16(122), Ok(122));
1560 test!(Value::I32(122), Ok(122));
1561 test!(Value::I64(122), Ok(122));
1562 test!(Value::I128(122), Ok(122));
1563 test!(Value::U8(122), Ok(122));
1564 test!(Value::U16(122), Ok(122));
1565 test!(Value::U32(122), Ok(122));
1566 test!(Value::U64(122), Ok(122));
1567 test!(Value::U128(122), Ok(122));
1568 test!(Value::F32(122.0_f32), Ok(122));
1569 test!(Value::F32(122.9_f32), Ok(122));
1570 test!(Value::F64(122.0), Ok(122));
1571 test!(Value::F64(122.9), Ok(122));
1572 test!(Value::Str("122".to_owned()), Ok(122));
1573 test!(Value::Decimal(Decimal::new(123, 0)), Ok(123));
1574
1575 err!(Value::I16(256));
1577 err!(Value::I32(256));
1578 err!(Value::I64(256));
1579 err!(Value::I128(256));
1580
1581 err!(Value::U16(256));
1582 err!(Value::U32(256));
1583 err!(Value::U64(256));
1584 err!(Value::U128(256));
1585
1586 err!(Value::F32(256.0_f32));
1587 err!(Value::F64(256.0));
1588
1589 err!(Value::Decimal(Decimal::new(256, 0)));
1590 err!(Value::Str("text".to_owned()));
1591 err!(Value::Bytea(Vec::new()));
1592 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1593 err!(Value::List(Vec::new()));
1594 err!(Value::Date(date(2021, 11, 20)));
1595 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1596 err!(Value::Time(time(10, 0, 0, 0)));
1597 err!(Value::Interval(I::Month(1)));
1598 err!(Value::Uuid(195965723427462096757863453463987888808));
1599 err!(Value::Map(HashMap::new()));
1600 err!(Value::List(Vec::new()));
1601 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1602 err!(Value::Null);
1603 }
1604
1605 #[test]
1606 fn try_into_u16() {
1607 macro_rules! test {
1608 ($from: expr, $to: expr) => {
1609 assert_eq!((&$from).try_into() as Result<u16>, $to);
1610 assert_eq!(u16::try_from(&$from), $to);
1611 };
1612 }
1613
1614 macro_rules! err {
1615 ($from: expr) => {
1616 test!(
1617 $from,
1618 Err(ConvertError {
1619 value: $from.clone(),
1620 data_type: DataType::Uint16,
1621 })
1622 )
1623 };
1624 }
1625
1626 test!(Value::Bool(true), Ok(1));
1627 test!(Value::Bool(false), Ok(0));
1628 test!(Value::I8(122), Ok(122));
1629 test!(Value::I16(122), Ok(122));
1630 test!(Value::I32(122), Ok(122));
1631 test!(Value::I64(122), Ok(122));
1632 test!(Value::I128(122), Ok(122));
1633 test!(Value::U8(122), Ok(122));
1634 test!(Value::U16(122), Ok(122));
1635 test!(Value::U32(122), Ok(122));
1636 test!(Value::U64(122), Ok(122));
1637 test!(Value::U128(122), Ok(122));
1638 test!(Value::F32(122.0_f32), Ok(122));
1639 test!(Value::F32(122.1_f32), Ok(122));
1640 test!(Value::F64(122.0), Ok(122));
1641 test!(Value::F64(122.1), Ok(122));
1642 test!(Value::Str("122".to_owned()), Ok(122));
1643 test!(Value::Decimal(Decimal::new(122, 0)), Ok(122));
1644
1645 err!(Value::I32(65536));
1646 err!(Value::I64(65536));
1647 err!(Value::I128(65536));
1648
1649 err!(Value::U32(65536));
1650 err!(Value::U64(65536));
1651 err!(Value::U128(65536));
1652
1653 err!(Value::F32(65536.0_f32));
1654 err!(Value::F64(65536.0));
1655
1656 err!(Value::Decimal(Decimal::new(65536, 0)));
1657 err!(Value::Str("text".to_owned()));
1658 err!(Value::Bytea(Vec::new()));
1659 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1660 err!(Value::Date(date(2021, 11, 20)));
1661 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1662 err!(Value::Time(time(10, 0, 0, 0)));
1663 err!(Value::Interval(I::Month(1)));
1664 err!(Value::Uuid(195965723427462096757863453463987888808));
1665 err!(Value::Map(HashMap::new()));
1666 err!(Value::List(Vec::new()));
1667 err!(Value::Null);
1668 }
1669
1670 #[test]
1671 fn try_into_u32() {
1672 macro_rules! test {
1673 ($from: expr, $to: expr) => {
1674 assert_eq!((&$from).try_into() as Result<u32>, $to);
1675 assert_eq!(u32::try_from(&$from), $to);
1676 };
1677 }
1678
1679 macro_rules! err {
1680 ($from: expr) => {
1681 test!(
1682 $from,
1683 Err(ConvertError {
1684 value: $from.clone(),
1685 data_type: DataType::Uint32,
1686 })
1687 )
1688 };
1689 }
1690
1691 test!(Value::Bool(true), Ok(1));
1692 test!(Value::Bool(false), Ok(0));
1693 test!(Value::I8(122), Ok(122));
1694 test!(Value::I16(122), Ok(122));
1695 test!(Value::I32(122), Ok(122));
1696 test!(Value::I64(122), Ok(122));
1697 test!(Value::I128(122), Ok(122));
1698 test!(Value::U8(122), Ok(122));
1699 test!(Value::U16(122), Ok(122));
1700 test!(Value::U32(122), Ok(122));
1701 test!(Value::U64(122), Ok(122));
1702 test!(Value::U128(122), Ok(122));
1703 test!(Value::F32(122.0_f32), Ok(122));
1704 test!(Value::F32(122.1_f32), Ok(122));
1705 test!(Value::F64(122.0), Ok(122));
1706 test!(Value::F64(122.1), Ok(122));
1707 test!(Value::Str("122".to_owned()), Ok(122));
1708 test!(Value::Decimal(Decimal::new(122, 0)), Ok(122));
1709
1710 err!(Value::I64(i64::MAX));
1711 err!(Value::I128(i128::MAX));
1712
1713 err!(Value::U64(u64::MAX));
1714 err!(Value::U128(u128::MAX));
1715
1716 err!(Value::F32(f32::MAX));
1717 err!(Value::F64(f64::MAX));
1718
1719 err!(Value::Decimal(Decimal::new(i64::MAX, 0)));
1720 err!(Value::Str("text".to_owned()));
1721 err!(Value::Bytea(Vec::new()));
1722 err!(Value::Inet(IpAddr::from_str("::0").unwrap()));
1723 err!(Value::Date(date(2021, 11, 20)));
1724 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1725 err!(Value::Time(time(10, 0, 0, 0)));
1726 err!(Value::Interval(I::Month(1)));
1727 err!(Value::Uuid(195965723427462096757863453463987888808));
1728 err!(Value::Map(HashMap::new()));
1729 err!(Value::List(Vec::new()));
1730 err!(Value::Null);
1731
1732 assert_eq!(
1733 u32::try_from(&Value::Inet(IpAddr::from_str("0.0.0.0").unwrap())),
1734 Ok(u32::from(Ipv4Addr::from(0)))
1735 );
1736 }
1737
1738 #[test]
1739 fn try_into_u64() {
1740 macro_rules! test {
1741 ($from: expr, $to: expr) => {
1742 assert_eq!((&$from).try_into() as Result<u64>, $to);
1743 assert_eq!(u64::try_from(&$from), $to);
1744 };
1745 }
1746
1747 macro_rules! err {
1748 ($from: expr) => {
1749 test!(
1750 $from,
1751 Err(ConvertError {
1752 value: $from.clone(),
1753 data_type: DataType::Uint64,
1754 })
1755 )
1756 };
1757 }
1758
1759 test!(Value::Bool(true), Ok(1));
1760 test!(Value::Bool(false), Ok(0));
1761 test!(Value::I8(122), Ok(122));
1762 test!(Value::I16(122), Ok(122));
1763 test!(Value::I32(122), Ok(122));
1764 test!(Value::I64(122), Ok(122));
1765 test!(Value::I128(122), Ok(122));
1766 test!(Value::U8(122), Ok(122));
1767 test!(Value::U16(122), Ok(122));
1768 test!(Value::U32(122), Ok(122));
1769 test!(Value::U64(122), Ok(122));
1770 test!(Value::U128(122), Ok(122));
1771 test!(Value::F32(122.0_f32), Ok(122));
1772 test!(Value::F32(122.1_f32), Ok(122));
1773 test!(Value::F64(122.0), Ok(122));
1774 test!(Value::F64(122.1), Ok(122));
1775 test!(Value::Str("122".to_owned()), Ok(122));
1776 test!(Value::Decimal(Decimal::new(122, 0)), Ok(122));
1777
1778 err!(Value::I128(i128::MIN));
1779
1780 err!(Value::U128(u128::MAX));
1781
1782 err!(Value::F32(f32::MIN));
1783 err!(Value::F64(f64::MIN));
1784
1785 err!(Value::Decimal(Decimal::new(i64::MIN, 0)));
1786 err!(Value::Str("text".to_owned()));
1787 err!(Value::Bytea(Vec::new()));
1788 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1789 err!(Value::Date(date(2021, 11, 20)));
1790 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1791 err!(Value::Time(time(10, 0, 0, 0)));
1792 err!(Value::Interval(I::Month(1)));
1793 err!(Value::Uuid(195965723427462096757863453463987888808));
1794 err!(Value::Map(HashMap::new()));
1795 err!(Value::List(Vec::new()));
1796 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1797 err!(Value::Null);
1798 }
1799
1800 #[test]
1801 fn try_into_u128() {
1802 macro_rules! test {
1803 ($from: expr, $to: expr) => {
1804 assert_eq!((&$from).try_into() as Result<u128>, $to);
1805 assert_eq!(u128::try_from(&$from), $to);
1806 };
1807 }
1808
1809 macro_rules! err {
1810 ($from: expr) => {
1811 test!(
1812 $from,
1813 Err(ConvertError {
1814 value: $from.clone(),
1815 data_type: DataType::Uint128,
1816 })
1817 )
1818 };
1819 }
1820
1821 test!(Value::Bool(true), Ok(1));
1822 test!(Value::Bool(false), Ok(0));
1823 test!(Value::I8(122), Ok(122));
1824 test!(Value::I16(122), Ok(122));
1825 test!(Value::I32(122), Ok(122));
1826 test!(Value::I64(122), Ok(122));
1827 test!(Value::I128(122), Ok(122));
1828 test!(Value::U8(122), Ok(122));
1829 test!(Value::U16(122), Ok(122));
1830 test!(Value::U32(122), Ok(122));
1831 test!(Value::U64(122), Ok(122));
1832 test!(Value::U128(122), Ok(122));
1833 test!(Value::F32(122.0_f32), Ok(122));
1834 test!(Value::F32(122.1_f32), Ok(122));
1835 test!(Value::F64(122.0), Ok(122));
1836 test!(Value::F64(122.1), Ok(122));
1837 test!(Value::Str("122".to_owned()), Ok(122));
1838 test!(Value::Decimal(Decimal::new(122, 0)), Ok(122));
1839
1840 err!(Value::F32(f32::MIN));
1841 err!(Value::F64(f64::MIN));
1842
1843 err!(Value::Decimal(Decimal::new(i64::MIN, 0)));
1844 err!(Value::Str("text".to_owned()));
1845 err!(Value::Bytea(Vec::new()));
1846
1847 err!(Value::Date(date(2021, 11, 20)));
1848 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1849 err!(Value::Time(time(10, 0, 0, 0)));
1850 err!(Value::Interval(I::Month(1)));
1851 err!(Value::Map(HashMap::new()));
1852 err!(Value::List(Vec::new()));
1853 err!(Value::Null);
1854
1855 let uuid = 195965723427462096757863453463987888808;
1856 assert_eq!((&Value::Uuid(uuid)).try_into() as Result<u128>, Ok(uuid));
1857 assert_eq!(u128::try_from(&Value::Uuid(uuid)), Ok(uuid));
1858
1859 let ip = Ipv6Addr::from(9876543210);
1860 assert_eq!(
1861 u128::try_from(&Value::Inet(IpAddr::V6(ip))),
1862 Ok(u128::from(ip))
1863 );
1864 }
1865
1866 #[test]
1867 fn try_into_f32() {
1868 macro_rules! test {
1869 ($from: expr, $to: expr) => {
1870 assert_eq!((&$from).try_into() as Result<f32>, $to);
1871 assert_eq!(f32::try_from(&$from), $to);
1872 };
1873 }
1874
1875 macro_rules! err {
1876 ($from: expr) => {
1877 test!(
1878 $from,
1879 Err(ConvertError {
1880 value: $from.clone(),
1881 data_type: DataType::Float32,
1882 })
1883 )
1884 };
1885 }
1886
1887 test!(Value::Bool(true), Ok(1.0_f32));
1888 test!(Value::Bool(false), Ok(0.0_f32));
1889 test!(Value::I8(122), Ok(122.0_f32));
1890 test!(Value::I16(122), Ok(122.0_f32));
1891 test!(Value::I32(122), Ok(122.0_f32));
1892 test!(Value::I64(122), Ok(122.0_f32));
1893 test!(Value::I128(122), Ok(122.0_f32));
1894 test!(Value::U8(122), Ok(122.0_f32));
1895 test!(Value::U16(122), Ok(122.0_f32));
1896 test!(Value::U32(122), Ok(122.0_f32));
1897 test!(Value::U64(122), Ok(122.0_f32));
1898 test!(Value::U128(122), Ok(122.0_f32));
1899 test!(Value::I64(1234567890), Ok(1234567890.0_f32));
1900 test!(Value::F64(1234567890.1), Ok(1234567890.1_f32));
1901 test!(Value::F32(1234567890.1_f32), Ok(1234567890.1_f32));
1902 test!(Value::Str("1234567890.1".to_owned()), Ok(1234567890.1_f32));
1903 test!(
1904 Value::Decimal(Decimal::new(12345678901, 1)),
1905 Ok(1234567890.1_f32)
1906 );
1907
1908 err!(Value::Str("text".to_owned()));
1909 err!(Value::Bytea(Vec::new()));
1910 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1911 err!(Value::Date(date(2021, 11, 20)));
1912 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1913 err!(Value::Time(time(10, 0, 0, 0)));
1914 err!(Value::Interval(I::Month(1)));
1915 err!(Value::Uuid(195965723427462096757863453463987888808));
1916 err!(Value::Map(HashMap::new()));
1917 err!(Value::List(Vec::new()));
1918 err!(Value::Null);
1919 }
1920
1921 #[test]
1922 fn try_into_f64() {
1923 macro_rules! test {
1924 ($from: expr, $to: expr) => {
1925 assert_eq!((&$from).try_into() as Result<f64>, $to);
1926 assert_eq!(f64::try_from(&$from), $to);
1927 };
1928 }
1929
1930 macro_rules! err {
1931 ($from: expr) => {
1932 test!(
1933 $from,
1934 Err(ConvertError {
1935 value: $from.clone(),
1936 data_type: DataType::Float,
1937 })
1938 )
1939 };
1940 }
1941
1942 test!(Value::Bool(true), Ok(1.0));
1943 test!(Value::Bool(false), Ok(0.0));
1944 test!(Value::I8(122), Ok(122.0));
1945 test!(Value::I16(122), Ok(122.0));
1946 test!(Value::I32(122), Ok(122.0));
1947 test!(Value::I64(122), Ok(122.0));
1948 test!(Value::I128(122), Ok(122.0));
1949 test!(Value::U8(122), Ok(122.0));
1950 test!(Value::U16(122), Ok(122.0));
1951 test!(Value::U32(122), Ok(122.0));
1952 test!(Value::U64(122), Ok(122.0));
1953 test!(Value::U128(122), Ok(122.0));
1954 test!(Value::I64(1234567890), Ok(1234567890.0));
1955 test!(Value::F32(1234567890.1_f32), Ok(1234567890.1_f32 as f64));
1956 test!(Value::F64(1234567890.1), Ok(1234567890.1));
1957 test!(Value::Str("1234567890.1".to_owned()), Ok(1234567890.1));
1958 test!(
1959 Value::Decimal(Decimal::new(12345678901, 1)),
1960 Ok(1234567890.1)
1961 );
1962
1963 err!(Value::Str("text".to_owned()));
1964 err!(Value::Bytea(Vec::new()));
1965 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1966 err!(Value::Date(date(2021, 11, 20)));
1967 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1968 err!(Value::Time(time(10, 0, 0, 0)));
1969 err!(Value::Interval(I::Month(1)));
1970 err!(Value::Uuid(195965723427462096757863453463987888808));
1971 err!(Value::Map(HashMap::new()));
1972 err!(Value::List(Vec::new()));
1973 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1974 err!(Value::Null);
1975 }
1976
1977 #[test]
1978 fn try_into_usize() {
1979 macro_rules! test {
1980 ($from: expr, $to: expr) => {
1981 assert_eq!((&$from).try_into() as Result<usize>, $to);
1982 assert_eq!(usize::try_from(&$from), $to);
1983 };
1984 }
1985
1986 let err = |value: Value| ConvertError {
1987 value,
1988 #[cfg(target_pointer_width = "64")]
1989 data_type: DataType::Uint64,
1990 #[cfg(target_pointer_width = "32")]
1991 data_type: DataType::Uint32,
1992 };
1993 macro_rules! err {
1994 ($from: expr) => {
1995 test!($from, Err(err($from.clone())))
1996 };
1997 }
1998
1999 test!(Value::Bool(true), Ok(1usize));
2000 test!(Value::Bool(false), Ok(0));
2001 test!(Value::I8(122), Ok(122));
2002 test!(Value::I16(122), Ok(122));
2003 test!(Value::I32(122), Ok(122));
2004 test!(Value::I64(122), Ok(122));
2005 test!(Value::I128(122), Ok(122));
2006 test!(Value::U8(122), Ok(122));
2007 test!(Value::U16(122), Ok(122));
2008 test!(Value::U32(122), Ok(122));
2009 test!(Value::U64(122), Ok(122));
2010 test!(Value::U128(122), Ok(122));
2011 test!(Value::I64(1234567890), Ok(1234567890));
2012 test!(Value::F32(1234567890.0_f32), Ok(1234567890.0_f32 as usize));
2013 test!(Value::F32(1234567890.1_f32), Ok(1234567890.1_f32 as usize));
2014 test!(Value::F64(1234567890.0), Ok(1234567890));
2015 test!(Value::F64(1234567890.1), Ok(1234567890));
2016 test!(Value::Str("1234567890".to_owned()), Ok(1234567890));
2017 test!(Value::Decimal(Decimal::new(1234567890, 0)), Ok(1234567890));
2018
2019 err!(Value::I128(i128::MIN));
2020
2021 err!(Value::U128(u128::MAX));
2022
2023 err!(Value::F32(f32::MIN));
2024 err!(Value::F64(f64::MIN));
2025
2026 err!(Value::Decimal(Decimal::new(i64::MIN, 0)));
2027 err!(Value::Str("text".to_owned()));
2028 err!(Value::Bytea(Vec::new()));
2029 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
2030 err!(Value::Date(date(2021, 11, 20)));
2031 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
2032 err!(Value::Time(time(10, 0, 0, 0)));
2033 err!(Value::Interval(I::Month(1)));
2034 err!(Value::Uuid(195965723427462096757863453463987888808));
2035 err!(Value::Map(HashMap::new()));
2036 err!(Value::List(Vec::new()));
2037 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
2038 err!(Value::Null);
2039 }
2040
2041 #[test]
2042 fn try_into_decimal() {
2043 macro_rules! test {
2044 ($from: expr, $to: expr) => {
2045 assert_eq!((&$from).try_into() as Result<Decimal>, $to);
2046 assert_eq!(Decimal::try_from(&$from), $to);
2047 };
2048 }
2049
2050 macro_rules! err {
2051 ($from: expr) => {
2052 test!(
2053 $from,
2054 Err(ConvertError {
2055 value: $from.clone(),
2056 data_type: DataType::Decimal,
2057 })
2058 )
2059 };
2060 }
2061
2062 test!(Value::Bool(true), Ok(Decimal::new(1, 0)));
2063 test!(Value::Bool(false), Ok(Decimal::new(0, 0)));
2064 test!(Value::I8(122), Ok(Decimal::new(122, 0)));
2065 test!(Value::I16(122), Ok(Decimal::new(122, 0)));
2066 test!(Value::I32(122), Ok(Decimal::new(122, 0)));
2067 test!(Value::I64(122), Ok(Decimal::new(122, 0)));
2068 test!(Value::I128(122), Ok(Decimal::new(122, 0)));
2069 test!(Value::U8(122), Ok(Decimal::new(122, 0)));
2070 test!(Value::U16(122), Ok(Decimal::new(122, 0)));
2071 test!(Value::U32(122), Ok(Decimal::new(122, 0)));
2072 test!(Value::U64(122), Ok(Decimal::new(122, 0)));
2073 test!(Value::U128(122), Ok(Decimal::new(122, 0)));
2074 test!(Value::F32(122.0_f32), Ok(Decimal::new(122, 0)));
2075 test!(Value::F32(122.1_f32), Ok(Decimal::new(1221, 1)));
2076 test!(Value::F64(122.0), Ok(Decimal::new(122, 0)));
2077 test!(Value::F64(122.1), Ok(Decimal::new(1221, 1)));
2078 test!(Value::Str("122".to_owned()), Ok(Decimal::new(122, 0)));
2079 test!(
2080 Value::Decimal(Decimal::new(122, 0)),
2081 Ok(Decimal::new(122, 0))
2082 );
2083
2084 err!(Value::Str("text".to_owned()));
2085 err!(Value::Bytea(Vec::new()));
2086 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
2087 err!(Value::Date(date(2021, 11, 20)));
2088 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
2089 err!(Value::Time(time(10, 0, 0, 0)));
2090 err!(Value::Interval(I::Month(1)));
2091 err!(Value::Uuid(195965723427462096757863453463987888808));
2092 err!(Value::Map(HashMap::new()));
2093 err!(Value::List(Vec::new()));
2094 err!(Value::Null);
2095 }
2096
2097 #[test]
2098 fn try_into_naive_date() {
2099 macro_rules! test {
2100 ($from: expr, $to: expr) => {
2101 assert_eq!((&$from).try_into() as Result<chrono::NaiveDate>, $to);
2102 assert_eq!(chrono::NaiveDate::try_from(&$from), $to);
2103 };
2104 }
2105
2106 macro_rules! err {
2107 ($from: expr) => {
2108 test!(
2109 $from,
2110 Err(ConvertError {
2111 value: $from.clone(),
2112 data_type: DataType::Date,
2113 })
2114 )
2115 };
2116 }
2117
2118 test!(Value::Date(date(2021, 11, 20)), Ok(date(2021, 11, 20)));
2119 test!(
2120 Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)),
2121 Ok(date(2021, 11, 20))
2122 );
2123 test!(Value::Str("2021-11-20".to_owned()), Ok(date(2021, 11, 20)));
2124
2125 err!(Value::F32(1.0_f32));
2126 err!(Value::F64(1.0));
2127 }
2128
2129 #[test]
2130 fn try_into_naive_time() {
2131 macro_rules! test {
2132 ($from: expr, $to: expr) => {
2133 assert_eq!((&$from).try_into() as Result<chrono::NaiveTime>, $to);
2134 assert_eq!(chrono::NaiveTime::try_from(&$from), $to);
2135 };
2136 }
2137
2138 macro_rules! err {
2139 ($from: expr) => {
2140 test!(
2141 $from,
2142 Err(ConvertError {
2143 value: $from.clone(),
2144 data_type: DataType::Time,
2145 })
2146 )
2147 };
2148 }
2149
2150 test!(Value::Time(time(10, 0, 0, 0)), Ok(time(10, 0, 0, 0)));
2151 test!(Value::Str("10:00:00".to_owned()), Ok(time(10, 0, 0, 0)));
2152
2153 err!(Value::F32(1.0_f32));
2154 err!(Value::F64(1.0));
2155 }
2156
2157 #[test]
2158 fn try_into_naive_date_time() {
2159 macro_rules! test {
2160 ($from: expr, $to: expr) => {
2161 assert_eq!((&$from).try_into() as Result<chrono::NaiveDateTime>, $to);
2162 assert_eq!(chrono::NaiveDateTime::try_from(&$from), $to);
2163 };
2164 }
2165
2166 macro_rules! err {
2167 ($from: expr) => {
2168 test!(
2169 $from,
2170 Err(ConvertError {
2171 value: $from.clone(),
2172 data_type: DataType::Timestamp,
2173 })
2174 )
2175 };
2176 }
2177
2178 let datetime = chrono::NaiveDateTime::new;
2179 test!(
2180 Value::Date(date(2021, 11, 20)),
2181 Ok(datetime(date(2021, 11, 20), time(0, 0, 0, 0)))
2182 );
2183 test!(
2184 Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)),
2185 Ok(datetime(date(2021, 11, 20), time(10, 0, 0, 0)))
2186 );
2187 test!(
2188 Value::Str("2021-11-20".to_owned()),
2189 Ok(datetime(date(2021, 11, 20), time(0, 0, 0, 0)))
2190 );
2191
2192 err!(Value::F32(1.0_f32));
2193 err!(Value::F64(1.0));
2194 }
2195
2196 #[test]
2197 fn try_into_ipaddr() {
2198 macro_rules! test {
2199 ($from: expr, $to: literal) => {
2200 assert_eq!(IpAddr::try_from($from), Ok(IpAddr::from_str($to).unwrap()));
2201 };
2202
2203 ($from: expr, $to: expr) => {
2204 assert_eq!(IpAddr::try_from($from), $to);
2205 };
2206 }
2207
2208 macro_rules! err {
2209 ($from: expr) => {
2210 test!(
2211 $from,
2212 Err(ConvertError {
2213 value: $from.clone(),
2214 data_type: DataType::Inet,
2215 })
2216 )
2217 };
2218 }
2219
2220 test!(&Value::Inet(IpAddr::from_str("::1").unwrap()), "::1");
2221 test!(&Value::Str("127.0.0.1".to_owned()), "127.0.0.1");
2222 test!(&Value::Str("0.0.0.0".to_owned()), "0.0.0.0");
2223 test!(IpAddr::from_str("::1").unwrap(), "::1");
2224 test!(IpAddr::from_str("::2:4cb0:16ea").unwrap(), "::2:4cb0:16ea");
2225
2226 err!(&Value::Date(date(2021, 11, 20)));
2227 }
2228
2229 #[test]
2230 fn try_into_point() {
2231 macro_rules! err {
2232 ($from: expr) => {
2233 assert_eq!(
2234 Point::try_from($from),
2235 Err(ConvertError {
2236 value: $from.clone(),
2237 data_type: DataType::Point,
2238 })
2239 );
2240 };
2241 }
2242
2243 assert_eq!(
2244 Point::try_from(&Value::Str("POINT(0.2 0.1)".to_owned())),
2245 Ok(Point::from_wkt("POINT(0.2 0.1)").unwrap())
2246 );
2247 assert_eq!(
2248 Point::try_from(&Value::Point(Point::new(0.1, 0.2))),
2249 Ok(Point::from_wkt("POINT(0.1 0.2)").unwrap())
2250 );
2251
2252 err!(&Value::Date(date(2021, 11, 20)));
2253 }
2254}