sea_query_sqlx/
sqlx_sqlite.rs

1use crate::SqlxValues;
2use sea_query::Value;
3
4impl<'q> sqlx::IntoArguments<'q, sqlx::sqlite::Sqlite> for SqlxValues {
5    fn into_arguments(self) -> sqlx::sqlite::SqliteArguments<'q> {
6        let mut args = sqlx::sqlite::SqliteArguments::default();
7        for arg in self.0.into_iter() {
8            use sqlx::Arguments;
9            match arg {
10                Value::Bool(b) => {
11                    let _ = args.add(b);
12                }
13                Value::TinyInt(i) => {
14                    let _ = args.add(i);
15                }
16                Value::SmallInt(i) => {
17                    let _ = args.add(i);
18                }
19                Value::Int(i) => {
20                    let _ = args.add(i);
21                }
22                Value::BigInt(i) => {
23                    let _ = args.add(i);
24                }
25                Value::TinyUnsigned(i) => {
26                    let _ = args.add(i);
27                }
28                Value::SmallUnsigned(i) => {
29                    let _ = args.add(i);
30                }
31                Value::Unsigned(i) => {
32                    let _ = args.add(i);
33                }
34                Value::BigUnsigned(i) => {
35                    let _ = args
36                        .add(i.map(|i| <i64 as std::convert::TryFrom<u64>>::try_from(i).unwrap()));
37                }
38                Value::Float(f) => {
39                    let _ = args.add(f);
40                }
41                Value::Double(d) => {
42                    let _ = args.add(d);
43                }
44                Value::String(s) => {
45                    let _ = args.add(s);
46                }
47                Value::Char(c) => {
48                    let _ = args.add(c.map(|c| c.to_string()));
49                }
50                Value::Bytes(b) => {
51                    let _ = args.add(b);
52                }
53                #[cfg(feature = "with-chrono")]
54                Value::ChronoDate(d) => {
55                    let _ = args.add(d);
56                }
57                #[cfg(feature = "with-chrono")]
58                Value::ChronoTime(t) => {
59                    let _ = args.add(t);
60                }
61                #[cfg(feature = "with-chrono")]
62                Value::ChronoDateTime(t) => {
63                    let _ = args.add(t);
64                }
65                #[cfg(feature = "with-chrono")]
66                Value::ChronoDateTimeUtc(t) => {
67                    let _ = args.add(t);
68                }
69                #[cfg(feature = "with-chrono")]
70                Value::ChronoDateTimeLocal(t) => {
71                    let _ = args.add(t);
72                }
73                #[cfg(feature = "with-chrono")]
74                Value::ChronoDateTimeWithTimeZone(t) => {
75                    let _ = args.add(t);
76                }
77                #[cfg(feature = "with-time")]
78                Value::TimeDate(t) => {
79                    let _ = args.add(t);
80                }
81                #[cfg(feature = "with-time")]
82                Value::TimeTime(t) => {
83                    let _ = args.add(t);
84                }
85                #[cfg(feature = "with-time")]
86                Value::TimeDateTime(t) => {
87                    let _ = args.add(t);
88                }
89                #[cfg(feature = "with-time")]
90                Value::TimeDateTimeWithTimeZone(t) => {
91                    let _ = args.add(t);
92                }
93                #[cfg(feature = "with-uuid")]
94                Value::Uuid(uuid) => {
95                    let _ = args.add(uuid);
96                }
97                #[cfg(feature = "with-rust_decimal")]
98                Value::Decimal(decimal) => {
99                    let _ = args.add(decimal.map(|d| d.to_string()));
100                }
101                #[cfg(feature = "with-bigdecimal")]
102                Value::BigDecimal(big_decimal) => {
103                    use sea_query::prelude::bigdecimal::ToPrimitive;
104                    let _ = args.add(big_decimal.map(|d| d.to_string()));
105                }
106                #[cfg(feature = "with-json")]
107                Value::Json(j) => {
108                    let _ = args.add(j.map(|j| *j));
109                }
110                #[cfg(feature = "with-ipnetwork")]
111                Value::IpNetwork(_) => {
112                    panic!("Sqlite doesn't support IpNetwork arguments");
113                }
114                #[cfg(feature = "with-mac_address")]
115                Value::MacAddress(_) => {
116                    panic!("Sqlite doesn't support MacAddress arguments");
117                }
118                #[cfg(feature = "postgres-array")]
119                Value::Array(_, _) => {
120                    panic!("Sqlite doesn't support array arguments");
121                }
122                #[cfg(feature = "postgres-vector")]
123                Value::Vector(_) => {
124                    panic!("Sqlite doesn't support vector arguments");
125                } /* #[cfg(feature = "postgres-range")]
126                  Value::Range(_) => {
127                      panic!("Sqlite doesn't support PgRange arguments");
128                  } */
129            }
130        }
131        args
132    }
133}
sea_query_sqlx/sqlx_sqlite.rs

sea_query_sqlx/
sqlx_sqlite.rs
