orm_mysql/
mysql.rs

1use std::str::FromStr;
2use mysql_async::{prelude::Queryable, Params};
3use crate::mysql::con_value::ValueConv;
4
5pub trait OrmMySqlTrait {
6    async fn query<C>(
7        comm: &mut C,
8        where_sql: &str,
9        limit: Option<usize>,
10    ) -> common_uu::IResult<Vec<Self>>
11    where
12        Self: Sized,
13        C: mysql_async::prelude::Queryable + Send + Sync;
14
15    async fn query_first<C>(comm: &mut C, where_sql: &str) -> common_uu::IResult<Option<Self>>
16    where
17        Self: Sized,
18        C: mysql_async::prelude::Queryable + Send + Sync;
19
20    async fn insert<C>(self, comm: &mut C) -> common_uu::IResult<i64>
21    where
22        Self: Sized,
23        C: mysql_async::prelude::Queryable + Send + Sync;
24
25    fn insert_sql() -> String
26    where
27        Self: Sized;
28
29    async fn update<C>(self, comm: &mut C) -> common_uu::IResult<i64>
30    where
31        Self: Sized,
32        C: mysql_async::prelude::Queryable + Send + Sync;
33
34    async fn delete<C>(&self, comm: &mut C) -> common_uu::IResult<i64>
35    where
36        Self: Sized,
37        C: mysql_async::prelude::Queryable + Send + Sync;
38
39    async fn delete_where<C>(comm: &mut C, where_sql: &str) -> common_uu::IResult<i64>
40    where
41        Self: Sized,
42        C: mysql_async::prelude::Queryable + Send + Sync;
43
44    fn delete_sql() -> String
45    where
46        Self: Sized;
47
48    fn where_id(&self) -> impl Into<mysql_async::Value>
49    where
50        Self: Sized;
51}
52
53pub trait OrmMySqlTraitConn<
54    T: OrmMySqlTrait + Send + Sync + Into<Params>,
55    C: mysql_async::prelude::Queryable + Send + Sync,
56> where
57    Self: Queryable + Sized + Send + Sync,
58{
59    async fn insert_arr(&mut self, arr: Vec<T>) -> common_uu::IResult<i64> {
60        if arr.is_empty() {
61            return Ok(0);
62        }
63        let sql = T::insert_sql();
64        let len = arr.len();
65        self.exec_batch(sql, arr).await?;
66        Ok(len as i64)
67    }
68    async fn delete_arr(&mut self, arr: Vec<T>) -> common_uu::IResult<i64> {
69        if arr.is_empty() {
70            return Ok(0);
71        }
72        let sql = T::delete_sql();
73        let params: Vec<(mysql_async::Value,)> = arr
74            .iter()
75            .map(|x| (x.where_id().into(),))
76            .collect::<Vec<_>>();
77        self.exec_batch(sql, params).await?;
78        Ok(arr.len() as i64)
79    }
80}
81
82impl<T: OrmMySqlTrait + Send + Sync + Into<Params>> OrmMySqlTraitConn<T, Self>
83    for mysql_async::Conn
84{
85}
86
87impl<'a, T: OrmMySqlTrait + Send + Sync + Clone + Into<Params>> OrmMySqlTraitConn<T, Self>
88    for mysql_async::Transaction<'a>
89{
90}
91
92pub mod con_value {
93    use std::str::FromStr;
94
95    pub trait ValueConv<T> {
96        fn conv(&self) -> common_uu::IResult<T>;
97    }
98
99    #[cfg(feature = "chrono")]
100    impl ValueConv<chrono::NaiveTime> for mysql_async::Value {
101        fn conv(&self) -> common_uu::IResult<chrono::NaiveTime> {
102            let v = match self.clone() {
103                mysql_async::Value::Bytes(bytes) => {
104                    let s = String::from_utf8(bytes)?;
105                    let v = chrono::NaiveTime::parse_from_str(&s, "%H:%M:%S")?;
106                    v
107                }
108                mysql_async::Value::Time(_is_negative, days, hours, minutes, seconds, micro) => {
109                    let mut v = chrono::NaiveTime::from_hms(0, 0, 0);
110                    v = v + chrono::Duration::days(days as i64);
111                    v = v + chrono::Duration::hours(hours as i64);
112                    v = v + chrono::Duration::minutes(minutes as i64);
113                    v = v + chrono::Duration::seconds(seconds as i64);
114                    v = v + chrono::Duration::microseconds(micro as i64);
115                    // if is_negative{
116                    //     v = v.checked_neg().unwrap();
117                    // }
118                    v
119                }
120                _ => {
121                    return Err("mysql_async::Value::Time")?;
122                }
123            };
124            Ok(v)
125        }
126    }
127    #[cfg(feature = "chrono")]
128    impl ValueConv<Option<chrono::NaiveTime>> for mysql_async::Value {
129        fn conv(&self) -> common_uu::IResult<Option<chrono::NaiveTime>> {
130            let v = match self.clone() {
131                mysql_async::Value::NULL => return Ok(None),
132                other => other.conv(),
133            }?;
134            Ok(Some(v))
135        }
136    }
137
138    #[cfg(feature = "chrono")]
139    impl ValueConv<chrono::NaiveDateTime> for mysql_async::Value {
140        fn conv(&self) -> common_uu::IResult<chrono::NaiveDateTime> {
141            let v = match self.clone() {
142                mysql_async::Value::Bytes(bytes) => {
143                    let s = String::from_utf8(bytes)?;
144                    chrono::NaiveDateTime::parse_from_str(&s, "%Y-%m-%d %H:%M:%S")
145                }
146                mysql_async::Value::Date(year, month, day, hour, minutes, seconds, micro) => {
147                    chrono::NaiveDateTime::parse_from_str(
148                        &format!("{year}-{month}-{day} {hour}:{minutes}:{seconds}.{micro:0>6}"),
149                        "%Y-%m-%d %H:%M:%S.f6",
150                    )
151                }
152                _ => {
153                    return Err("mysql_async::Value::Date")?;
154                }
155            }?;
156            Ok(v)
157        }
158    }
159
160    #[cfg(feature = "chrono")]
161    impl ValueConv<Option<chrono::NaiveDateTime>> for mysql_async::Value {
162        fn conv(&self) -> common_uu::IResult<Option<chrono::NaiveDateTime>> {
163            let v = match self.clone() {
164                mysql_async::Value::NULL => return Ok(None),
165                other => other.conv(),
166            }?;
167            Ok(Some(v))
168        }
169    }
170
171    #[cfg(feature = "chrono")]
172    impl ValueConv<chrono::NaiveDate> for mysql_async::Value {
173        fn conv(&self) -> common_uu::IResult<chrono::NaiveDate> {
174            let v = match self.clone() {
175                mysql_async::Value::Bytes(bytes) => {
176                    let s = String::from_utf8(bytes)?;
177                    chrono::NaiveDate::parse_from_str(&s, "%Y-%m-%d")
178                }
179                mysql_async::Value::Date(year, month, day, hour, minutes, seconds, micro) => {
180                    chrono::NaiveDate::parse_from_str(&format!("{year}-{month}-{day}"), "%Y-%m-%d")
181                }
182                mysql_async::Value::Time(_is_negative, days, hours, minutes, seconds, micro) => {
183                    let mut v = chrono::NaiveDate::from_ymd(1970, 1, 1);
184                    v = v + chrono::Duration::days(days as i64);
185                    Ok(v)
186                }
187                _ => {
188                    return Err("mysql_async deser tos chrono::NaiveDate")?;
189                }
190            }?;
191            Ok(v)
192        }
193    }
194    #[cfg(feature = "chrono")]
195    impl ValueConv<Option<chrono::NaiveDate>> for mysql_async::Value {
196        fn conv(&self) -> common_uu::IResult<Option<chrono::NaiveDate>> {
197            let v = match self.clone() {
198                mysql_async::Value::NULL => return Ok(None),
199                other => other.conv(),
200            }?;
201            Ok(Some(v))
202        }
203    }
204
205    #[cfg(feature = "chrono")]
206    impl ValueConv<chrono::DateTime<chrono::Local>> for mysql_async::Value {
207        fn conv(&self) -> common_uu::IResult<chrono::DateTime<chrono::Local>> {
208            let v = match self.clone() {
209                mysql_async::Value::Int(timestament) => {
210                    use chrono::TimeZone;
211                    let dt = chrono::Local.timestamp(timestament as i64, 0);
212                    dt
213                }
214                mysql_async::Value::UInt(timestament) => {
215                    use chrono::TimeZone;
216                    let dt = chrono::Local.timestamp(timestament as i64, 0);
217                    dt
218                }
219                mysql_async::Value::Time(_is_negative, days, hours, minutes, seconds, micro) => {
220                    let mut v = chrono::NaiveTime::from_hms(0, 0, 0);
221                    v = v + chrono::Duration::days(days as i64);
222                    v = v + chrono::Duration::hours(hours as i64);
223                    v = v + chrono::Duration::minutes(minutes as i64);
224                    v = v + chrono::Duration::seconds(seconds as i64);
225                    v = v + chrono::Duration::microseconds(micro as i64);
226                    // if is_negative{
227                    //     v = v.checked_neg().unwrap();
228                    // }
229                    chrono::Local::now().date().and_time(v).unwrap_or_default()
230                }
231                mysql_async::Value::Date(year, month, day, hour, minutes, seconds, micro) => {
232                    use chrono::TimeZone;
233                    let dt = chrono::Local
234                        .ymd(year as i32, month as u32, day as u32)
235                        .and_hms_micro(hour as u32, minutes as u32, seconds as u32, micro as u32);
236                    dt
237                }
238                other => Err(format!("ValueConv Error: {:?}", other))?,
239            };
240            Ok(v)
241        }
242    }
243
244    #[cfg(feature = "chrono")]
245    impl ValueConv<Option<chrono::DateTime<chrono::Local>>> for mysql_async::Value {
246        fn conv(&self) -> common_uu::IResult<Option<chrono::DateTime<chrono::Local>>> {
247            let v = match self.clone() {
248                mysql_async::Value::NULL => {
249                    return Ok(None);
250                }
251                other => other.conv()?,
252            };
253            Ok(v)
254        }
255    }
256
257    #[cfg(feature = "chrono")]
258    impl ValueConv<Option<chrono::DateTime<chrono::Utc>>> for mysql_async::Value {
259        fn conv(&self) -> common_uu::IResult<Option<chrono::DateTime<chrono::Utc>>> {
260            let v = match self.clone() {
261                mysql_async::Value::NULL => {
262                    return Ok(None);
263                }
264                other => other.conv()?,
265            };
266            Ok(v)
267        }
268    }
269
270    #[cfg(feature = "rust_decimal")]
271    impl ValueConv<Option<rust_decimal::Decimal>> for mysql_async::Value {
272        fn conv(&self) -> common_uu::IResult<Option<rust_decimal::Decimal>> {
273            use rust_decimal::prelude::*;
274            let v = match self.clone() {
275                mysql_async::Value::NULL => None,
276                mysql_async::Value::Bytes(v) => {
277                    Some(rust_decimal::Decimal::from_str(&(String::from_utf8(v)?))?)
278                }
279                mysql_async::Value::Int(v) => rust_decimal::Decimal::from_i64(v),
280                mysql_async::Value::UInt(v) => Decimal::from_i64(v as i64),
281                mysql_async::Value::Float(v) => Decimal::from_f32(v),
282                mysql_async::Value::Double(v) => Decimal::from_f64(v),
283                other => Err(format!("ValueConv Error: {:?}", other))?,
284            };
285            Ok(v)
286        }
287    }
288
289    #[cfg(feature = "rust_decimal")]
290    impl ValueConv<rust_decimal::Decimal> for mysql_async::Value {
291        fn conv(&self) -> common_uu::IResult<rust_decimal::Decimal> {
292            use rust_decimal::prelude::*;
293            let v = match self.clone() {
294                mysql_async::Value::NULL => None,
295                mysql_async::Value::Bytes(v) => {
296                    Some(rust_decimal::Decimal::from_str(&(String::from_utf8(v)?))?)
297                }
298                mysql_async::Value::Int(v) => rust_decimal::Decimal::from_i64(v),
299                mysql_async::Value::UInt(v) => Decimal::from_i64(v as i64),
300                mysql_async::Value::Float(v) => Decimal::from_f32(v),
301                mysql_async::Value::Double(v) => Decimal::from_f64(v),
302                other => Err(format!("ValueConv Error: {:?}", other))?,
303            };
304            Ok(v.unwrap_or_else(|| rust_decimal::Decimal::ZERO))
305        }
306    }
307
308    #[cfg(feature = "bigdecimal")]
309    impl ValueConv<Option<bigdecimal::BigDecimal>> for mysql_async::Value {
310        fn conv(&self) -> common_uu::IResult<Option<bigdecimal::BigDecimal>> {
311            use bigdecimal::BigDecimal as Decimal;
312            use bigdecimal::FromPrimitive;
313            let v = match self.clone() {
314                mysql_async::Value::NULL => None,
315                mysql_async::Value::Bytes(v) => Some(Decimal::from_str(&(String::from_utf8(v)?))?),
316                mysql_async::Value::Int(v) => Decimal::from_i64(v),
317                mysql_async::Value::UInt(v) => Decimal::from_i64(v as i64),
318                mysql_async::Value::Float(v) => Decimal::from_f32(v),
319                mysql_async::Value::Double(v) => Decimal::from_f64(v),
320                other => Err(format!("ValueConv Error: {:?}", other))?,
321            };
322            Ok(v)
323        }
324    }
325
326    #[cfg(feature = "bigdecimal")]
327    impl ValueConv<bigdecimal::BigDecimal> for mysql_async::Value {
328        fn conv(&self) -> common_uu::IResult<bigdecimal::BigDecimal> {
329            use bigdecimal::BigDecimal as Decimal;
330            use bigdecimal::FromPrimitive;
331            let v = match self.clone() {
332                mysql_async::Value::NULL => None,
333                mysql_async::Value::Bytes(v) => Some(Decimal::from_str(&(String::from_utf8(v)?))?),
334                mysql_async::Value::Int(v) => Decimal::from_i64(v),
335                mysql_async::Value::UInt(v) => Decimal::from_i64(v as i64),
336                mysql_async::Value::Float(v) => Decimal::from_f32(v),
337                mysql_async::Value::Double(v) => Decimal::from_f64(v),
338                other => Err(format!("ValueConv Error: {:?}", other))?,
339            };
340            Ok(v.unwrap_or_else(|| Decimal::default()))
341        }
342    }
343
344    impl ValueConv<f64> for mysql_async::Value {
345        fn conv(&self) -> common_uu::IResult<f64> {
346            let v = match self.clone() {
347                mysql_async::Value::NULL => 0.0,
348                mysql_async::Value::Bytes(v) => String::from_utf8(v)?.parse()?,
349                mysql_async::Value::Int(v) => v as f64,
350                mysql_async::Value::UInt(v) => v as f64,
351                mysql_async::Value::Float(v) => v as f64,
352                mysql_async::Value::Double(v) => v,
353                other => Err(format!("ValueConv Error: {:?}", other))?,
354            };
355            Ok(v)
356        }
357    }
358    impl ValueConv<Option<f64>> for mysql_async::Value {
359        fn conv(&self) -> common_uu::IResult<Option<f64>> {
360            let v = match self.clone() {
361                mysql_async::Value::NULL => None,
362                mysql_async::Value::Bytes(v) => Some(String::from_utf8(v)?.parse()?),
363                mysql_async::Value::Int(v) => Some(v as f64),
364                mysql_async::Value::UInt(v) => Some(v as f64),
365                mysql_async::Value::Float(v) => Some(v as f64),
366                mysql_async::Value::Double(v) => Some(v),
367                other => Err(format!("ValueConv Error: {:?}", other))?,
368            };
369            Ok(v)
370        }
371    }
372
373    impl ValueConv<f32> for mysql_async::Value {
374        fn conv(&self) -> common_uu::IResult<f32> {
375            let v = match self.clone() {
376                mysql_async::Value::NULL => 0.0,
377                mysql_async::Value::Bytes(v) => String::from_utf8(v)?.parse()?,
378                mysql_async::Value::Int(v) => v as f32,
379                mysql_async::Value::UInt(v) => v as f32,
380                mysql_async::Value::Float(v) => v,
381                mysql_async::Value::Double(v) => v as f32,
382                other => Err(format!("ValueConv Error: {:?}", other))?,
383            };
384            Ok(v)
385        }
386    }
387    impl ValueConv<Option<f32>> for mysql_async::Value {
388        fn conv(&self) -> common_uu::IResult<Option<f32>> {
389            let v = match self.clone() {
390                mysql_async::Value::NULL => None,
391                mysql_async::Value::Bytes(v) => Some(String::from_utf8(v)?.parse()?),
392                mysql_async::Value::Int(v) => Some(v as f32),
393                mysql_async::Value::UInt(v) => Some(v as f32),
394                mysql_async::Value::Float(v) => Some(v),
395                mysql_async::Value::Double(v) => Some(v as f32),
396                other => Err(format!("ValueConv Error: {:?}", other))?,
397            };
398            Ok(v)
399        }
400    }
401
402    impl ValueConv<isize> for mysql_async::Value {
403        fn conv(&self) -> common_uu::IResult<isize> {
404            let v = match self.clone() {
405                mysql_async::Value::NULL => 0,
406                mysql_async::Value::Bytes(v) => String::from_utf8(v)?.parse()?,
407                mysql_async::Value::Int(v) => v as isize,
408                mysql_async::Value::UInt(v) => v as isize,
409                mysql_async::Value::Float(v) => v as isize,
410                mysql_async::Value::Double(v) => v as isize,
411                other => Err(format!("ValueConv Error: {:?}", other))?,
412            };
413            Ok(v)
414        }
415    }
416    impl ValueConv<Option<isize>> for mysql_async::Value {
417        fn conv(&self) -> common_uu::IResult<Option<isize>> {
418            let v = match self.clone() {
419                mysql_async::Value::NULL => None,
420                mysql_async::Value::Bytes(v) => Some(String::from_utf8(v)?.parse()?),
421                mysql_async::Value::Int(v) => Some(v as isize),
422                mysql_async::Value::UInt(v) => Some(v as isize),
423                mysql_async::Value::Float(v) => Some(v as isize),
424                mysql_async::Value::Double(v) => Some(v as isize),
425                other => Err(format!("ValueConv Error: {:?}", other))?,
426            };
427            Ok(v)
428        }
429    }
430
431    impl ValueConv<u64> for mysql_async::Value {
432        fn conv(&self) -> common_uu::IResult<u64> {
433            let v = match self.clone() {
434                mysql_async::Value::NULL => 0,
435                mysql_async::Value::Bytes(v) => String::from_utf8(v)?.parse()?,
436                mysql_async::Value::Int(v) => v as u64,
437                mysql_async::Value::UInt(v) => v as u64,
438                mysql_async::Value::Float(v) => v as u64,
439                mysql_async::Value::Double(v) => v as u64,
440                other => Err(format!("ValueConv Error: {:?}", other))?,
441            };
442            Ok(v)
443        }
444    }
445    impl ValueConv<Option<u64>> for mysql_async::Value {
446        fn conv(&self) -> common_uu::IResult<Option<u64>> {
447            let v = match self.clone() {
448                mysql_async::Value::NULL => None,
449                mysql_async::Value::Bytes(v) => Some(String::from_utf8(v)?.parse()?),
450                mysql_async::Value::Int(v) => Some(v as u64),
451                mysql_async::Value::UInt(v) => Some(v as u64),
452                mysql_async::Value::Float(v) => Some(v as u64),
453                mysql_async::Value::Double(v) => Some(v as u64),
454                other => Err(format!("ValueConv Error: {:?}", other))?,
455            };
456            Ok(v)
457        }
458    }
459
460    impl ValueConv<u32> for mysql_async::Value {
461        fn conv(&self) -> common_uu::IResult<u32> {
462            let v = match self.clone() {
463                mysql_async::Value::NULL => 0,
464                mysql_async::Value::Bytes(v) => String::from_utf8(v)?.parse()?,
465                mysql_async::Value::Int(v) => v as u32,
466                mysql_async::Value::UInt(v) => v as u32,
467                mysql_async::Value::Float(v) => v as u32,
468                mysql_async::Value::Double(v) => v as u32,
469                other => Err(format!("ValueConv Error: {:?}", other))?,
470            };
471            Ok(v)
472        }
473    }
474    impl ValueConv<Option<u32>> for mysql_async::Value {
475        fn conv(&self) -> common_uu::IResult<Option<u32>> {
476            let v = match self.clone() {
477                mysql_async::Value::NULL => None,
478                mysql_async::Value::Bytes(v) => Some(String::from_utf8(v)?.parse()?),
479                mysql_async::Value::Int(v) => Some(v as u32),
480                mysql_async::Value::UInt(v) => Some(v as u32),
481                mysql_async::Value::Float(v) => Some(v as u32),
482                mysql_async::Value::Double(v) => Some(v as u32),
483                other => Err(format!("ValueConv Error: {:?}", other))?,
484            };
485            Ok(v)
486        }
487    }
488
489    impl ValueConv<usize> for mysql_async::Value {
490        fn conv(&self) -> common_uu::IResult<usize> {
491            let v = match self.clone() {
492                mysql_async::Value::NULL => 0,
493                mysql_async::Value::Bytes(v) => String::from_utf8(v)?.parse()?,
494                mysql_async::Value::Int(v) => v as usize,
495                mysql_async::Value::UInt(v) => v as usize,
496                mysql_async::Value::Float(v) => v as usize,
497                mysql_async::Value::Double(v) => v as usize,
498                other => Err(format!("ValueConv Error: {:?}", other))?,
499            };
500            Ok(v)
501        }
502    }
503    impl ValueConv<Option<usize>> for mysql_async::Value {
504        fn conv(&self) -> common_uu::IResult<Option<usize>> {
505            let v = match self.clone() {
506                mysql_async::Value::NULL => None,
507                mysql_async::Value::Bytes(v) => Some(String::from_utf8(v)?.parse()?),
508                mysql_async::Value::Int(v) => Some(v as usize),
509                mysql_async::Value::UInt(v) => Some(v as usize),
510                mysql_async::Value::Float(v) => Some(v as usize),
511                mysql_async::Value::Double(v) => Some(v as usize),
512                other => Err(format!("ValueConv Error: {:?}", other))?,
513            };
514            Ok(v)
515        }
516    }
517
518    impl ValueConv<u8> for mysql_async::Value {
519        fn conv(&self) -> common_uu::IResult<u8> {
520            let v = match self.clone() {
521                mysql_async::Value::NULL => 0,
522                mysql_async::Value::Bytes(v) => String::from_utf8(v)?.parse()?,
523                mysql_async::Value::Int(v) => v as u8,
524                mysql_async::Value::UInt(v) => v as u8,
525                mysql_async::Value::Float(v) => v as u8,
526                mysql_async::Value::Double(v) => v as u8,
527                other => Err(format!("ValueConv Error: {:?}", other))?,
528            };
529            Ok(v)
530        }
531    }
532
533    impl ValueConv<Option<u8>> for mysql_async::Value {
534        fn conv(&self) -> common_uu::IResult<Option<u8>> {
535            let v = match self.clone() {
536                mysql_async::Value::NULL => None,
537                mysql_async::Value::Bytes(v) => Some(String::from_utf8(v)?.parse()?),
538                mysql_async::Value::Int(v) => Some(v as u8),
539                mysql_async::Value::UInt(v) => Some(v as u8),
540                mysql_async::Value::Float(v) => Some(v as u8),
541                mysql_async::Value::Double(v) => Some(v as u8),
542                other => Err(format!("ValueConv Error: {:?}", other))?,
543            };
544            Ok(v)
545        }
546    }
547
548    impl ValueConv<i32> for mysql_async::Value {
549        fn conv(&self) -> common_uu::IResult<i32> {
550            let v = match self.clone() {
551                mysql_async::Value::NULL => 0,
552                mysql_async::Value::Bytes(v) => String::from_utf8(v)?.parse()?,
553                mysql_async::Value::Int(v) => v as i32,
554                mysql_async::Value::UInt(v) => v as i32,
555                mysql_async::Value::Float(v) => v as i32,
556                mysql_async::Value::Double(v) => v as i32,
557                other => Err(format!("ValueConv Error: {:?}", other))?,
558            };
559            Ok(v)
560        }
561    }
562
563    impl ValueConv<Option<i32>> for mysql_async::Value {
564        fn conv(&self) -> common_uu::IResult<Option<i32>> {
565            let v = match self.clone() {
566                mysql_async::Value::NULL => None,
567                mysql_async::Value::Bytes(v) => Some(String::from_utf8(v)?.parse()?),
568                mysql_async::Value::Int(v) => Some(v as i32),
569                mysql_async::Value::UInt(v) => Some(v as i32),
570                mysql_async::Value::Float(v) => Some(v as i32),
571                mysql_async::Value::Double(v) => Some(v as i32),
572                other => Err(format!("ValueConv Error: {:?}", other))?,
573            };
574            Ok(v)
575        }
576    }
577
578    impl ValueConv<i64> for mysql_async::Value {
579        fn conv(&self) -> common_uu::IResult<i64> {
580            let v = match self.clone() {
581                mysql_async::Value::NULL => 0,
582                mysql_async::Value::Bytes(v) => String::from_utf8(v)?.parse()?,
583                mysql_async::Value::Int(v) => v,
584                mysql_async::Value::UInt(v) => v as i64,
585                mysql_async::Value::Float(v) => v as i64,
586                mysql_async::Value::Double(v) => v as i64,
587                other => Err(format!("ValueConv Error: {:?}", other))?,
588            };
589            Ok(v)
590        }
591    }
592    impl ValueConv<Option<i64>> for mysql_async::Value {
593        fn conv(&self) -> common_uu::IResult<Option<i64>> {
594            let v = match self.clone() {
595                mysql_async::Value::NULL => None,
596                mysql_async::Value::Bytes(v) => Some(String::from_utf8(v)?.parse()?),
597                mysql_async::Value::Int(v) => Some(v),
598                mysql_async::Value::UInt(v) => Some(v as i64),
599                mysql_async::Value::Float(v) => Some(v as i64),
600                mysql_async::Value::Double(v) => Some(v as i64),
601                other => Err(format!("ValueConv Error: {:?}", other))?,
602            };
603            Ok(v)
604        }
605    }
606
607    impl ValueConv<String> for mysql_async::Value {
608        fn conv(&self) -> common_uu::IResult<String> {
609            let v = match self.clone() {
610                mysql_async::Value::NULL => "".into(),
611                mysql_async::Value::Bytes(v) => String::from_utf8(v)?,
612                mysql_async::Value::Int(v) => v.to_string(),
613                mysql_async::Value::UInt(v) => v.to_string(),
614                mysql_async::Value::Float(v) => v.to_string(),
615                mysql_async::Value::Double(v) => v.to_string(),
616                other => format!("{:?}", other),
617            };
618            Ok(v)
619        }
620    }
621
622    impl ValueConv<Option<String>> for mysql_async::Value {
623        fn conv(&self) -> common_uu::IResult<Option<String>> {
624            let v = match self.clone() {
625                mysql_async::Value::NULL => return Ok(None),
626                mysql_async::Value::Bytes(v) => String::from_utf8(v)?,
627                mysql_async::Value::Int(v) => v.to_string(),
628                mysql_async::Value::UInt(v) => v.to_string(),
629                mysql_async::Value::Float(v) => v.to_string(),
630                mysql_async::Value::Double(v) => v.to_string(),
631                other => format!("{:?}", other),
632            };
633            Ok(Some(v))
634        }
635    }
636}
orm_mysql/mysql.rs

orm_mysql/
mysql.rs
