sea_query_sqlx/
sqlx_postgres.rs

1#[cfg(feature = "with-bigdecimal")]
2use sea_query::prelude::BigDecimal;
3#[cfg(feature = "with-rust_decimal")]
4use sea_query::prelude::Decimal;
5#[cfg(feature = "with-ipnetwork")]
6use sea_query::prelude::IpNetwork;
7#[cfg(feature = "with-json")]
8use sea_query::prelude::Json;
9#[cfg(feature = "with-mac_address")]
10use sea_query::prelude::MacAddress;
11#[cfg(feature = "with-uuid")]
12use sea_query::prelude::Uuid;
13#[cfg(feature = "with-time")]
14use sea_query::prelude::time;
15#[cfg(feature = "with-chrono")]
16use sea_query::prelude::{DateTime, FixedOffset, Local, NaiveDate, NaiveDateTime, NaiveTime, Utc};
17
18use sea_query::{ArrayType, Value};
19
20use crate::SqlxValues;
21
22impl sqlx::IntoArguments<'_, sqlx::postgres::Postgres> for SqlxValues {
23    fn into_arguments(self) -> sqlx::postgres::PgArguments {
24        let mut args = sqlx::postgres::PgArguments::default();
25        for arg in self.0.into_iter() {
26            use sqlx::Arguments;
27            match arg {
28                Value::Bool(b) => {
29                    let _ = args.add(b);
30                }
31                Value::TinyInt(i) => {
32                    let _ = args.add(i);
33                }
34                Value::SmallInt(i) => {
35                    let _ = args.add(i);
36                }
37                Value::Int(i) => {
38                    let _ = args.add(i);
39                }
40                Value::BigInt(i) => {
41                    let _ = args.add(i);
42                }
43                Value::TinyUnsigned(i) => {
44                    let _ = args.add(i.map(|i| i as i16));
45                }
46                Value::SmallUnsigned(i) => {
47                    let _ = args.add(i.map(|i| i as i32));
48                }
49                Value::Unsigned(i) => {
50                    let _ = args.add(i.map(|i| i as i64));
51                }
52                Value::BigUnsigned(i) => {
53                    let _ = args.add(i.map(|i| <i64 as TryFrom<u64>>::try_from(i).unwrap()));
54                }
55                Value::Float(f) => {
56                    let _ = args.add(f);
57                }
58                Value::Double(d) => {
59                    let _ = args.add(d);
60                }
61                Value::String(s) => {
62                    let _ = args.add(s.as_deref());
63                }
64                Value::Char(c) => {
65                    let _ = args.add(c.map(|c| c.to_string()));
66                }
67                Value::Bytes(b) => {
68                    let _ = args.add(b.as_deref());
69                }
70                #[cfg(feature = "with-chrono")]
71                Value::ChronoDate(d) => {
72                    let _ = args.add(d);
73                }
74                #[cfg(feature = "with-chrono")]
75                Value::ChronoTime(t) => {
76                    let _ = args.add(t);
77                }
78                #[cfg(feature = "with-chrono")]
79                Value::ChronoDateTime(t) => {
80                    let _ = args.add(t);
81                }
82                #[cfg(feature = "with-chrono")]
83                Value::ChronoDateTimeUtc(t) => {
84                    let _ = args.add(t);
85                }
86                #[cfg(feature = "with-chrono")]
87                Value::ChronoDateTimeLocal(t) => {
88                    let _ = args.add(t);
89                }
90                #[cfg(feature = "with-chrono")]
91                Value::ChronoDateTimeWithTimeZone(t) => {
92                    let _ = args.add(t);
93                }
94                #[cfg(feature = "with-time")]
95                Value::TimeDate(t) => {
96                    let _ = args.add(t);
97                }
98                #[cfg(feature = "with-time")]
99                Value::TimeTime(t) => {
100                    let _ = args.add(t);
101                }
102                #[cfg(feature = "with-time")]
103                Value::TimeDateTime(t) => {
104                    let _ = args.add(t);
105                }
106                #[cfg(feature = "with-time")]
107                Value::TimeDateTimeWithTimeZone(t) => {
108                    let _ = args.add(t);
109                }
110                #[cfg(feature = "with-uuid")]
111                Value::Uuid(uuid) => {
112                    let _ = args.add(uuid);
113                }
114                #[cfg(feature = "with-rust_decimal")]
115                Value::Decimal(d) => {
116                    let _ = args.add(d);
117                }
118                #[cfg(feature = "with-bigdecimal")]
119                Value::BigDecimal(d) => {
120                    let _ = args.add(d.as_deref());
121                }
122                #[cfg(feature = "with-json")]
123                Value::Json(j) => {
124                    let _ = args.add(j.as_deref());
125                }
126                #[cfg(feature = "with-ipnetwork")]
127                Value::IpNetwork(ip) => {
128                    let _ = args.add(ip);
129                }
130                #[cfg(feature = "with-mac_address")]
131                Value::MacAddress(mac) => {
132                    let _ = args.add(mac);
133                }
134                #[cfg(feature = "postgres-array")]
135                Value::Array(ty, v) => match ty {
136                    ArrayType::Bool => {
137                        let value: Option<Vec<bool>> = Value::Array(ty, v)
138                            .expect("This Value::Array should consist of Value::Bool");
139                        let _ = args.add(value);
140                    }
141                    ArrayType::TinyInt => {
142                        let value: Option<Vec<i8>> = Value::Array(ty, v)
143                            .expect("This Value::Array should consist of Value::TinyInt");
144                        let _ = args.add(value);
145                    }
146                    ArrayType::SmallInt => {
147                        let value: Option<Vec<i16>> = Value::Array(ty, v)
148                            .expect("This Value::Array should consist of Value::SmallInt");
149                        let _ = args.add(value);
150                    }
151                    ArrayType::Int => {
152                        let value: Option<Vec<i32>> = Value::Array(ty, v)
153                            .expect("This Value::Array should consist of Value::Int");
154                        let _ = args.add(value);
155                    }
156                    ArrayType::BigInt => {
157                        let value: Option<Vec<i64>> = Value::Array(ty, v)
158                            .expect("This Value::Array should consist of Value::BigInt");
159                        let _ = args.add(value);
160                    }
161                    ArrayType::TinyUnsigned => {
162                        let value: Option<Vec<u8>> = Value::Array(ty, v)
163                            .expect("This Value::Array should consist of Value::TinyUnsigned");
164                        let value: Option<Vec<i16>> =
165                            value.map(|vec| vec.into_iter().map(|i| i as i16).collect());
166                        let _ = args.add(value);
167                    }
168                    ArrayType::SmallUnsigned => {
169                        let value: Option<Vec<u16>> = Value::Array(ty, v)
170                            .expect("This Value::Array should consist of Value::SmallUnsigned");
171                        let value: Option<Vec<i32>> =
172                            value.map(|vec| vec.into_iter().map(|i| i as i32).collect());
173                        let _ = args.add(value);
174                    }
175                    ArrayType::Unsigned => {
176                        let value: Option<Vec<u32>> = Value::Array(ty, v)
177                            .expect("This Value::Array should consist of Value::Unsigned");
178                        let value: Option<Vec<i64>> =
179                            value.map(|vec| vec.into_iter().map(|i| i as i64).collect());
180                        let _ = args.add(value);
181                    }
182                    ArrayType::BigUnsigned => {
183                        let value: Option<Vec<u64>> = Value::Array(ty, v)
184                            .expect("This Value::Array should consist of Value::BigUnsigned");
185                        let value: Option<Vec<i64>> = value.map(|vec| {
186                            vec.into_iter()
187                                .map(|i| <i64 as TryFrom<u64>>::try_from(i).unwrap())
188                                .collect()
189                        });
190                        let _ = args.add(value);
191                    }
192                    ArrayType::Float => {
193                        let value: Option<Vec<f32>> = Value::Array(ty, v)
194                            .expect("This Value::Array should consist of Value::Float");
195                        let _ = args.add(value);
196                    }
197                    ArrayType::Double => {
198                        let value: Option<Vec<f64>> = Value::Array(ty, v)
199                            .expect("This Value::Array should consist of Value::Double");
200                        let _ = args.add(value);
201                    }
202                    ArrayType::String => {
203                        let value: Option<Vec<String>> = Value::Array(ty, v)
204                            .expect("This Value::Array should consist of Value::String");
205                        let _ = args.add(value);
206                    }
207                    ArrayType::Char => {
208                        let value: Option<Vec<char>> = Value::Array(ty, v)
209                            .expect("This Value::Array should consist of Value::Char");
210                        let value: Option<Vec<String>> =
211                            value.map(|vec| vec.into_iter().map(|c| c.to_string()).collect());
212                        let _ = args.add(value);
213                    }
214                    ArrayType::Bytes => {
215                        let value: Option<Vec<Vec<u8>>> = Value::Array(ty, v)
216                            .expect("This Value::Array should consist of Value::Bytes");
217                        let _ = args.add(value);
218                    }
219                    #[cfg(feature = "with-chrono")]
220                    ArrayType::ChronoDate => {
221                        let value: Option<Vec<NaiveDate>> = Value::Array(ty, v)
222                            .expect("This Value::Array should consist of Value::ChronoDate");
223                        let _ = args.add(value);
224                    }
225                    #[cfg(feature = "with-chrono")]
226                    ArrayType::ChronoTime => {
227                        let value: Option<Vec<NaiveTime>> = Value::Array(ty, v)
228                            .expect("This Value::Array should consist of Value::ChronoTime");
229                        let _ = args.add(value);
230                    }
231                    #[cfg(feature = "with-chrono")]
232                    ArrayType::ChronoDateTime => {
233                        let value: Option<Vec<NaiveDateTime>> = Value::Array(ty, v)
234                            .expect("This Value::Array should consist of Value::ChronoDateTime");
235                        let _ = args.add(value);
236                    }
237                    #[cfg(feature = "with-chrono")]
238                    ArrayType::ChronoDateTimeUtc => {
239                        let value: Option<Vec<DateTime<Utc>>> = Value::Array(ty, v)
240                            .expect("This Value::Array should consist of Value::ChronoDateTimeUtc");
241                        let _ = args.add(value);
242                    }
243                    #[cfg(feature = "with-chrono")]
244                    ArrayType::ChronoDateTimeLocal => {
245                        let value: Option<Vec<DateTime<Local>>> = Value::Array(ty, v).expect(
246                            "This Value::Array should consist of Value::ChronoDateTimeLocal",
247                        );
248                        let _ = args.add(value);
249                    }
250                    #[cfg(feature = "with-chrono")]
251                    ArrayType::ChronoDateTimeWithTimeZone => {
252                        let value: Option<Vec<DateTime<FixedOffset>>> = Value::Array(ty, v).expect(
253                            "This Value::Array should consist of Value::ChronoDateTimeWithTimeZone",
254                        );
255                        let _ = args.add(value);
256                    }
257                    #[cfg(feature = "with-time")]
258                    ArrayType::TimeDate => {
259                        let value: Option<Vec<time::Date>> = Value::Array(ty, v)
260                            .expect("This Value::Array should consist of Value::TimeDate");
261                        let _ = args.add(value);
262                    }
263                    #[cfg(feature = "with-time")]
264                    ArrayType::TimeTime => {
265                        let value: Option<Vec<time::Time>> = Value::Array(ty, v)
266                            .expect("This Value::Array should consist of Value::TimeTime");
267                        let _ = args.add(value);
268                    }
269                    #[cfg(feature = "with-time")]
270                    ArrayType::TimeDateTime => {
271                        let value: Option<Vec<time::PrimitiveDateTime>> = Value::Array(ty, v)
272                            .expect("This Value::Array should consist of Value::TimeDateTime");
273                        let _ = args.add(value);
274                    }
275                    #[cfg(feature = "with-time")]
276                    ArrayType::TimeDateTimeWithTimeZone => {
277                        let value: Option<Vec<time::OffsetDateTime>> = Value::Array(ty, v).expect(
278                            "This Value::Array should consist of Value::TimeDateTimeWithTimeZone",
279                        );
280                        let _ = args.add(value);
281                    }
282                    #[cfg(feature = "with-uuid")]
283                    ArrayType::Uuid => {
284                        let value: Option<Vec<Uuid>> = Value::Array(ty, v)
285                            .expect("This Value::Array should consist of Value::Uuid");
286                        let _ = args.add(value);
287                    }
288                    #[cfg(feature = "with-rust_decimal")]
289                    ArrayType::Decimal => {
290                        let value: Option<Vec<Decimal>> = Value::Array(ty, v)
291                            .expect("This Value::Array should consist of Value::Decimal");
292                        let _ = args.add(value);
293                    }
294                    #[cfg(feature = "with-bigdecimal")]
295                    ArrayType::BigDecimal => {
296                        let value: Option<Vec<BigDecimal>> = Value::Array(ty, v)
297                            .expect("This Value::Array should consist of Value::BigDecimal");
298                        let _ = args.add(value);
299                    }
300                    #[cfg(feature = "with-json")]
301                    ArrayType::Json => {
302                        let value: Option<Vec<Json>> = Value::Array(ty, v)
303                            .expect("This Value::Array should consist of Value::Json");
304                        let _ = args.add(value);
305                    }
306                    #[cfg(feature = "with-ipnetwork")]
307                    ArrayType::IpNetwork => {
308                        let value: Option<Vec<IpNetwork>> = Value::Array(ty, v)
309                            .expect("This Value::Array should consist of Value::IpNetwork");
310                        let _ = args.add(value);
311                    }
312                    #[cfg(feature = "with-mac_address")]
313                    ArrayType::MacAddress => {
314                        let value: Option<Vec<MacAddress>> = Value::Array(ty, v)
315                            .expect("This Value::Array should consist of Value::MacAddress");
316                        let _ = args.add(value);
317                    }
318                },
319                #[cfg(feature = "postgres-vector")]
320                Value::Vector(v) => {
321                    let _ = args.add(v);
322                } /* #[cfg(feature = "postgres-range")]
323                  Value::Range(v) => {
324                      let _ = args.add(v);
325                  } */
326            }
327        }
328        args
329    }
330}
sea_query_sqlx/sqlx_postgres.rs

sea_query_sqlx/
sqlx_postgres.rs
