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