1use {
2 super::{
3 Value,
4 date::{parse_date, parse_time, parse_timestamp},
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::{
1062 ast::DataType,
1063 data::{Interval as I, Point, point},
1064 },
1065 chrono::{self, NaiveDate, NaiveDateTime, NaiveTime},
1066 rust_decimal::Decimal,
1067 std::{
1068 collections::BTreeMap,
1069 net::{IpAddr, Ipv4Addr, Ipv6Addr},
1070 str::FromStr,
1071 },
1072 };
1073
1074 fn timestamp(y: i32, m: u32, d: u32, hh: u32, mm: u32, ss: u32, ms: u32) -> NaiveDateTime {
1075 NaiveDate::from_ymd_opt(y, m, d)
1076 .unwrap()
1077 .and_hms_milli_opt(hh, mm, ss, ms)
1078 .unwrap()
1079 }
1080
1081 fn time(hour: u32, min: u32, sec: u32, milli: u32) -> NaiveTime {
1082 NaiveTime::from_hms_milli_opt(hour, min, sec, milli).unwrap()
1083 }
1084
1085 fn date(year: i32, month: u32, day: u32) -> NaiveDate {
1086 NaiveDate::from_ymd_opt(year, month, day).unwrap()
1087 }
1088
1089 #[test]
1090 fn from() {
1091 macro_rules! test {
1092 ($from: expr, $to: expr) => {
1093 assert_eq!(String::from($from), $to.to_owned())
1094 };
1095 }
1096
1097 test!(Value::Str("text".to_owned()), "text");
1098 test!(Value::Bytea(hex::decode("1234").unwrap()), "1234");
1099 test!(Value::Inet(IpAddr::from_str("::1").unwrap()), "::1");
1100 test!(Value::Bool(true), "TRUE");
1101 test!(Value::I8(122), "122");
1102 test!(Value::I16(122), "122");
1103 test!(Value::I32(122), "122");
1104 test!(Value::I64(1234567890), "1234567890");
1105 test!(Value::I128(1234567890), "1234567890");
1106 test!(Value::U8(122), "122");
1107 test!(Value::U16(122), "122");
1108 test!(Value::U32(122), "122");
1109 test!(Value::U64(122), "122");
1110 test!(Value::U128(122), "122");
1111 test!(Value::F32(123456.1_f32), "123456.1");
1112 test!(Value::F64(1234567890.0987), "1234567890.0987");
1113 test!(Value::Date(date(2021, 11, 20)), "2021-11-20");
1114 test!(
1115 Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)),
1116 "2021-11-20 10:00:00"
1117 );
1118 test!(Value::Time(time(10, 0, 0, 0)), "10:00:00");
1119 test!(Value::Interval(I::Month(1)), I::Month(1).to_sql_str());
1120 test!(
1121 Value::Uuid(195965723427462096757863453463987888808),
1122 "936da01f-9abd-4d9d-80c7-02af85c822a8"
1123 );
1124 test!(Value::Map(BTreeMap::new()), "{}");
1125 test!(Value::List(Vec::new()), "[]");
1126
1127 let mut map = BTreeMap::new();
1128 map.insert("abc".to_owned(), Value::I32(123));
1129 test!(Value::Map(map), "{\"abc\":123}");
1130 test!(Value::List(vec![Value::I32(1), Value::I32(2)]), "[1,2]");
1131 test!(
1132 Value::Point(point::Point::new(1.0313, 2.0314)),
1133 "POINT(1.0313 2.0314)"
1134 );
1135 test!(Value::Decimal(Decimal::new(2000, 1)), "200.0");
1136 test!(Value::Null, "NULL");
1137 }
1138
1139 #[test]
1140 fn try_into_bool() {
1141 macro_rules! test {
1142 ($from: expr, $to: expr) => {
1143 assert_eq!((&$from).try_into() as Result<bool>, $to);
1144 assert_eq!(bool::try_from(&$from), $to);
1145 };
1146 }
1147
1148 macro_rules! err {
1149 ($from: expr) => {
1150 test!(
1151 $from,
1152 Err(ConvertError {
1153 value: $from.clone(),
1154 data_type: DataType::Boolean,
1155 })
1156 )
1157 };
1158 }
1159
1160 test!(Value::Bool(true), Ok(true));
1161 test!(Value::I8(1), Ok(true));
1162 test!(Value::I8(0), Ok(false));
1163 test!(Value::I16(1), Ok(true));
1164 test!(Value::I16(0), Ok(false));
1165 test!(Value::I32(1), Ok(true));
1166 test!(Value::I32(0), Ok(false));
1167 test!(Value::I64(1), Ok(true));
1168 test!(Value::I64(0), Ok(false));
1169 test!(Value::I128(1), Ok(true));
1170 test!(Value::I128(0), Ok(false));
1171 test!(Value::U8(1), Ok(true));
1172 test!(Value::U8(0), Ok(false));
1173
1174 test!(Value::U16(1), Ok(true));
1175 test!(Value::U16(0), Ok(false));
1176 test!(Value::U32(1), Ok(true));
1177 test!(Value::U32(0), Ok(false));
1178 test!(Value::U64(1), Ok(true));
1179 test!(Value::U64(0), Ok(false));
1180 test!(Value::U128(1), Ok(true));
1181 test!(Value::U128(0), Ok(false));
1182
1183 test!(Value::F32(1.0_f32), Ok(true));
1184 test!(Value::F32(0.0_f32), Ok(false));
1185 test!(Value::F64(1.0), Ok(true));
1186 test!(Value::F64(0.0), Ok(false));
1187 test!(Value::Str("true".to_owned()), Ok(true));
1188 test!(Value::Str("false".to_owned()), Ok(false));
1189 test!(Value::Decimal(Decimal::new(10, 1)), Ok(true));
1190 test!(Value::Decimal(Decimal::new(0, 1)), Ok(false));
1191
1192 err!(Value::I8(3));
1193 err!(Value::I16(3));
1194 err!(Value::I32(3));
1195 err!(Value::I64(3));
1196 err!(Value::I128(3));
1197 err!(Value::U8(3));
1198 err!(Value::U16(3));
1199 err!(Value::U32(3));
1200 err!(Value::U64(3));
1201 err!(Value::U128(3));
1202 err!(Value::F32(2.0_f32));
1203 err!(Value::F64(2.0));
1204 err!(Value::Decimal(Decimal::new(2, 0)));
1205 err!(Value::Str("text".to_owned()));
1206 err!(Value::Bytea(Vec::new()));
1207 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1208 err!(Value::Date(date(2021, 11, 20)));
1209 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1210 err!(Value::Time(time(10, 0, 0, 0)));
1211 err!(Value::Interval(I::Month(1)));
1212 err!(Value::Uuid(195965723427462096757863453463987888808));
1213 err!(Value::Map(BTreeMap::new()));
1214 err!(Value::List(Vec::new()));
1215 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1216 err!(Value::Null);
1217 }
1218
1219 #[test]
1220 fn try_into_i8() {
1221 macro_rules! test {
1222 ($from: expr, $to: expr) => {
1223 assert_eq!((&$from).try_into() as Result<i8>, $to);
1224 assert_eq!(i8::try_from(&$from), $to);
1225 };
1226 }
1227
1228 macro_rules! err {
1229 ($from: expr) => {
1230 test!(
1231 $from,
1232 Err(ConvertError {
1233 value: $from.clone(),
1234 data_type: DataType::Int8,
1235 })
1236 )
1237 };
1238 }
1239
1240 test!(Value::Bool(true), Ok(1));
1241 test!(Value::Bool(false), Ok(0));
1242 test!(Value::I8(122), Ok(122));
1243 test!(Value::I16(122), Ok(122));
1244 test!(Value::I32(122), Ok(122));
1245 test!(Value::I64(122), Ok(122));
1246 test!(Value::I128(122), Ok(122));
1247 test!(Value::U8(122), Ok(122));
1248 test!(Value::U16(122), Ok(122));
1249 test!(Value::U32(122), Ok(122));
1250 test!(Value::U64(122), Ok(122));
1251 test!(Value::U128(122), Ok(122));
1252 test!(Value::F32(122.0_f32), Ok(122));
1253 test!(Value::F64(122.0), Ok(122));
1254 test!(Value::Str("122".to_owned()), Ok(122));
1255 test!(Value::Decimal(Decimal::new(123, 0)), Ok(123));
1256
1257 err!(Value::I16(128));
1258 err!(Value::I32(128));
1259 err!(Value::I64(128));
1260 err!(Value::I128(128));
1261 err!(Value::U8(128));
1262 err!(Value::U16(128));
1263 err!(Value::U32(128));
1264 err!(Value::U64(128));
1265 err!(Value::U128(128));
1266 err!(Value::F32(128.0_f32));
1267 err!(Value::F64(128.0));
1268 err!(Value::Decimal(Decimal::new(128, 0)));
1269 err!(Value::Str("text".to_owned()));
1270 err!(Value::Bytea(Vec::new()));
1271 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1272 err!(Value::Date(date(2021, 11, 20)));
1273 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1274 err!(Value::Time(time(10, 0, 0, 0)));
1275 err!(Value::Interval(I::Month(1)));
1276 err!(Value::Uuid(195965723427462096757863453463987888808));
1277 err!(Value::Map(BTreeMap::new()));
1278 err!(Value::List(Vec::new()));
1279 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1280 err!(Value::Null);
1281 }
1282
1283 #[test]
1284 fn try_into_i16() {
1285 macro_rules! test {
1286 ($from: expr, $to: expr) => {
1287 assert_eq!((&$from).try_into() as Result<i16>, $to);
1288 assert_eq!(i16::try_from(&$from), $to);
1289 };
1290 }
1291
1292 macro_rules! err {
1293 ($from: expr) => {
1294 test!(
1295 $from,
1296 Err(ConvertError {
1297 value: $from.clone(),
1298 data_type: DataType::Int16,
1299 })
1300 )
1301 };
1302 }
1303
1304 test!(Value::Bool(true), Ok(1));
1305 test!(Value::Bool(false), Ok(0));
1306 test!(Value::I8(122), Ok(122));
1307 test!(Value::I16(122), Ok(122));
1308 test!(Value::I32(122), Ok(122));
1309 test!(Value::I64(122), Ok(122));
1310 test!(Value::I128(122), Ok(122));
1311 test!(Value::U8(122), Ok(122));
1312 test!(Value::U16(122), Ok(122));
1313 test!(Value::U32(122), Ok(122));
1314 test!(Value::U64(122), Ok(122));
1315 test!(Value::U128(122), Ok(122));
1316 test!(Value::F32(122.0_f32), Ok(122));
1317 test!(Value::F32(122.1_f32), Ok(122));
1318 test!(Value::F64(122.0), Ok(122));
1319 test!(Value::F64(122.1), Ok(122));
1320 test!(Value::Str("122".to_owned()), Ok(122));
1321 test!(Value::Decimal(Decimal::new(122, 0)), Ok(122));
1322
1323 err!(Value::I32(i32::MAX));
1324 err!(Value::I64(i64::MAX));
1325 err!(Value::I128(i128::MAX));
1326
1327 err!(Value::U16(u16::MAX));
1328 err!(Value::U32(u32::MAX));
1329 err!(Value::U64(u64::MAX));
1330 err!(Value::U128(u128::MAX));
1331
1332 err!(Value::F32(f32::MAX));
1333 err!(Value::F64(f64::MAX));
1334 err!(Value::Decimal(Decimal::new(i64::MAX, 0)));
1335 err!(Value::Str("text".to_owned()));
1336 err!(Value::Bytea(Vec::new()));
1337 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1338 err!(Value::Date(date(2021, 11, 20)));
1339 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1340 err!(Value::Time(time(10, 0, 0, 0)));
1341 err!(Value::Interval(I::Month(1)));
1342 err!(Value::Uuid(195965723427462096757863453463987888808));
1343 err!(Value::Map(BTreeMap::new()));
1344 err!(Value::List(Vec::new()));
1345 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1346 err!(Value::Null);
1347 }
1348
1349 #[test]
1350 fn try_into_i32() {
1351 macro_rules! test {
1352 ($from: expr, $to: expr) => {
1353 assert_eq!((&$from).try_into() as Result<i32>, $to);
1354 assert_eq!(i32::try_from(&$from), $to);
1355 };
1356 }
1357
1358 macro_rules! err {
1359 ($from: expr) => {
1360 test!(
1361 $from,
1362 Err(ConvertError {
1363 value: $from.clone(),
1364 data_type: DataType::Int32,
1365 })
1366 )
1367 };
1368 }
1369
1370 test!(Value::Bool(true), Ok(1));
1371 test!(Value::Bool(false), Ok(0));
1372 test!(Value::I8(122), Ok(122));
1373 test!(Value::I16(122), Ok(122));
1374 test!(Value::I32(122), Ok(122));
1375 test!(Value::I64(122), Ok(122));
1376 test!(Value::I128(122), Ok(122));
1377 test!(Value::U8(122), Ok(122));
1378 test!(Value::U16(122), Ok(122));
1379 test!(Value::U32(122), Ok(122));
1380 test!(Value::U64(122), Ok(122));
1381 test!(Value::U128(122), Ok(122));
1382 test!(Value::I64(1234567890), Ok(1234567890));
1383 test!(Value::F32(1234567890.0_f32), Ok(1234567890.0_f32 as i32));
1384 test!(Value::F32(1234567890.1_f32), Ok(1234567890.1_f32 as i32));
1385 test!(Value::F64(1234567890.0), Ok(1234567890));
1386 test!(Value::F64(1234567890.1), Ok(1234567890));
1387 test!(Value::Str("1234567890".to_owned()), Ok(1234567890));
1388 test!(Value::Decimal(Decimal::new(1234567890, 0)), Ok(1234567890));
1389
1390 err!(Value::I64(i64::MAX));
1391 err!(Value::I128(i128::MAX));
1392
1393 err!(Value::U32(u32::MAX));
1394 err!(Value::U64(u64::MAX));
1395 err!(Value::U128(u128::MAX));
1396
1397 err!(Value::F32(f32::MAX));
1398 err!(Value::F64(f64::MAX));
1399
1400 err!(Value::Decimal(Decimal::new(i64::MAX, 0)));
1401 err!(Value::Str("text".to_owned()));
1402 err!(Value::Bytea(Vec::new()));
1403 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1404 err!(Value::Date(date(2021, 11, 20)));
1405 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1406 err!(Value::Time(time(10, 0, 0, 0)));
1407 err!(Value::Interval(I::Month(1)));
1408 err!(Value::Uuid(195965723427462096757863453463987888808));
1409 err!(Value::Map(BTreeMap::new()));
1410 err!(Value::List(Vec::new()));
1411 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1412 err!(Value::Null);
1413 }
1414
1415 #[test]
1416 fn try_into_i64() {
1417 macro_rules! test {
1418 ($from: expr, $to: expr) => {
1419 assert_eq!((&$from).try_into() as Result<i64>, $to);
1420 assert_eq!(i64::try_from(&$from), $to);
1421 };
1422 }
1423
1424 macro_rules! err {
1425 ($from: expr) => {
1426 test!(
1427 $from,
1428 Err(ConvertError {
1429 value: $from.clone(),
1430 data_type: DataType::Int,
1431 })
1432 )
1433 };
1434 }
1435
1436 test!(Value::Bool(true), Ok(1));
1437 test!(Value::Bool(false), Ok(0));
1438 test!(Value::I8(122), Ok(122));
1439 test!(Value::I16(122), Ok(122));
1440 test!(Value::I32(122), Ok(122));
1441 test!(Value::I64(122), Ok(122));
1442 test!(Value::I128(122), Ok(122));
1443 test!(Value::U8(122), Ok(122));
1444 test!(Value::U16(122), Ok(122));
1445 test!(Value::U32(122), Ok(122));
1446 test!(Value::U64(122), Ok(122));
1447 test!(Value::U128(122), Ok(122));
1448 test!(Value::I64(1234567890), Ok(1234567890));
1449 test!(Value::F32(1234567890.0_f32), Ok(1234567890.0_f32 as i64));
1450 test!(Value::F32(1234567890.1_f32), Ok(1234567890.1_f32 as i64));
1451 test!(Value::F64(1234567890.0), Ok(1234567890));
1452 test!(Value::F64(1234567890.1), Ok(1234567890));
1453 test!(Value::Str("1234567890".to_owned()), Ok(1234567890));
1454 test!(Value::Decimal(Decimal::new(1234567890, 0)), Ok(1234567890));
1455
1456 err!(Value::I128(i128::MAX));
1457
1458 err!(Value::U64(u64::MAX));
1459 err!(Value::U128(u128::MAX));
1460
1461 err!(Value::F32(f32::MAX));
1462 err!(Value::F64(f64::MAX));
1463
1464 err!(Value::Str("text".to_owned()));
1465 err!(Value::Bytea(Vec::new()));
1466 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1467 err!(Value::Date(date(2021, 11, 20)));
1468 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1469 err!(Value::Time(time(10, 0, 0, 0)));
1470 err!(Value::Interval(I::Month(1)));
1471 err!(Value::Uuid(195965723427462096757863453463987888808));
1472 err!(Value::Map(BTreeMap::new()));
1473 err!(Value::List(Vec::new()));
1474 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1475 err!(Value::Null);
1476 }
1477
1478 #[test]
1479 fn try_into_i128() {
1480 macro_rules! test {
1481 ($from: expr, $to: expr) => {
1482 assert_eq!((&$from).try_into() as Result<i128>, $to);
1483 assert_eq!(i128::try_from(&$from), $to);
1484 };
1485 }
1486
1487 macro_rules! err {
1488 ($from: expr) => {
1489 test!(
1490 $from,
1491 Err(ConvertError {
1492 value: $from.clone(),
1493 data_type: DataType::Int128,
1494 })
1495 )
1496 };
1497 }
1498
1499 test!(Value::Bool(true), Ok(1));
1500 test!(Value::Bool(false), Ok(0));
1501 test!(Value::I8(122), Ok(122));
1502 test!(Value::I16(122), Ok(122));
1503 test!(Value::I32(122), Ok(122));
1504 test!(Value::I64(122), Ok(122));
1505 test!(Value::I128(122), Ok(122));
1506 test!(Value::U8(122), Ok(122));
1507 test!(Value::U16(122), Ok(122));
1508 test!(Value::U32(122), Ok(122));
1509 test!(Value::U64(122), Ok(122));
1510 test!(Value::U128(122), Ok(122));
1511 test!(Value::I64(1234567890), Ok(1234567890));
1512 test!(Value::F32(1234567890.0_f32), Ok(1234567890.0_f32 as i128));
1513 test!(Value::F32(1234567890.9_f32), Ok(1234567890.9_f32 as i128));
1514 test!(Value::F64(1234567890.0), Ok(1234567890));
1515 test!(Value::F64(1234567890.9), Ok(1234567890));
1516 test!(Value::Str("1234567890".to_owned()), Ok(1234567890));
1517 test!(Value::Decimal(Decimal::new(1234567890, 0)), Ok(1234567890));
1518
1519 err!(Value::U128(u128::MAX));
1520
1521 err!(Value::F32(f32::MAX));
1522 err!(Value::F64(f64::MAX));
1523
1524 err!(Value::Str("text".to_owned()));
1525 err!(Value::Bytea(Vec::new()));
1526 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1527 err!(Value::Date(date(2021, 11, 20)));
1528 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1529 err!(Value::Time(time(10, 0, 0, 0)));
1530 err!(Value::Interval(I::Month(1)));
1531 err!(Value::Uuid(195965723427462096757863453463987888808));
1532 err!(Value::Map(BTreeMap::new()));
1533 err!(Value::List(Vec::new()));
1534 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1535 err!(Value::Null);
1536 }
1537
1538 #[test]
1539 fn try_into_u8() {
1540 macro_rules! test {
1541 ($from: expr, $to: expr) => {
1542 assert_eq!((&$from).try_into() as Result<u8>, $to);
1543 assert_eq!(u8::try_from(&$from), $to);
1544 };
1545 }
1546
1547 macro_rules! err {
1548 ($from: expr) => {
1549 test!(
1550 $from,
1551 Err(ConvertError {
1552 value: $from.clone(),
1553 data_type: DataType::Uint8,
1554 })
1555 )
1556 };
1557 }
1558
1559 test!(Value::Bool(true), Ok(1));
1560 test!(Value::Bool(false), Ok(0));
1561 test!(Value::I8(122), Ok(122));
1562 test!(Value::I16(122), Ok(122));
1563 test!(Value::I32(122), Ok(122));
1564 test!(Value::I64(122), Ok(122));
1565 test!(Value::I128(122), Ok(122));
1566 test!(Value::U8(122), Ok(122));
1567 test!(Value::U16(122), Ok(122));
1568 test!(Value::U32(122), Ok(122));
1569 test!(Value::U64(122), Ok(122));
1570 test!(Value::U128(122), Ok(122));
1571 test!(Value::F32(122.0_f32), Ok(122));
1572 test!(Value::F32(122.9_f32), Ok(122));
1573 test!(Value::F64(122.0), Ok(122));
1574 test!(Value::F64(122.9), Ok(122));
1575 test!(Value::Str("122".to_owned()), Ok(122));
1576 test!(Value::Decimal(Decimal::new(123, 0)), Ok(123));
1577
1578 err!(Value::I16(256));
1580 err!(Value::I32(256));
1581 err!(Value::I64(256));
1582 err!(Value::I128(256));
1583
1584 err!(Value::U16(256));
1585 err!(Value::U32(256));
1586 err!(Value::U64(256));
1587 err!(Value::U128(256));
1588
1589 err!(Value::F32(256.0_f32));
1590 err!(Value::F64(256.0));
1591
1592 err!(Value::Decimal(Decimal::new(256, 0)));
1593 err!(Value::Str("text".to_owned()));
1594 err!(Value::Bytea(Vec::new()));
1595 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1596 err!(Value::List(Vec::new()));
1597 err!(Value::Date(date(2021, 11, 20)));
1598 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1599 err!(Value::Time(time(10, 0, 0, 0)));
1600 err!(Value::Interval(I::Month(1)));
1601 err!(Value::Uuid(195965723427462096757863453463987888808));
1602 err!(Value::Map(BTreeMap::new()));
1603 err!(Value::List(Vec::new()));
1604 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1605 err!(Value::Null);
1606 }
1607
1608 #[test]
1609 fn try_into_u16() {
1610 macro_rules! test {
1611 ($from: expr, $to: expr) => {
1612 assert_eq!((&$from).try_into() as Result<u16>, $to);
1613 assert_eq!(u16::try_from(&$from), $to);
1614 };
1615 }
1616
1617 macro_rules! err {
1618 ($from: expr) => {
1619 test!(
1620 $from,
1621 Err(ConvertError {
1622 value: $from.clone(),
1623 data_type: DataType::Uint16,
1624 })
1625 )
1626 };
1627 }
1628
1629 test!(Value::Bool(true), Ok(1));
1630 test!(Value::Bool(false), Ok(0));
1631 test!(Value::I8(122), Ok(122));
1632 test!(Value::I16(122), Ok(122));
1633 test!(Value::I32(122), Ok(122));
1634 test!(Value::I64(122), Ok(122));
1635 test!(Value::I128(122), Ok(122));
1636 test!(Value::U8(122), Ok(122));
1637 test!(Value::U16(122), Ok(122));
1638 test!(Value::U32(122), Ok(122));
1639 test!(Value::U64(122), Ok(122));
1640 test!(Value::U128(122), Ok(122));
1641 test!(Value::F32(122.0_f32), Ok(122));
1642 test!(Value::F32(122.1_f32), Ok(122));
1643 test!(Value::F64(122.0), Ok(122));
1644 test!(Value::F64(122.1), Ok(122));
1645 test!(Value::Str("122".to_owned()), Ok(122));
1646 test!(Value::Decimal(Decimal::new(122, 0)), Ok(122));
1647
1648 err!(Value::I32(65536));
1649 err!(Value::I64(65536));
1650 err!(Value::I128(65536));
1651
1652 err!(Value::U32(65536));
1653 err!(Value::U64(65536));
1654 err!(Value::U128(65536));
1655
1656 err!(Value::F32(65536.0_f32));
1657 err!(Value::F64(65536.0));
1658
1659 err!(Value::Decimal(Decimal::new(65536, 0)));
1660 err!(Value::Str("text".to_owned()));
1661 err!(Value::Bytea(Vec::new()));
1662 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1663 err!(Value::Date(date(2021, 11, 20)));
1664 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1665 err!(Value::Time(time(10, 0, 0, 0)));
1666 err!(Value::Interval(I::Month(1)));
1667 err!(Value::Uuid(195965723427462096757863453463987888808));
1668 err!(Value::Map(BTreeMap::new()));
1669 err!(Value::List(Vec::new()));
1670 err!(Value::Null);
1671 }
1672
1673 #[test]
1674 fn try_into_u32() {
1675 macro_rules! test {
1676 ($from: expr, $to: expr) => {
1677 assert_eq!((&$from).try_into() as Result<u32>, $to);
1678 assert_eq!(u32::try_from(&$from), $to);
1679 };
1680 }
1681
1682 macro_rules! err {
1683 ($from: expr) => {
1684 test!(
1685 $from,
1686 Err(ConvertError {
1687 value: $from.clone(),
1688 data_type: DataType::Uint32,
1689 })
1690 )
1691 };
1692 }
1693
1694 test!(Value::Bool(true), Ok(1));
1695 test!(Value::Bool(false), Ok(0));
1696 test!(Value::I8(122), Ok(122));
1697 test!(Value::I16(122), Ok(122));
1698 test!(Value::I32(122), Ok(122));
1699 test!(Value::I64(122), Ok(122));
1700 test!(Value::I128(122), Ok(122));
1701 test!(Value::U8(122), Ok(122));
1702 test!(Value::U16(122), Ok(122));
1703 test!(Value::U32(122), Ok(122));
1704 test!(Value::U64(122), Ok(122));
1705 test!(Value::U128(122), Ok(122));
1706 test!(Value::F32(122.0_f32), Ok(122));
1707 test!(Value::F32(122.1_f32), Ok(122));
1708 test!(Value::F64(122.0), Ok(122));
1709 test!(Value::F64(122.1), Ok(122));
1710 test!(Value::Str("122".to_owned()), Ok(122));
1711 test!(Value::Decimal(Decimal::new(122, 0)), Ok(122));
1712
1713 err!(Value::I64(i64::MAX));
1714 err!(Value::I128(i128::MAX));
1715
1716 err!(Value::U64(u64::MAX));
1717 err!(Value::U128(u128::MAX));
1718
1719 err!(Value::F32(f32::MAX));
1720 err!(Value::F64(f64::MAX));
1721
1722 err!(Value::Decimal(Decimal::new(i64::MAX, 0)));
1723 err!(Value::Str("text".to_owned()));
1724 err!(Value::Bytea(Vec::new()));
1725 err!(Value::Inet(IpAddr::from_str("::0").unwrap()));
1726 err!(Value::Date(date(2021, 11, 20)));
1727 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1728 err!(Value::Time(time(10, 0, 0, 0)));
1729 err!(Value::Interval(I::Month(1)));
1730 err!(Value::Uuid(195965723427462096757863453463987888808));
1731 err!(Value::Map(BTreeMap::new()));
1732 err!(Value::List(Vec::new()));
1733 err!(Value::Null);
1734
1735 assert_eq!(
1736 u32::try_from(&Value::Inet(IpAddr::from_str("0.0.0.0").unwrap())),
1737 Ok(u32::from(Ipv4Addr::from(0)))
1738 );
1739 }
1740
1741 #[test]
1742 fn try_into_u64() {
1743 macro_rules! test {
1744 ($from: expr, $to: expr) => {
1745 assert_eq!((&$from).try_into() as Result<u64>, $to);
1746 assert_eq!(u64::try_from(&$from), $to);
1747 };
1748 }
1749
1750 macro_rules! err {
1751 ($from: expr) => {
1752 test!(
1753 $from,
1754 Err(ConvertError {
1755 value: $from.clone(),
1756 data_type: DataType::Uint64,
1757 })
1758 )
1759 };
1760 }
1761
1762 test!(Value::Bool(true), Ok(1));
1763 test!(Value::Bool(false), Ok(0));
1764 test!(Value::I8(122), Ok(122));
1765 test!(Value::I16(122), Ok(122));
1766 test!(Value::I32(122), Ok(122));
1767 test!(Value::I64(122), Ok(122));
1768 test!(Value::I128(122), Ok(122));
1769 test!(Value::U8(122), Ok(122));
1770 test!(Value::U16(122), Ok(122));
1771 test!(Value::U32(122), Ok(122));
1772 test!(Value::U64(122), Ok(122));
1773 test!(Value::U128(122), Ok(122));
1774 test!(Value::F32(122.0_f32), Ok(122));
1775 test!(Value::F32(122.1_f32), Ok(122));
1776 test!(Value::F64(122.0), Ok(122));
1777 test!(Value::F64(122.1), Ok(122));
1778 test!(Value::Str("122".to_owned()), Ok(122));
1779 test!(Value::Decimal(Decimal::new(122, 0)), Ok(122));
1780
1781 err!(Value::I128(i128::MIN));
1782
1783 err!(Value::U128(u128::MAX));
1784
1785 err!(Value::F32(f32::MIN));
1786 err!(Value::F64(f64::MIN));
1787
1788 err!(Value::Decimal(Decimal::new(i64::MIN, 0)));
1789 err!(Value::Str("text".to_owned()));
1790 err!(Value::Bytea(Vec::new()));
1791 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1792 err!(Value::Date(date(2021, 11, 20)));
1793 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1794 err!(Value::Time(time(10, 0, 0, 0)));
1795 err!(Value::Interval(I::Month(1)));
1796 err!(Value::Uuid(195965723427462096757863453463987888808));
1797 err!(Value::Map(BTreeMap::new()));
1798 err!(Value::List(Vec::new()));
1799 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1800 err!(Value::Null);
1801 }
1802
1803 #[test]
1804 fn try_into_u128() {
1805 macro_rules! test {
1806 ($from: expr, $to: expr) => {
1807 assert_eq!((&$from).try_into() as Result<u128>, $to);
1808 assert_eq!(u128::try_from(&$from), $to);
1809 };
1810 }
1811
1812 macro_rules! err {
1813 ($from: expr) => {
1814 test!(
1815 $from,
1816 Err(ConvertError {
1817 value: $from.clone(),
1818 data_type: DataType::Uint128,
1819 })
1820 )
1821 };
1822 }
1823
1824 test!(Value::Bool(true), Ok(1));
1825 test!(Value::Bool(false), Ok(0));
1826 test!(Value::I8(122), Ok(122));
1827 test!(Value::I16(122), Ok(122));
1828 test!(Value::I32(122), Ok(122));
1829 test!(Value::I64(122), Ok(122));
1830 test!(Value::I128(122), Ok(122));
1831 test!(Value::U8(122), Ok(122));
1832 test!(Value::U16(122), Ok(122));
1833 test!(Value::U32(122), Ok(122));
1834 test!(Value::U64(122), Ok(122));
1835 test!(Value::U128(122), Ok(122));
1836 test!(Value::F32(122.0_f32), Ok(122));
1837 test!(Value::F32(122.1_f32), Ok(122));
1838 test!(Value::F64(122.0), Ok(122));
1839 test!(Value::F64(122.1), Ok(122));
1840 test!(Value::Str("122".to_owned()), Ok(122));
1841 test!(Value::Decimal(Decimal::new(122, 0)), Ok(122));
1842
1843 err!(Value::F32(f32::MIN));
1844 err!(Value::F64(f64::MIN));
1845
1846 err!(Value::Decimal(Decimal::new(i64::MIN, 0)));
1847 err!(Value::Str("text".to_owned()));
1848 err!(Value::Bytea(Vec::new()));
1849
1850 err!(Value::Date(date(2021, 11, 20)));
1851 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1852 err!(Value::Time(time(10, 0, 0, 0)));
1853 err!(Value::Interval(I::Month(1)));
1854 err!(Value::Map(BTreeMap::new()));
1855 err!(Value::List(Vec::new()));
1856 err!(Value::Null);
1857
1858 let uuid = 195965723427462096757863453463987888808;
1859 assert_eq!((&Value::Uuid(uuid)).try_into() as Result<u128>, Ok(uuid));
1860 assert_eq!(u128::try_from(&Value::Uuid(uuid)), Ok(uuid));
1861
1862 let ip = Ipv6Addr::from(9876543210);
1863 assert_eq!(
1864 u128::try_from(&Value::Inet(IpAddr::V6(ip))),
1865 Ok(u128::from(ip))
1866 );
1867 }
1868
1869 #[test]
1870 fn try_into_f32() {
1871 macro_rules! test {
1872 ($from: expr, $to: expr) => {
1873 assert_eq!((&$from).try_into() as Result<f32>, $to);
1874 assert_eq!(f32::try_from(&$from), $to);
1875 };
1876 }
1877
1878 macro_rules! err {
1879 ($from: expr) => {
1880 test!(
1881 $from,
1882 Err(ConvertError {
1883 value: $from.clone(),
1884 data_type: DataType::Float32,
1885 })
1886 )
1887 };
1888 }
1889
1890 test!(Value::Bool(true), Ok(1.0_f32));
1891 test!(Value::Bool(false), Ok(0.0_f32));
1892 test!(Value::I8(122), Ok(122.0_f32));
1893 test!(Value::I16(122), Ok(122.0_f32));
1894 test!(Value::I32(122), Ok(122.0_f32));
1895 test!(Value::I64(122), Ok(122.0_f32));
1896 test!(Value::I128(122), Ok(122.0_f32));
1897 test!(Value::U8(122), Ok(122.0_f32));
1898 test!(Value::U16(122), Ok(122.0_f32));
1899 test!(Value::U32(122), Ok(122.0_f32));
1900 test!(Value::U64(122), Ok(122.0_f32));
1901 test!(Value::U128(122), Ok(122.0_f32));
1902 test!(Value::I64(1234567890), Ok(1234567890.0_f32));
1903 test!(Value::F64(1234567890.1), Ok(1234567890.1_f32));
1904 test!(Value::F32(1234567890.1_f32), Ok(1234567890.1_f32));
1905 test!(Value::Str("1234567890.1".to_owned()), Ok(1234567890.1_f32));
1906 test!(
1907 Value::Decimal(Decimal::new(12345678901, 1)),
1908 Ok(1234567890.1_f32)
1909 );
1910
1911 err!(Value::Str("text".to_owned()));
1912 err!(Value::Bytea(Vec::new()));
1913 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1914 err!(Value::Date(date(2021, 11, 20)));
1915 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1916 err!(Value::Time(time(10, 0, 0, 0)));
1917 err!(Value::Interval(I::Month(1)));
1918 err!(Value::Uuid(195965723427462096757863453463987888808));
1919 err!(Value::Map(BTreeMap::new()));
1920 err!(Value::List(Vec::new()));
1921 err!(Value::Null);
1922 }
1923
1924 #[test]
1925 fn try_into_f64() {
1926 macro_rules! test {
1927 ($from: expr, $to: expr) => {
1928 assert_eq!((&$from).try_into() as Result<f64>, $to);
1929 assert_eq!(f64::try_from(&$from), $to);
1930 };
1931 }
1932
1933 macro_rules! err {
1934 ($from: expr) => {
1935 test!(
1936 $from,
1937 Err(ConvertError {
1938 value: $from.clone(),
1939 data_type: DataType::Float,
1940 })
1941 )
1942 };
1943 }
1944
1945 test!(Value::Bool(true), Ok(1.0));
1946 test!(Value::Bool(false), Ok(0.0));
1947 test!(Value::I8(122), Ok(122.0));
1948 test!(Value::I16(122), Ok(122.0));
1949 test!(Value::I32(122), Ok(122.0));
1950 test!(Value::I64(122), Ok(122.0));
1951 test!(Value::I128(122), Ok(122.0));
1952 test!(Value::U8(122), Ok(122.0));
1953 test!(Value::U16(122), Ok(122.0));
1954 test!(Value::U32(122), Ok(122.0));
1955 test!(Value::U64(122), Ok(122.0));
1956 test!(Value::U128(122), Ok(122.0));
1957 test!(Value::I64(1234567890), Ok(1234567890.0));
1958 test!(Value::F32(1234567890.1_f32), Ok(1234567890.1_f32 as f64));
1959 test!(Value::F64(1234567890.1), Ok(1234567890.1));
1960 test!(Value::Str("1234567890.1".to_owned()), Ok(1234567890.1));
1961 test!(
1962 Value::Decimal(Decimal::new(12345678901, 1)),
1963 Ok(1234567890.1)
1964 );
1965
1966 err!(Value::Str("text".to_owned()));
1967 err!(Value::Bytea(Vec::new()));
1968 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
1969 err!(Value::Date(date(2021, 11, 20)));
1970 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
1971 err!(Value::Time(time(10, 0, 0, 0)));
1972 err!(Value::Interval(I::Month(1)));
1973 err!(Value::Uuid(195965723427462096757863453463987888808));
1974 err!(Value::Map(BTreeMap::new()));
1975 err!(Value::List(Vec::new()));
1976 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
1977 err!(Value::Null);
1978 }
1979
1980 #[test]
1981 fn try_into_usize() {
1982 macro_rules! test {
1983 ($from: expr, $to: expr) => {
1984 assert_eq!((&$from).try_into() as Result<usize>, $to);
1985 assert_eq!(usize::try_from(&$from), $to);
1986 };
1987 }
1988
1989 let err = |value: Value| ConvertError {
1990 value,
1991 #[cfg(target_pointer_width = "64")]
1992 data_type: DataType::Uint64,
1993 #[cfg(target_pointer_width = "32")]
1994 data_type: DataType::Uint32,
1995 };
1996 macro_rules! err {
1997 ($from: expr) => {
1998 test!($from, Err(err($from.clone())))
1999 };
2000 }
2001
2002 test!(Value::Bool(true), Ok(1usize));
2003 test!(Value::Bool(false), Ok(0));
2004 test!(Value::I8(122), Ok(122));
2005 test!(Value::I16(122), Ok(122));
2006 test!(Value::I32(122), Ok(122));
2007 test!(Value::I64(122), Ok(122));
2008 test!(Value::I128(122), Ok(122));
2009 test!(Value::U8(122), Ok(122));
2010 test!(Value::U16(122), Ok(122));
2011 test!(Value::U32(122), Ok(122));
2012 test!(Value::U64(122), Ok(122));
2013 test!(Value::U128(122), Ok(122));
2014 test!(Value::I64(1234567890), Ok(1234567890));
2015 test!(Value::F32(1234567890.0_f32), Ok(1234567890.0_f32 as usize));
2016 test!(Value::F32(1234567890.1_f32), Ok(1234567890.1_f32 as usize));
2017 test!(Value::F64(1234567890.0), Ok(1234567890));
2018 test!(Value::F64(1234567890.1), Ok(1234567890));
2019 test!(Value::Str("1234567890".to_owned()), Ok(1234567890));
2020 test!(Value::Decimal(Decimal::new(1234567890, 0)), Ok(1234567890));
2021
2022 err!(Value::I128(i128::MIN));
2023
2024 err!(Value::U128(u128::MAX));
2025
2026 err!(Value::F32(f32::MIN));
2027 err!(Value::F64(f64::MIN));
2028
2029 err!(Value::Decimal(Decimal::new(i64::MIN, 0)));
2030 err!(Value::Str("text".to_owned()));
2031 err!(Value::Bytea(Vec::new()));
2032 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
2033 err!(Value::Date(date(2021, 11, 20)));
2034 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
2035 err!(Value::Time(time(10, 0, 0, 0)));
2036 err!(Value::Interval(I::Month(1)));
2037 err!(Value::Uuid(195965723427462096757863453463987888808));
2038 err!(Value::Map(BTreeMap::new()));
2039 err!(Value::List(Vec::new()));
2040 err!(Value::Point(point::Point::new(1.0313, 2.0314)));
2041 err!(Value::Null);
2042 }
2043
2044 #[test]
2045 fn try_into_decimal() {
2046 macro_rules! test {
2047 ($from: expr, $to: expr) => {
2048 assert_eq!((&$from).try_into() as Result<Decimal>, $to);
2049 assert_eq!(Decimal::try_from(&$from), $to);
2050 };
2051 }
2052
2053 macro_rules! err {
2054 ($from: expr) => {
2055 test!(
2056 $from,
2057 Err(ConvertError {
2058 value: $from.clone(),
2059 data_type: DataType::Decimal,
2060 })
2061 )
2062 };
2063 }
2064
2065 test!(Value::Bool(true), Ok(Decimal::new(1, 0)));
2066 test!(Value::Bool(false), Ok(Decimal::new(0, 0)));
2067 test!(Value::I8(122), Ok(Decimal::new(122, 0)));
2068 test!(Value::I16(122), Ok(Decimal::new(122, 0)));
2069 test!(Value::I32(122), Ok(Decimal::new(122, 0)));
2070 test!(Value::I64(122), Ok(Decimal::new(122, 0)));
2071 test!(Value::I128(122), Ok(Decimal::new(122, 0)));
2072 test!(Value::U8(122), Ok(Decimal::new(122, 0)));
2073 test!(Value::U16(122), Ok(Decimal::new(122, 0)));
2074 test!(Value::U32(122), Ok(Decimal::new(122, 0)));
2075 test!(Value::U64(122), Ok(Decimal::new(122, 0)));
2076 test!(Value::U128(122), Ok(Decimal::new(122, 0)));
2077 test!(Value::F32(122.0_f32), Ok(Decimal::new(122, 0)));
2078 test!(Value::F32(122.1_f32), Ok(Decimal::new(1221, 1)));
2079 test!(Value::F64(122.0), Ok(Decimal::new(122, 0)));
2080 test!(Value::F64(122.1), Ok(Decimal::new(1221, 1)));
2081 test!(Value::Str("122".to_owned()), Ok(Decimal::new(122, 0)));
2082 test!(
2083 Value::Decimal(Decimal::new(122, 0)),
2084 Ok(Decimal::new(122, 0))
2085 );
2086
2087 err!(Value::Str("text".to_owned()));
2088 err!(Value::Bytea(Vec::new()));
2089 err!(Value::Inet(IpAddr::from_str("::1").unwrap()));
2090 err!(Value::Date(date(2021, 11, 20)));
2091 err!(Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)));
2092 err!(Value::Time(time(10, 0, 0, 0)));
2093 err!(Value::Interval(I::Month(1)));
2094 err!(Value::Uuid(195965723427462096757863453463987888808));
2095 err!(Value::Map(BTreeMap::new()));
2096 err!(Value::List(Vec::new()));
2097 err!(Value::Null);
2098 }
2099
2100 #[test]
2101 fn try_into_naive_date() {
2102 macro_rules! test {
2103 ($from: expr, $to: expr) => {
2104 assert_eq!((&$from).try_into() as Result<chrono::NaiveDate>, $to);
2105 assert_eq!(chrono::NaiveDate::try_from(&$from), $to);
2106 };
2107 }
2108
2109 macro_rules! err {
2110 ($from: expr) => {
2111 test!(
2112 $from,
2113 Err(ConvertError {
2114 value: $from.clone(),
2115 data_type: DataType::Date,
2116 })
2117 )
2118 };
2119 }
2120
2121 test!(Value::Date(date(2021, 11, 20)), Ok(date(2021, 11, 20)));
2122 test!(
2123 Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)),
2124 Ok(date(2021, 11, 20))
2125 );
2126 test!(Value::Str("2021-11-20".to_owned()), Ok(date(2021, 11, 20)));
2127
2128 err!(Value::F32(1.0_f32));
2129 err!(Value::F64(1.0));
2130 }
2131
2132 #[test]
2133 fn try_into_naive_time() {
2134 macro_rules! test {
2135 ($from: expr, $to: expr) => {
2136 assert_eq!((&$from).try_into() as Result<chrono::NaiveTime>, $to);
2137 assert_eq!(chrono::NaiveTime::try_from(&$from), $to);
2138 };
2139 }
2140
2141 macro_rules! err {
2142 ($from: expr) => {
2143 test!(
2144 $from,
2145 Err(ConvertError {
2146 value: $from.clone(),
2147 data_type: DataType::Time,
2148 })
2149 )
2150 };
2151 }
2152
2153 test!(Value::Time(time(10, 0, 0, 0)), Ok(time(10, 0, 0, 0)));
2154 test!(Value::Str("10:00:00".to_owned()), Ok(time(10, 0, 0, 0)));
2155
2156 err!(Value::F32(1.0_f32));
2157 err!(Value::F64(1.0));
2158 }
2159
2160 #[test]
2161 fn try_into_naive_date_time() {
2162 macro_rules! test {
2163 ($from: expr, $to: expr) => {
2164 assert_eq!((&$from).try_into() as Result<chrono::NaiveDateTime>, $to);
2165 assert_eq!(chrono::NaiveDateTime::try_from(&$from), $to);
2166 };
2167 }
2168
2169 macro_rules! err {
2170 ($from: expr) => {
2171 test!(
2172 $from,
2173 Err(ConvertError {
2174 value: $from.clone(),
2175 data_type: DataType::Timestamp,
2176 })
2177 )
2178 };
2179 }
2180
2181 let datetime = chrono::NaiveDateTime::new;
2182 test!(
2183 Value::Date(date(2021, 11, 20)),
2184 Ok(datetime(date(2021, 11, 20), time(0, 0, 0, 0)))
2185 );
2186 test!(
2187 Value::Timestamp(timestamp(2021, 11, 20, 10, 0, 0, 0)),
2188 Ok(datetime(date(2021, 11, 20), time(10, 0, 0, 0)))
2189 );
2190 test!(
2191 Value::Str("2021-11-20".to_owned()),
2192 Ok(datetime(date(2021, 11, 20), time(0, 0, 0, 0)))
2193 );
2194
2195 err!(Value::F32(1.0_f32));
2196 err!(Value::F64(1.0));
2197 }
2198
2199 #[test]
2200 fn try_into_ipaddr() {
2201 macro_rules! test {
2202 ($from: expr, $to: literal) => {
2203 assert_eq!(IpAddr::try_from($from), Ok(IpAddr::from_str($to).unwrap()));
2204 };
2205
2206 ($from: expr, $to: expr) => {
2207 assert_eq!(IpAddr::try_from($from), $to);
2208 };
2209 }
2210
2211 macro_rules! err {
2212 ($from: expr) => {
2213 test!(
2214 $from,
2215 Err(ConvertError {
2216 value: $from.clone(),
2217 data_type: DataType::Inet,
2218 })
2219 )
2220 };
2221 }
2222
2223 test!(&Value::Inet(IpAddr::from_str("::1").unwrap()), "::1");
2224 test!(&Value::Str("127.0.0.1".to_owned()), "127.0.0.1");
2225 test!(&Value::Str("0.0.0.0".to_owned()), "0.0.0.0");
2226 test!(IpAddr::from_str("::1").unwrap(), "::1");
2227 test!(IpAddr::from_str("::2:4cb0:16ea").unwrap(), "::2:4cb0:16ea");
2228
2229 err!(&Value::Date(date(2021, 11, 20)));
2230 }
2231
2232 #[test]
2233 fn try_into_point() {
2234 macro_rules! err {
2235 ($from: expr) => {
2236 assert_eq!(
2237 Point::try_from($from),
2238 Err(ConvertError {
2239 value: $from.clone(),
2240 data_type: DataType::Point,
2241 })
2242 );
2243 };
2244 }
2245
2246 assert_eq!(
2247 Point::try_from(&Value::Str("POINT(0.2 0.1)".to_owned())),
2248 Ok(Point::from_wkt("POINT(0.2 0.1)").unwrap())
2249 );
2250 assert_eq!(
2251 Point::try_from(&Value::Point(Point::new(0.1, 0.2))),
2252 Ok(Point::from_wkt("POINT(0.1 0.2)").unwrap())
2253 );
2254
2255 err!(&Value::Date(date(2021, 11, 20)));
2256 }
2257}