akita_core/
value.rs

1/*
2 *
3 *  *
4 *  *      Copyright (c) 2018-2025, SnackCloud All rights reserved.
5 *  *
6 *  *   Redistribution and use in source and binary forms, with or without
7 *  *   modification, are permitted provided that the following conditions are met:
8 *  *
9 *  *   Redistributions of source code must retain the above copyright notice,
10 *  *   this list of conditions and the following disclaimer.
11 *  *   Redistributions in binary form must reproduce the above copyright
12 *  *   notice, this list of conditions and the following disclaimer in the
13 *  *   documentation and/or other materials provided with the distribution.
14 *  *   Neither the name of the www.snackcloud.cn developer nor the names of its
15 *  *   contributors may be used to endorse or promote products derived from
16 *  *   this software without specific prior written permission.
17 *  *   Author: SnackCloud
18 *  *
19 *
20 */
21
22use std::{any::type_name, fmt, mem};
23use bigdecimal::{BigDecimal, ToPrimitive};
24use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime, Utc};
25use serde::{Serialize, Deserialize, Serializer, Deserializer, de, ser::SerializeMap};
26use serde_json::Map;
27use uuid::Uuid;
28use indexmap::{IndexMap};
29use serde::de::{MapAccess, Visitor};
30
31use crate::error::{ConvertError, AkitaDataError};
32use crate::{Row};
33
34#[derive(Debug, Clone, PartialEq)]
35pub enum Value {
36    Null,
37    Bool(bool),
38    Tinyint(i8),
39    Smallint(i16),
40    Int(i32),
41    Bigint(i64),
42    Float(f32),
43    Double(f64),
44    BigDecimal(BigDecimal),
45    Blob(Vec<u8>),
46    Char(char),
47    Text(String),
48    Json(serde_json::Value),
49    Uuid(Uuid),
50    Date(NaiveDate),
51    Time(NaiveTime),
52    DateTime(NaiveDateTime),
53    Timestamp(DateTime<Utc>),
54    Interval(Interval),
55    Object(IndexMap<String, Value>),
56    Array(Array),
57}
58
59// Implement Serialize
60impl Serialize for Value {
61    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
62        where
63            S: Serializer,
64    {
65        match self {
66            Value::Null => serializer.serialize_unit(),
67            Value::Bool(b) => serializer.serialize_bool(*b),
68            Value::Tinyint(i) => serializer.serialize_i8(*i),
69            Value::Smallint(i) => serializer.serialize_i16(*i),
70            Value::Int(i) => serializer.serialize_i32(*i),
71            Value::Bigint(i) => serializer.serialize_i64(*i),
72            Value::Float(f) => serializer.serialize_f32(*f),
73            Value::Double(f) => serializer.serialize_f64(*f),
74            Value::BigDecimal(bd) => serializer.serialize_str(&bd.to_string()),
75            Value::Blob(blob) => serializer.serialize_bytes(blob),
76            Value::Char(c) => serializer.serialize_char(*c),
77            Value::Text(s) => serializer.serialize_str(s),
78            Value::Json(value) => value.serialize(serializer),
79            Value::Uuid(uuid) => serializer.serialize_str(&uuid.to_string()),
80            Value::Date(date) => serializer.serialize_str(&date.to_string()),
81            Value::Time(time) => serializer.serialize_str(&time.to_string()),
82            Value::DateTime(dt) => serializer.serialize_str(&dt.to_string()),
83            Value::Timestamp(ts) => serializer.serialize_str(&ts.to_rfc3339()),
84            Value::Interval(interval) => serializer.serialize_str(&interval.to_string()),
85            Value::Object(map) => {
86                let mut obj = serializer.serialize_map(Some(map.len()))?;
87                for (key, value) in map {
88                    obj.serialize_entry(key, value)?;
89                }
90                obj.end()
91            }
92            Value::Array(arr) => serializer.collect_str(&serde_json::to_string(&arr).unwrap_or_default()),
93        }
94    }
95}
96
97// Implement Deserialize
98impl<'de> Deserialize<'de> for Value {
99    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
100        where
101            D: Deserializer<'de>,
102    {
103        struct ValueVisitor;
104
105        impl<'de> Visitor<'de> for ValueVisitor {
106            type Value = Value;
107
108            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
109                formatter.write_str("a valid Value variant")
110            }
111
112            fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E> {
113                Ok(Value::Bool(value))
114            }
115
116            fn visit_i8<E>(self, value: i8) -> Result<Self::Value, E> {
117                Ok(Value::Tinyint(value))
118            }
119
120            fn visit_i16<E>(self, value: i16) -> Result<Self::Value, E> {
121                Ok(Value::Smallint(value))
122            }
123
124            fn visit_i32<E>(self, value: i32) -> Result<Self::Value, E> {
125                Ok(Value::Int(value))
126            }
127
128            fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E> {
129                Ok(Value::Bigint(value))
130            }
131
132            fn visit_f32<E>(self, value: f32) -> Result<Self::Value, E> {
133                Ok(Value::Float(value))
134            }
135
136            fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E> {
137                Ok(Value::Double(value))
138            }
139
140            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
141                where
142                    E: de::Error,
143            {
144                if let Ok(uuid) = value.parse::<Uuid>() {
145                    return Ok(Value::Uuid(uuid));
146                }
147                if let Ok(date) = value.parse::<NaiveDate>() {
148                    return Ok(Value::Date(date));
149                }
150                if let Ok(time) = value.parse::<NaiveTime>() {
151                    return Ok(Value::Time(time));
152                }
153                if let Ok(dt) = value.parse::<NaiveDateTime>() {
154                    return Ok(Value::DateTime(dt));
155                }
156                if let Ok(ts) = value.parse::<DateTime<Utc>>() {
157                    return Ok(Value::Timestamp(ts));
158                }
159                if let Ok(bd) = value.parse::<BigDecimal>() {
160                    return Ok(Value::BigDecimal(bd));
161                }
162                Ok(Value::Text(value.to_string()))
163            }
164
165            fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
166                where
167                    M: MapAccess<'de>,
168            {
169                let mut object = IndexMap::new();
170                while let Some((key, value)) = map.next_entry()? {
171                    object.insert(key, value);
172                }
173                Ok(Value::Object(object))
174            }
175
176        }
177
178        deserializer.deserialize_any(ValueVisitor)
179    }
180}
181
182impl Default for Value {
183    fn default() -> Self {
184        Value::Null
185    }
186}
187
188#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
189pub struct Interval {
190    pub microseconds: i64,
191    pub days: i32,
192    pub months: i32,
193}
194
195impl Interval {
196    pub fn new(microseconds: i64, days: i32, months: i32) -> Self {
197        Interval {
198            microseconds,
199            days,
200            months,
201        }
202    }
203    
204}
205
206impl ToString for Interval {
207    fn to_string(&self) -> String {
208        format!("{}-{}-{}", self.months, self.days, self.microseconds)
209    }
210}
211
212impl Value {
213
214    pub fn is_string(&self) -> bool {
215        self.as_str().is_some()
216    }
217
218    pub fn is_object(&self) -> bool {
219        self.as_object().is_some()
220    }
221
222    pub fn as_object(&self) -> Option<&IndexMap<String, Value>> {
223        match *self {
224            Value::Object(ref map) => Some(map),
225            _ => None,
226        }
227    }
228
229    pub fn as_object_mut(&mut self) -> Option<&mut IndexMap<String, Value>> {
230        match *self {
231            Value::Object(ref mut map) => Some(map),
232            _ => None,
233        }
234    }
235
236    pub fn is_array(&self) -> bool {
237        self.as_array().is_some()
238    }
239
240    pub fn as_array(&self) -> Option<&Array> {
241        match *self {
242            Value::Array(ref array) => Some(array),
243            _ => None,
244        }
245    }
246
247    pub fn as_str(&self) -> Option<&str> {
248        match *self {
249            Value::Text(ref s) => Some(s.as_str()),
250            _ => None,
251        }
252    }
253
254    pub fn is_number(&self) -> bool {
255        match *self {
256            Value::Tinyint(_) | Value::Smallint(_) | Value::Int(_)  
257            | Value::Bigint(_)  | Value::Float(_) | Value::BigDecimal(_) | Value::Double(_)  => true,
258            _ => false,
259        }
260    }
261
262    pub fn is_boolean(&self) -> bool {
263        self.as_bool().is_some()
264    }
265
266    pub fn as_bool(&self) -> Option<bool> {
267        match *self {
268            Value::Bool(b) => Some(b),
269            _ => None,
270        }
271    }
272
273    pub fn is_null(&self) -> bool {
274        self.as_null().is_some()
275    }
276
277    pub fn as_null(&self) -> Option<()> {
278        match *self {
279            Value::Null => Some(()),
280            _ => None,
281        }
282    }
283
284    pub fn take(&mut self) -> Value {
285        mem::replace(self, Value::Null)
286    }
287
288    pub fn new_object() -> Self { Value::Object(IndexMap::new()) }
289
290    pub fn insert_obj<K, V>(&mut self, k: K, v: V)
291    where
292        K: ToString,
293        V: ToValue,
294    {
295        match self {
296            Value::Object(data) => {data.insert(k.to_string().replace("r#",""), v.to_value());},
297            _ => (),
298        }
299    }
300
301    pub fn insert_obj_value<K>(&mut self, k: K, value: &Value)
302    where
303        K: ToString,
304    {
305        match self {
306            Value::Object(v) => {v.insert(k.to_string(), value.clone());},
307            _ => (),
308        }
309    }
310
311    pub fn get_obj<'a, T>(&'a self, s: &str) -> Result<T, AkitaDataError>
312    where
313        T: FromValue,
314    {
315        match self {
316            Value::Object(data) => match data.get(&s.replace("r#","")) {
317                Some(v) => {
318                    let s = FromValue::from_value_opt(v);
319                    s
320                },
321                None => Err(AkitaDataError::NoSuchValueError(s.into())),
322            },
323            _ => Err(AkitaDataError::ObjectValidError("Unsupported type".to_string())),
324        }
325    }
326
327    pub fn get_obj_len<'a>(&'a self) -> usize
328    {
329        match self {
330            Value::Object(data) => data.len(),
331            _ => 0,
332        }
333    }
334
335    pub fn get_obj_opt<'a, T>(&'a self, s: &str) -> Result<Option<T>, AkitaDataError>
336    where
337        T: FromValue,
338    {
339        match self {
340            Value::Object(data) => match data.get(&s.replace("r#","")) {
341                Some(v) => {
342                    match v {
343                        Value::Null => Ok(None),
344                        _ => {
345                            Ok(Some(
346                                FromValue::from_value(v)
347                            ))
348                        }
349                    }
350                }
351                None => Ok(None),
352            },
353            _ => Ok(None),
354        }
355    }
356
357    pub fn get_obj_value(&self, s: &str) -> Option<&Value> { 
358        match self {
359            Value::Object(data) => data.get(s),
360            _ => None,
361        }
362     }
363
364    pub fn remove_obj(&mut self, s: &str) -> Option<Value> { 
365        match self {
366            Value::Object(v) => v.shift_remove(s),
367            _ => None,
368        } 
369    }
370
371    /// Will take value of a column with index `index` if it exists and wasn't taken earlier then
372    /// will converts it to `T`.
373    pub fn take_obj_raw<'a, T>(&'a self, index: usize) -> Option<T>
374    where
375        T: FromValue,
376    {
377        match self {
378            Value::Object(v) => v.get_index(index).and_then(|(_k, v)| Some(FromValue::from_value(v))),
379            _ => None,
380        }
381    }
382
383    /// Will take value of a column with index `index` if it exists and wasn't taken earlier then
384    /// will attempt to convert it to `T`. Unlike `Row::take`, `Row::take_opt` will allow you to
385    /// directly handle errors if the value could not be converted to `T`.
386    pub fn take_obj_raw_opt<'a, T>(&'a self, index: usize) -> Option<Result<T, AkitaDataError>>
387    where
388        T: FromValue,
389    {
390        match self {
391            Value::Object(v) => v.get_index(index).and_then(|(_k, v)| Some(FromValue::from_value_opt(v))),
392            _ => Some(Err(AkitaDataError::ObjectValidError("Unsupported type".to_string()))),
393        }
394    }
395
396    #[doc(hidden)]
397    pub fn place(&mut self, index: usize, value: Value) {
398        match self {
399            Value::Object(v) => match v.get_index_mut(index) {
400                Some((_k, v)) => {
401                    *v = value;
402                }
403                None => ()
404            }
405            _ => (),
406        }
407    }
408}
409
410impl fmt::Display for Value {
411    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
412        match self {
413            Value::Null => write!(f, "Null"),
414            Value::Bool(v) => write!(f, "{}", v),
415            Value::Tinyint(v) => write!(f, "{}", v),
416            Value::Smallint(v) => write!(f, "{}", v),
417            Value::Int(v) => write!(f, "{}", v),
418            Value::Bigint(v) => write!(f, "{}", v),
419            Value::Float(v) => write!(f, "{}", v),
420            Value::Double(v) => write!(f, "{}", v),
421            Value::BigDecimal(v) => write!(f, "{}", v),
422            Value::Char(v) => write!(f, "{}", v),
423            Value::Text(v) => write!(f, "{}", v),
424            Value::Json(v) => write!(f, "{}", serde_json::to_string(v).unwrap_or_default()),
425            Value::Uuid(v) => write!(f, "{}", v),
426            Value::Date(v) => write!(f, "{}", v),
427            Value::Time(v) => write!(f, "{}", v),
428            Value::DateTime(v) => write!(f, "{}", v.format("%Y-%m-%d %H:%M:%S").to_string()),
429            Value::Timestamp(v) => write!(f, "{}", v.to_rfc3339()),
430            Value::Array(array) => array.fmt(f),
431            Value::Blob(v) => {
432                write!(f, "{}", String::from_utf8_lossy(v))
433            }
434            _ => panic!("not yet implemented: {:?}", self),
435        }
436    }
437}
438
439
440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
441pub enum Array {
442    Bool(Vec<bool>),
443    Tinyint(Vec<i8>),
444    Smallint(Vec<i16>),
445    Int(Vec<i64>),
446    Float(Vec<f64>),
447    Bigint(Vec<i64>),
448    Double(Vec<f64>),
449    BigDecimal(Vec<BigDecimal>),
450    Text(Vec<String>),
451    Json(Vec<serde_json::Value>),
452    Char(Vec<char>),
453    Uuid(Vec<Uuid>),
454    Date(Vec<NaiveDate>),
455    Timestamp(Vec<DateTime<Utc>>),
456}
457
458impl fmt::Display for Array {
459    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
460        match self {
461            Array::Text(texts) => {
462                write!(f, "[{}]", texts.join(","))
463            }
464            Array::Float(floats) => {
465                write!(f, "[{}]", serde_json::to_string(&floats).unwrap_or_default())
466            }
467            Array::Json(json) => {
468                write!(f, "{}", serde_json::to_string(&json).unwrap_or_default())
469            }
470            Array::Bool(bools) => {
471                write!(f, "[{}]", serde_json::to_string(&bools).unwrap_or_default())
472            }
473            Array::Tinyint(tinyints) => {
474                write!(f, "[{}]", serde_json::to_string(&tinyints).unwrap_or_default())
475            }
476            Array::Smallint(smallints) => {
477                write!(f, "[{}]", serde_json::to_string(&smallints).unwrap_or_default())
478            }
479            Array::Int(ints) => {
480                write!(f, "[{}]", serde_json::to_string(&ints).unwrap_or_default())
481            }
482            Array::Bigint(bigints) => {
483                write!(f, "[{}]", serde_json::to_string(&bigints).unwrap_or_default())
484            }
485            Array::Double(doubles) => {
486                write!(f, "[{}]", serde_json::to_string(&doubles).unwrap_or_default())
487            }
488            Array::BigDecimal(bigdecimals) => {
489                let fmt = bigdecimals.iter().map(|v| v.to_string()).collect::<Vec<_>>().join(",");
490                write!(f, "[{}]", fmt)
491            }
492            Array::Char(chars) => {
493                write!(f, "[{}]", serde_json::to_string(&chars).unwrap_or_default())
494            }
495            Array::Uuid(uuids) => {
496                let fmt = uuids.iter().map(|v| v.to_string()).collect::<Vec<_>>().join(",");
497                write!(f, "[{}]", fmt)
498            }
499            Array::Date(dates) => {
500                write!(f, "[{}]", serde_json::to_string(&dates).unwrap_or_default())
501            }
502            Array::Timestamp(timestamps) => {
503                write!(f, "[{}]", serde_json::to_string(&timestamps).unwrap_or_default())
504            }
505            // _ => panic!("not yet implemented: {:?}", self),
506        }
507    }
508}
509
510/// A trait to allow passing of parameters ergonomically
511/// in em.execute_sql_with_return
512pub trait ToValue {
513    fn to_value(&self) -> Value;
514}
515
516macro_rules! impl_to_value {
517    ($ty:ty, $variant:ident) => {
518        impl ToValue for $ty {
519            fn to_value(&self) -> Value {
520                Value::$variant(self.to_owned())
521            }
522        }
523    };
524}
525
526macro_rules! impl_usined_to_value {
527    ($ty:ty, $variant:ident, $target_variant:ident) => {
528        impl ToValue for $ty {
529            fn to_value(&self) -> Value {
530                Value::$variant(self.to_owned() as $target_variant)
531            }
532        }
533    };
534}
535
536impl_usined_to_value!(u8, Tinyint, i8);
537impl_usined_to_value!(u16, Smallint, i16);
538impl_usined_to_value!(u32, Int, i32);
539impl_usined_to_value!(u64, Bigint, i64);
540impl_usined_to_value!(usize, Bigint, i64);
541impl_usined_to_value!(isize, Bigint, i64);
542
543
544impl_to_value!(bool, Bool);
545impl_to_value!(i8, Tinyint);
546impl_to_value!(i16, Smallint);
547impl_to_value!(i32, Int);
548impl_to_value!(i64, Bigint);
549impl_to_value!(f32, Float);
550impl_to_value!(f64, Double);
551impl_to_value!(Vec<u8>, Blob);
552impl_to_value!(char, Char);
553impl_to_value!(String, Text);
554impl_to_value!(Uuid, Uuid);
555impl_to_value!(NaiveDate, Date);
556impl_to_value!(NaiveTime, Time);
557impl_to_value!(DateTime<Utc>, Timestamp);
558impl_to_value!(NaiveDateTime, DateTime);
559
560impl ToValue for &str {
561    fn to_value(&self) -> Value {
562        Value::Text(self.to_string())
563    }
564}
565
566impl ToValue for serde_json::Value {
567    fn to_value(&self) -> Value {
568        match self {
569            serde_json::Value::Null => Value::Null,
570            serde_json::Value::Bool(v) => Value::Bool(v.to_owned()),
571            serde_json::Value::Number(v) => {
572                if v.is_f64() {
573                    Value::Double(v.as_f64().unwrap_or_default())
574                } else if v.is_i64() {
575                    Value::Bigint(v.as_i64().unwrap_or_default())
576                } else if v.is_u64() {
577                    Value::Bigint(v.as_u64().unwrap_or_default() as i64)
578                } else {
579                    Value::Int(0)
580                }
581            },
582            serde_json::Value::String(v) => Value::Text(v.to_owned()),
583            serde_json::Value::Array(v) => v.to_value(),
584            serde_json::Value::Object(data) => {
585                let mut map: IndexMap<String, Value> = IndexMap::new();
586                for key in data.keys() {
587                    if let Some(v) = self.get(key) {
588                        map.insert(key.to_string(), serde_json::Value::to_value(v));
589                    }
590                }
591                Value::Object(map)
592            },
593        }
594    }
595}
596
597impl ToValue for Vec<String> {
598    fn to_value(&self) -> Value {
599        Value::Array(Array::Text(self.to_owned()))
600    }
601}
602
603impl ToValue for Vec<serde_json::Value> {
604    fn to_value(&self) -> Value {
605        if self.is_empty() {
606            return Value::Null
607        }
608        let mut int_values = Vec::new();
609        let mut float_values = Vec::new();
610        let mut text_values = Vec::new();
611        let mut obj_values = Vec::new();
612        for v in self {
613            if v.is_f64() {
614                float_values.push(v.as_f64().unwrap_or_default());
615            } else if v.is_i64() {
616                int_values.push(v.as_i64().unwrap_or_default());
617            } else if v.is_u64() {
618                int_values.push(v.as_i64().unwrap_or_default());
619            } else if v.is_string() {
620                text_values.push(v.as_str().unwrap_or_default().to_string());
621            } else if v.is_object() {
622                obj_values.push(v.to_owned());
623            } else {
624                text_values.push(v.to_string());
625            }
626        }
627        if !int_values.is_empty() {
628            Value::Array(Array::Int(int_values))
629        } else if !float_values.is_empty() {
630            Value::Array(Array::Float(float_values))
631        } else if !obj_values.is_empty() {
632            Value::Array(Array::Json(obj_values))
633        } else{
634            Value::Array(Array::Text(text_values))
635        }
636    }
637}
638
639impl<T> ToValue for Option<T>
640where
641    T: ToValue,
642{
643    fn to_value(&self) -> Value {
644        
645        match self {
646            Some(v) => v.to_value(),
647            None => Value::Null,
648        }
649    }
650}
651
652impl ToValue for () {
653    fn to_value(&self) -> Value {
654        Value::Null
655    }
656}
657
658impl <T> ToValue for &T
659where
660    T: ToValue,
661{
662    fn to_value(&self) -> Value {
663        (*self).to_value()
664    }
665}
666
667impl ToValue for Row {
668    fn to_value(&self) -> Value {
669        let mut data = IndexMap::new();
670        for (i, col) in self.columns.iter().enumerate() {
671            data.insert(col.to_string(), self.data.get(i).map(|v| v.clone()).unwrap_or(Value::Null));
672        }
673        Value::Object(data)
674    }
675}
676
677impl <'a> From<&'a Value> for Value {
678    fn from(v: &'a Value) -> Value {
679        v.to_owned()
680    }
681}
682
683impl<T> From<T> for Value
684where
685    T: ToValue,
686{
687    fn from(v: T) -> Value {
688        v.to_value()
689    }
690}
691
692pub trait FromValue: Sized {
693    fn from_value(v: &Value) -> Self {
694        match Self::from_value_opt(v) {
695            Ok(x) => x,
696            Err(_err) => panic!(
697                "Couldn't from {:?} to type {}. (see FromValue documentation)",
698                v,
699                type_name::<Self>(),
700            ),
701        }
702    }
703
704    fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError>;
705}
706
707macro_rules! impl_from_value {
708    ($ty: ty, $ty_name: tt, $($variant: ident),*) => {
709        /// try from to owned
710        impl FromValue for $ty {
711            fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError> {
712                match *v {
713                    $(Value::$variant(ref v) => Ok(v.to_owned() as $ty),
714                    )*
715                    _ => Err(AkitaDataError::ConvertError(ConvertError::NotSupported(format!("{:?}",v), $ty_name.into()))),
716                }
717            }
718        }
719    }
720}
721
722macro_rules! impl_from_value_numeric {
723    ($ty: ty, $method:ident, $ty_name: tt, $($variant: ident),*) => {
724        impl FromValue for $ty {
725            fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError> {
726                match *v {
727                    $(Value::$variant(ref v) => Ok(v.to_owned() as $ty),
728                    )*
729                    Value::BigDecimal(ref v) => Ok(v.$method().unwrap_or_default()),
730                    Value::Object(ref v) => {
731                        let (_, v) = v.first().unwrap_or((&String::default(), &Value::Null));
732                        Ok(<$ty>::from_value(v))
733                    },
734                    _ => Err(AkitaDataError::ConvertError(ConvertError::NotSupported(format!("{:?}", v), $ty_name.into()))),
735                }
736            }
737        }
738    }
739}
740
741impl_from_value!(Vec<u8>, "Vec<u8>", Blob);
742impl_from_value!(char, "char", Char);
743impl_from_value!(Uuid, "Uuid", Uuid);
744impl_from_value!(NaiveDate, "NaiveDate", Date);
745
746impl_from_value_numeric!(i8, to_i8, "i8", Tinyint);
747impl_from_value_numeric!(isize, to_isize, "isize", Tinyint, Bigint, Int);
748impl_from_value_numeric!(u8, to_u8, "u8", Tinyint, Bigint, Int);
749impl_from_value_numeric!(u16, to_u16, "u16", Tinyint, Bigint, Int);
750impl_from_value_numeric!(u32, to_u32, "u32", Tinyint, Bigint, Int);
751impl_from_value_numeric!(u64, to_u64, "u64", Tinyint, Bigint, Int);
752impl_from_value_numeric!(usize, to_usize, "usize", Tinyint, Bigint, Int);
753impl_from_value_numeric!(i16, to_i16, "i16", Tinyint, Smallint);
754impl_from_value_numeric!(i32, to_i32, "i32", Tinyint, Smallint, Int, Bigint);
755impl_from_value_numeric!(i64, to_i64, "i64", Tinyint, Smallint, Int, Bigint);
756impl_from_value_numeric!(f32, to_f32, "f32", Float);
757impl_from_value_numeric!(f64, to_f64, "f64", Float, Double);
758
759/// Char can be casted into String
760/// and they havea separate implementation for extracting data
761impl FromValue for String {
762    fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError> {
763        match *v {
764            Value::Text(ref v) => Ok(v.to_owned()),
765            Value::Char(ref v) => {
766                let mut s = String::new();
767                s.push(*v);
768                Ok(s)
769            }
770            Value::Blob(ref v) => String::from_utf8(v.to_owned()).map_err(|e| {
771                AkitaDataError::ConvertError(ConvertError::NotSupported(format!("{:?}", v), format!("String: {}", e)))
772            }),
773            Value::Bool(ref v) => Ok(v.to_string()),
774            Value::Tinyint(ref v) => Ok(v.to_string()),
775            Value::Smallint(ref v) => Ok(v.to_string()),
776            Value::Int(ref v) => Ok(v.to_string()),
777            Value::Bigint(ref v) => Ok(v.to_string()),
778            Value::Float(ref v) => Ok(v.to_string()),
779            Value::Double(ref v) => Ok(v.to_string()),
780            Value::BigDecimal(ref v) => Ok(v.to_string()),
781            Value::Json(ref v) => Ok(serde_json::to_string(v).unwrap_or_default()),
782            Value::Uuid(ref v) => Ok(v.to_string()),
783            Value::Date(ref v) => Ok(v.to_string()),
784            Value::Time(ref v) => Ok(v.to_string()),
785            Value::DateTime(ref v) => Ok(v.to_string()),
786            Value::Timestamp(ref v) => Ok(v.to_string()),
787            Value::Array(ref v) => {
788                match v {
789                    Array::Int(vv) =>  Ok(serde_json::to_string(vv).unwrap_or_default()),
790                    Array::Float(vv) =>  Ok(serde_json::to_string(vv).unwrap_or_default()),
791                    Array::Text(vv) =>  Ok(serde_json::to_string(vv).unwrap_or_default()),
792                    Array::Json(vv) =>  Ok(serde_json::to_string(vv).unwrap_or_default()),
793                    Array::Bool(vv) =>  Ok(serde_json::to_string(vv).unwrap_or_default()),
794                    Array::Tinyint(vv) =>  Ok(serde_json::to_string(vv).unwrap_or_default()),
795                    Array::Smallint(vv) =>  Ok(serde_json::to_string(vv).unwrap_or_default()),
796                    Array::Bigint(vv) =>  Ok(serde_json::to_string(vv).unwrap_or_default()),
797                    Array::BigDecimal(vv) =>  Ok(vv.iter().map(|v| v.to_string()).collect::<Vec<_>>().join(",")),
798                    Array::Date(vv) =>  Ok(vv.iter().map(|v| v.to_string()).collect::<Vec<_>>().join(",")),
799                    Array::Timestamp(vv) =>  Ok(vv.iter().map(|v| v.to_string()).collect::<Vec<_>>().join(",")),
800                    Array::Uuid(vv) =>  Ok(vv.iter().map(|v| v.to_string()).collect::<Vec<_>>().join(",")),
801                    Array::Double(vv) =>  Ok(serde_json::to_string(vv).unwrap_or_default()),
802                    Array::Char(vv) =>  Ok(serde_json::to_string(vv).unwrap_or_default()),
803                }
804            }
805            Value::Object(ref obj) => {
806                let data: IndexMap<String, Value> = obj.to_owned();
807                if data.len() > 0 {
808                    let (_k, v) = data.get_index(0).unwrap();
809                    Ok(v.as_str().to_owned().unwrap_or_default().to_string())
810                } else {
811                    Ok(String::default())
812                }
813            }
814            _ => Err(AkitaDataError::ConvertError(ConvertError::NotSupported(
815                format!("{:?}", v),
816                "String".to_string(),
817            ))),
818
819        }
820    }
821}
822
823impl FromValue for Vec<String> {
824    fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError> {
825        match *v {
826            Value::Array(Array::Text(ref t)) => Ok(t.to_owned()),
827            _ => Err(AkitaDataError::ConvertError(ConvertError::NotSupported(
828                format!("{:?}", v),
829                "Vec<String>".to_string(),
830            ))),
831        }
832    }
833}
834
835impl FromValue for () {
836    fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError> {
837        match *v {
838            Value::Null => Ok(()),
839            _ => Err(AkitaDataError::ConvertError(ConvertError::NotSupported(
840                format!("{:?}", v),
841                "Vec<String>".to_string(),
842            ))),
843        }
844    }
845}
846
847impl FromValue for bool {
848    fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError> {
849        match *v {
850            Value::Bool(v) => Ok(v),
851            Value::Tinyint(v) => Ok(v == 1),
852            Value::Smallint(v) => Ok(v == 1),
853            Value::Int(v) => Ok(v == 1),
854            Value::Bigint(v) => Ok(v == 1),
855            _ => Err(AkitaDataError::ConvertError(ConvertError::NotSupported(
856                format!("{:?}", v),
857                "bool".to_string(),
858            ))),
859        }
860    }
861}
862
863impl FromValue for serde_json::Value {
864    fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError> {
865        match v.clone() {
866            Value::Bool(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
867            Value::Null => Ok(serde_json::Value::Null),
868            Value::Tinyint(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
869            Value::Smallint(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
870            Value::Int(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
871            Value::Bigint(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
872            Value::Float(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
873            Value::Double(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
874            Value::Blob(v) => serde_json::from_slice(&v).map_err(AkitaDataError::from),
875            Value::Char(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
876            Value::Text(v) => Ok(serde_json::Value::String(v)),
877            Value::Json(v) => Ok(v), //serde_json::to_value(v).map_err(AkitaDataError::from),
878            Value::Uuid(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
879            Value::Date(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
880            Value::Time(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
881            Value::DateTime(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
882            Value::Timestamp(v) => serde_json::to_value(v).map_err(AkitaDataError::from),
883            // Value::SerdeJson(v) => Ok(v.clone()),
884            Value::Object(v) => {
885                let mut data = Map::new();
886                for (k, v) in v.into_iter() {
887                    data.insert(k, serde_json::Value::from_value(&v));
888                }
889                Ok(serde_json::Value::Object(data))
890            },
891            Value::Array(v) => serde_json::to_value(v).map_err(|err| AkitaDataError::from(err)),
892            _ => Err(AkitaDataError::ConvertError(ConvertError::NotSupported(
893                format!("{:?}", v),
894                "SerdeJson".to_string(),
895            ))),
896        }
897    }
898}
899
900impl FromValue for DateTime<Utc> {
901    fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError> {
902        match *v {
903            Value::Text(ref v) => Ok(DateTime::<Utc>::from_naive_utc_and_offset(parse_naive_date_time(v), Utc)),
904            Value::DateTime(v) => Ok(DateTime::<Utc>::from_naive_utc_and_offset(v, Utc)),
905            Value::Timestamp(v) => Ok(v),
906            _ => Err(AkitaDataError::ConvertError(ConvertError::NotSupported(
907                format!("{:?}", v),
908                "DateTime".to_string(),
909            ))),
910        }
911    }
912}
913
914impl FromValue for NaiveDateTime {
915    fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError> {
916        match *v {
917            Value::Text(ref v) => Ok(parse_naive_date_time(v)),
918            Value::DateTime(v) => Ok(v),
919            _ => Err(AkitaDataError::ConvertError(ConvertError::NotSupported(
920                format!("{:?}", v),
921                "NaiveDateTime".to_string(),
922            ))),
923        }
924    }
925}
926
927impl<T> FromValue for Option<T>
928where
929    T: FromValue,
930{
931    fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError> {
932        match *v {
933            Value::Null => Ok(None),
934            _ => FromValue::from_value_opt(v).map(Some),
935        }
936    }
937}
938
939impl FromValue for Vec<Value> {
940    fn from_value_opt(_v: &Value) -> Result<Self, AkitaDataError> {
941       Ok(vec![])
942    }
943}
944
945impl<T> FromValue for &T
946where
947    T: FromValue,
948{
949    fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError> {
950        match *v {
951            Value::Null => Err(AkitaDataError::NoSuchValueError(format!("{:?} can not get value", v))),
952            _ => FromValue::from_value_opt(v),
953        }
954        
955    }
956}
957
958
959impl FromValue for Value
960{
961    fn from_value_opt(v: &Value) -> Result<Self, AkitaDataError> {
962        Ok(v.to_owned())
963    }
964}
965
966fn parse_naive_date_time(v: &str) -> NaiveDateTime {
967    let ts = NaiveDateTime::parse_from_str(&v, "%Y-%m-%d %H:%M:%S");
968    if let Ok(ts) = ts {
969        ts
970    } else {
971        let ts = NaiveDateTime::parse_from_str(&v, "%Y-%m-%d %H:%M:%S%.3f");
972        if let Ok(ts) = ts {
973            ts
974        } else {
975            panic!("unable to parse timestamp: {}", v);
976        }
977    }
978}
979
980
981macro_rules! take_or_place {
982    ($row:expr, $index:expr, $t:ident) => (
983        match $row.take_obj_raw($index) {
984            Some(v) => v,
985            None => return Err(AkitaDataError::NoSuchValueError(format!("{:?} can not get value", $row))),
986        }
987    );
988    ($row:expr, $index:expr, $t:ident, $( [$idx:expr, $ir:expr] ),*) => (
989        match $row.take_obj_raw($index) {
990            Some(v) => v,
991            None => return Err(AkitaDataError::NoSuchValueError(format!("{:?} can not get value", $row))),
992        }
993    );
994}
995
996
997impl <T1> FromValue for (T1,)
998where  T1: FromValue {
999    fn from_value_opt(data: &Value) -> Result<Self, AkitaDataError> {
1000        T1::from_value_opt(data).map(|t| (t,))
1001    }
1002}
1003
1004impl<T1, T2> FromValue for (T1, T2)
1005where
1006    T1: FromValue,
1007    T2: FromValue,
1008{
1009    fn from_value_opt(data: &Value) -> Result<Self, AkitaDataError> {
1010        if data.get_obj_len() != 2 {
1011            return Err(AkitaDataError::NoSuchValueError(format!("Can not convert row with {:?}", data)))
1012        }
1013        let ir1 = take_or_place!(data, 0, T1);
1014        let ir2 = take_or_place!(data, 1, T2, [0, ir1]);
1015        Ok((ir1, ir2))
1016    }
1017}
1018
1019impl<T1, T2, T3> FromValue for (T1, T2, T3)
1020where
1021    T1: FromValue,
1022    T2: FromValue,
1023    T3: FromValue,
1024{
1025    fn from_value_opt(data: &Value) -> Result<Self, AkitaDataError> {
1026        if data.get_obj_len() != 3 {
1027            return Err(AkitaDataError::NoSuchValueError(format!("Can not convert row with {:?}", data)))
1028        }
1029        let ir1 = take_or_place!(data, 0, T1);
1030        let ir2 = take_or_place!(data, 1, T2, [0, ir1]);
1031        let ir3 = take_or_place!(data, 2, T3, [0, ir1], [1, ir2]);
1032        Ok((ir1, ir2, ir3))
1033    }
1034}
1035
1036impl<T1, T2, T3, T4> FromValue for (T1, T2, T3, T4)
1037where
1038    T1: FromValue,
1039    T2: FromValue,
1040    T3: FromValue,
1041    T4: FromValue,
1042{
1043    fn from_value_opt(data: &Value) -> Result<Self, AkitaDataError> {
1044        if data.get_obj_len() != 4 {
1045            return Err(AkitaDataError::NoSuchValueError(format!("Can not convert row with {:?}", data)))
1046        }
1047        let ir1 = take_or_place!(data, 0, T1);
1048        let ir2 = take_or_place!(data, 1, T2, [0, ir1]);
1049        let ir3 = take_or_place!(data, 2, T3, [0, ir1], [1, ir2]);
1050        let ir4 = take_or_place!(data, 3, T4, [0, ir1], [1, ir2], [2, ir3]);
1051        Ok((ir1, ir2, ir3, ir4))
1052    }
1053}
1054
1055impl<T1, T2, T3, T4, T5> FromValue for (T1, T2, T3, T4, T5)
1056where
1057    T1: FromValue,
1058    T2: FromValue,
1059    T3: FromValue,
1060    T4: FromValue,
1061    T5: FromValue,
1062{
1063    fn from_value_opt(data: &Value) -> Result<Self, AkitaDataError> {
1064        if data.get_obj_len() != 5 {
1065            return Err(AkitaDataError::NoSuchValueError(format!("Can not convert row with {:?}", data)))
1066        }
1067        let ir1 = take_or_place!(data, 0, T1);
1068        let ir2 = take_or_place!(data, 1, T2, [0, ir1]);
1069        let ir3 = take_or_place!(data, 2, T3, [0, ir1], [1, ir2]);
1070        let ir4 = take_or_place!(data, 3, T4, [0, ir1], [1, ir2], [2, ir3]);
1071        let ir5 = take_or_place!(data, 4, T5, [0, ir1], [1, ir2], [2, ir3], [3, ir4]);
1072        Ok((ir1, ir2, ir3, ir4, ir5))
1073    }
1074}
1075
1076
1077impl<T1, T2, T3, T4, T5, T6> FromValue for (T1, T2, T3, T4, T5, T6)
1078where
1079    T1: FromValue,
1080    T2: FromValue,
1081    T3: FromValue,
1082    T4: FromValue,
1083    T5: FromValue,
1084    T6: FromValue,
1085{
1086    fn from_value_opt(data: &Value) -> Result<Self, AkitaDataError> {
1087        if data.get_obj_len() != 6 {
1088            return Err(AkitaDataError::NoSuchValueError(format!("Can not convert row with {:?}", data)))
1089        }
1090        let ir1 = take_or_place!(data, 0, T1);
1091        let ir2 = take_or_place!(data, 1, T2, [0, ir1]);
1092        let ir3 = take_or_place!(data, 2, T3, [0, ir1], [1, ir2]);
1093        let ir4 = take_or_place!(data, 3, T4, [0, ir1], [1, ir2], [2, ir3]);
1094        let ir5 = take_or_place!(data, 4, T5, [0, ir1], [1, ir2], [2, ir3], [3, ir4]);
1095        let ir6 = take_or_place!(data, 5, T6, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5]);
1096        Ok((ir1, ir2, ir3, ir4, ir5, ir6))
1097    }
1098}
1099
1100
1101impl<T1, T2, T3, T4, T5, T6, T7> FromValue for (T1, T2, T3, T4, T5, T6, T7)
1102where
1103    T1: FromValue,
1104    T2: FromValue,
1105    T3: FromValue,
1106    T4: FromValue,
1107    T5: FromValue,
1108    T6: FromValue,
1109    T7: FromValue,
1110{
1111    fn from_value_opt(data: &Value) -> Result<Self, AkitaDataError> {
1112        if data.get_obj_len() != 7 {
1113            return Err(AkitaDataError::NoSuchValueError(format!("Can not convert row with {:?}", data)))
1114        }
1115        let ir1 = take_or_place!(data, 0, T1);
1116        let ir2 = take_or_place!(data, 1, T2, [0, ir1]);
1117        let ir3 = take_or_place!(data, 2, T3, [0, ir1], [1, ir2]);
1118        let ir4 = take_or_place!(data, 3, T4, [0, ir1], [1, ir2], [2, ir3]);
1119        let ir5 = take_or_place!(data, 4, T5, [0, ir1], [1, ir2], [2, ir3], [3, ir4]);
1120        let ir6 = take_or_place!(data, 5, T6, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5]);
1121        let ir7 = take_or_place!(data, 6, T7, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6]);
1122        Ok((ir1, ir2, ir3, ir4, ir5, ir6, ir7))
1123    }
1124}
1125
1126
1127
1128
1129impl<T1, T2, T3, T4, T5, T6, T7, T8> FromValue for (T1, T2, T3, T4, T5, T6, T7, T8)
1130where
1131    T1: FromValue,
1132    T2: FromValue,
1133    T3: FromValue,
1134    T4: FromValue,
1135    T5: FromValue,
1136    T6: FromValue,
1137    T7: FromValue,
1138    T8: FromValue,
1139{
1140    fn from_value_opt(data: &Value) -> Result<Self, AkitaDataError> {
1141        if data.get_obj_len() !=8 {
1142            return Err(AkitaDataError::NoSuchValueError(format!("Can not convert row with {:?}", data)))
1143        }
1144        let ir1 = take_or_place!(data, 0, T1);
1145        let ir2 = take_or_place!(data, 1, T2, [0, ir1]);
1146        let ir3 = take_or_place!(data, 2, T3, [0, ir1], [1, ir2]);
1147        let ir4 = take_or_place!(data, 3, T4, [0, ir1], [1, ir2], [2, ir3]);
1148        let ir5 = take_or_place!(data, 4, T5, [0, ir1], [1, ir2], [2, ir3], [3, ir4]);
1149        let ir6 = take_or_place!(data, 5, T6, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5]);
1150        let ir7 = take_or_place!(data, 6, T7, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6]);
1151        let ir8 = take_or_place!(data, 7, T8, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7]);
1152        Ok((ir1, ir2, ir3, ir4, ir5, ir6, ir7, ir8))
1153    }
1154}
1155
1156
1157impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> FromValue for (T1, T2, T3, T4, T5, T6, T7, T8, T9)
1158where
1159    T1: FromValue,
1160    T2: FromValue,
1161    T3: FromValue,
1162    T4: FromValue,
1163    T5: FromValue,
1164    T6: FromValue,
1165    T7: FromValue,
1166    T8: FromValue,
1167    T9: FromValue,
1168{
1169    fn from_value_opt(data: &Value) -> Result<Self, AkitaDataError> {
1170        if data.get_obj_len() !=9 {
1171            return Err(AkitaDataError::NoSuchValueError(format!("Can not convert row with {:?}", data)))
1172        }
1173        let ir1 = take_or_place!(data, 0, T1);
1174        let ir2 = take_or_place!(data, 1, T2, [0, ir1]);
1175        let ir3 = take_or_place!(data, 2, T3, [0, ir1], [1, ir2]);
1176        let ir4 = take_or_place!(data, 3, T4, [0, ir1], [1, ir2], [2, ir3]);
1177        let ir5 = take_or_place!(data, 4, T5, [0, ir1], [1, ir2], [2, ir3], [3, ir4]);
1178        let ir6 = take_or_place!(data, 5, T6, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5]);
1179        let ir7 = take_or_place!(data, 6, T7, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6]);
1180        let ir8 = take_or_place!(data, 7, T8, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7]);
1181        let ir9 = take_or_place!(data, 8, T9, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7], [7, ir8]);
1182        Ok((ir1, ir2, ir3, ir4, ir5, ir6, ir7, ir8, ir9))
1183    }
1184}
1185
1186
1187
1188impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> FromValue for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
1189where
1190    T1: FromValue,
1191    T2: FromValue,
1192    T3: FromValue,
1193    T4: FromValue,
1194    T5: FromValue,
1195    T6: FromValue,
1196    T7: FromValue,
1197    T8: FromValue,
1198    T9: FromValue,
1199    T10: FromValue,
1200{
1201    fn from_value_opt(data: &Value) -> Result<Self, AkitaDataError> {
1202        if data.get_obj_len() !=10 {
1203            return Err(AkitaDataError::NoSuchValueError(format!("Can not convert row with {:?}", data)))
1204        }
1205        let ir1 = take_or_place!(data, 0, T1);
1206        let ir2 = take_or_place!(data, 1, T2, [0, ir1]);
1207        let ir3 = take_or_place!(data, 2, T3, [0, ir1], [1, ir2]);
1208        let ir4 = take_or_place!(data, 3, T4, [0, ir1], [1, ir2], [2, ir3]);
1209        let ir5 = take_or_place!(data, 4, T5, [0, ir1], [1, ir2], [2, ir3], [3, ir4]);
1210        let ir6 = take_or_place!(data, 5, T6, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5]);
1211        let ir7 = take_or_place!(data, 6, T7, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6]);
1212        let ir8 = take_or_place!(data, 7, T8, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7]);
1213        let ir9 = take_or_place!(data, 8, T9, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7], [7, ir8]);
1214        let ir10 = take_or_place!(data, 9, T10, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7], [7, ir8], [8, ir9]);
1215        Ok((ir1, ir2, ir3, ir4, ir5, ir6, ir7, ir8, ir9, ir10))
1216    }
1217}
1218
1219
1220
1221
1222impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> FromValue for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
1223where
1224    T1: FromValue,
1225    T2: FromValue,
1226    T3: FromValue,
1227    T4: FromValue,
1228    T5: FromValue,
1229    T6: FromValue,
1230    T7: FromValue,
1231    T8: FromValue,
1232    T9: FromValue,
1233    T10: FromValue,
1234    T11: FromValue,
1235{
1236    fn from_value_opt(data: &Value) -> Result<Self, AkitaDataError> {
1237        if data.get_obj_len() !=11 {
1238            return Err(AkitaDataError::NoSuchValueError(format!("Can not convert row with {:?}", data)))
1239        }
1240        let ir1 = take_or_place!(data, 0, T1);
1241        let ir2 = take_or_place!(data, 1, T2, [0, ir1]);
1242        let ir3 = take_or_place!(data, 2, T3, [0, ir1], [1, ir2]);
1243        let ir4 = take_or_place!(data, 3, T4, [0, ir1], [1, ir2], [2, ir3]);
1244        let ir5 = take_or_place!(data, 4, T5, [0, ir1], [1, ir2], [2, ir3], [3, ir4]);
1245        let ir6 = take_or_place!(data, 5, T6, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5]);
1246        let ir7 = take_or_place!(data, 6, T7, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6]);
1247        let ir8 = take_or_place!(data, 7, T8, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7]);
1248        let ir9 = take_or_place!(data, 8, T9, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7], [7, ir8]);
1249        let ir10 = take_or_place!(data, 9, T10, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7], [7, ir8], [8, ir9]);
1250        let ir11 = take_or_place!(data, 10, T11, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7], [7, ir8], [8, ir9], [9, ir10]);
1251        Ok((ir1, ir2, ir3, ir4, ir5, ir6, ir7, ir8, ir9, ir10, ir11))
1252    }
1253}
1254
1255
1256impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> FromValue for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
1257where
1258    T1: FromValue,
1259    T2: FromValue,
1260    T3: FromValue,
1261    T4: FromValue,
1262    T5: FromValue,
1263    T6: FromValue,
1264    T7: FromValue,
1265    T8: FromValue,
1266    T9: FromValue,
1267    T10: FromValue,
1268    T11: FromValue,
1269    T12: FromValue,
1270{
1271    fn from_value_opt(data: &Value) -> Result<Self, AkitaDataError> {
1272        if data.get_obj_len() !=12 {
1273            return Err(AkitaDataError::NoSuchValueError(format!("Can not convert row with {:?}", data)))
1274        }
1275        let ir1 = take_or_place!(data, 0, T1);
1276        let ir2 = take_or_place!(data, 1, T2, [0, ir1]);
1277        let ir3 = take_or_place!(data, 2, T3, [0, ir1], [1, ir2]);
1278        let ir4 = take_or_place!(data, 3, T4, [0, ir1], [1, ir2], [2, ir3]);
1279        let ir5 = take_or_place!(data, 4, T5, [0, ir1], [1, ir2], [2, ir3], [3, ir4]);
1280        let ir6 = take_or_place!(data, 5, T6, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5]);
1281        let ir7 = take_or_place!(data, 6, T7, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6]);
1282        let ir8 = take_or_place!(data, 7, T8, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7]);
1283        let ir9 = take_or_place!(data, 8, T9, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7], [7, ir8]);
1284        let ir10 = take_or_place!(data, 9, T10, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7], [7, ir8], [8, ir9]);
1285        let ir11 = take_or_place!(data, 10, T11, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7], [7, ir8], [8, ir9], [9, ir10]);
1286        let ir12 = take_or_place!(data, 11, T12, [0, ir1], [1, ir2], [2, ir3], [3, ir4], [4, ir5], [5, ir6], [6, ir7], [7, ir8], [8, ir9], [9, ir10], [10, ir11]);
1287        Ok((ir1, ir2, ir3, ir4, ir5, ir6, ir7, ir8, ir9, ir10, ir11, ir12))
1288    }
1289}
1290
1291impl <V> ToValue for IndexMap<String, V> where V: ToValue {
1292    fn to_value(&self) -> Value {
1293        let mut map: IndexMap<String, Value> = IndexMap::new();
1294        for key in self.keys() {
1295            if let Some(v) = self.get(key) {
1296                map.insert(key.to_string(), V::to_value(v));
1297            }
1298        }
1299        Value::Object(map)
1300
1301    }
1302}
1303
1304/// Will panic if could not convert `v` to `T`
1305#[inline]
1306pub fn from_value<T: FromValue>(v: Value) -> T {
1307    FromValue::from_value(&v)
1308}
1309
1310/// Will return `Err(FromValueError(v))` if could not convert `v` to `T`
1311#[inline]
1312pub fn from_value_opt<T: FromValue>(v: Value) -> Result<T, AkitaDataError> {
1313    FromValue::from_value_opt(&v)
1314}
1315
1316
1317
1318#[test]
1319fn test_serialize() {
1320    use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime, Utc};
1321    let mut v: Value = Value::Object(IndexMap::new());
1322    v.insert_obj("k", "v");
1323    let serialize = serde_json::to_string(&v).unwrap();
1324    println!("serialize: {}", serialize);
1325    let deserials = serde_json::from_str::<Value>(&serialize).unwrap();
1326    println!("derialize: {:?}", v);
1327
1328}
akita_core/value.rs

akita_core/
value.rs
