Skip to main content

db_cores/common/
value.rs

1use crate::{APICategory, AccessBucket, DatabaseKind,  FileRouterScope, Logical, Operator, OwnerKind, PermtKind, RoleKind};
2
3#[derive(Debug, serde::Serialize, serde::Deserialize, PartialEq, Clone)]
4pub enum SqlValue {
5    Num(i64),
6    Float(f64),
7    Str(String),
8    UtcTime(::chrono::DateTime<::chrono::Utc>),
9    Time(::chrono::NaiveTime),
10    Date(::chrono::NaiveDate),
11    DateTime(::chrono::NaiveDateTime),
12    Bool(bool),
13    Buff(Vec<u8>),
14    Json(serde_json::Value),
15    Null,
16}
17
18pub trait IntoSqlValue {
19    fn into_sql_value(self) -> SqlValue;
20}
21
22
23pub struct SqlOf<T: IntoSqlValue>(pub T);
24
25impl<T: IntoSqlValue> From<SqlOf<T>> for SqlValue {
26    fn from(v: SqlOf<T>) -> Self {
27        v.0.into_sql_value()
28    }
29}
30
31
32pub enum ValueEnum {
33    Num,
34    Float,
35    Str,
36    UtcTime,
37    Time,
38    Date,
39    DateTime,
40    Bool,
41    Buff,
42    Json,
43    Null,
44}
45
46#[derive(Debug, serde::Serialize, serde::Deserialize, PartialEq, Clone)]
47pub enum WhereValue {
48    Value(SqlValue),
49    List(Vec<SqlValue>),
50}
51
52// 实现into
53impl<T> From<T> for WhereValue
54where
55    T: Into<SqlValue>,
56{
57    fn from(v: T) -> Self {
58        WhereValue::Value(v.into())
59    }
60}
61
62impl<T> From<Vec<T>> for WhereValue
63where
64    T: Into<SqlValue>,
65{
66    fn from(v: Vec<T>) -> Self {
67        WhereValue::List(v.into_iter().map(|item| item.into()).collect())
68    }
69}
70
71/// &[T] 泛型实现,支持 Clone
72impl<T> From<&[T]> for WhereValue
73where
74    T: Into<SqlValue> + Clone,
75{
76    fn from(v: &[T]) -> Self {
77        WhereValue::List(v.iter().cloned().map(|item| item.into()).collect())
78    }
79}
80
81impl From<DatabaseKind> for SqlValue {
82    fn from(v: DatabaseKind) -> Self {
83        SqlValue::Str(v.to_string())
84    }
85}
86impl From<&DatabaseKind> for SqlValue {
87    fn from(v: &DatabaseKind) -> Self {
88        SqlValue::Str(v.to_string())
89    }
90}
91
92impl From<RoleKind> for SqlValue {
93    fn from(v: RoleKind) -> Self {
94        SqlValue::Str(v.to_string().to_lowercase())
95    }
96}
97
98impl From<&RoleKind> for SqlValue {
99    fn from(v: &RoleKind) -> Self {
100        SqlValue::Str(v.to_string().to_lowercase())
101    }
102}
103
104impl From<AccessBucket> for SqlValue {
105    fn from(v: AccessBucket) -> Self {
106        SqlValue::Str(v.to_string().to_lowercase())
107    }
108}
109
110impl From<&AccessBucket> for SqlValue {
111    fn from(v: &AccessBucket) -> Self {
112        SqlValue::Str(v.to_string().to_lowercase())
113    }
114}
115
116impl From<&FileRouterScope> for SqlValue {
117    fn from(v: &FileRouterScope) -> Self {
118        SqlValue::Str(v.to_string().to_lowercase())
119    }
120}
121
122impl From<FileRouterScope> for SqlValue {
123    fn from(v: FileRouterScope) -> Self {
124        SqlValue::Str(v.to_string().to_lowercase())
125    }
126}
127
128
129#[cfg(any(feature = "postgres", feature = "mysql", feature = "sqlite"))]
130impl<T> From<::sqlx::types::Json<T>> for SqlValue
131where
132    T: serde::Serialize,
133{
134    fn from(v: ::sqlx::types::Json<T>) -> Self {
135        // 直接序列化内部结构为 serde_json::Value
136        let json_value = serde_json::to_value(v.0).unwrap_or(serde_json::Value::Null);
137        SqlValue::Json(json_value)
138    }
139}
140
141impl From<PermtKind> for SqlValue {
142    fn from(v: PermtKind) -> Self {
143        SqlValue::Str(v.to_string().to_lowercase())
144    }
145}
146
147impl From<&PermtKind> for SqlValue {
148    fn from(v: &PermtKind) -> Self {
149        SqlValue::Str(v.to_string().to_lowercase())
150    }
151}
152
153impl From<OwnerKind> for SqlValue {
154    fn from(v: OwnerKind) -> Self {
155        SqlValue::Str(v.to_string().to_lowercase())
156    }
157}
158
159impl From<&OwnerKind> for SqlValue {
160    fn from(v: &OwnerKind) -> Self {
161        SqlValue::Str(v.to_string().to_lowercase())
162    }
163}
164
165impl From<APICategory> for SqlValue {
166    fn from(v: APICategory) -> Self {
167        SqlValue::Str(v.to_string().to_lowercase())
168    }
169}
170
171impl From<&APICategory> for SqlValue {
172    fn from(v: &APICategory) -> Self {
173        SqlValue::Str(v.to_string().to_lowercase())
174    }
175}
176
177#[test]
178fn dev() {
179    let res = APICategory::Auth.to_string();
180    println!("{res}");
181}
182
183impl From<::chrono::DateTime<::chrono::Utc>> for SqlValue {
184    fn from(v: ::chrono::DateTime<::chrono::Utc>) -> Self {
185        SqlValue::UtcTime(v)
186    }
187}
188impl From<&::chrono::DateTime<::chrono::Utc>> for SqlValue {
189    fn from(v: &::chrono::DateTime<::chrono::Utc>) -> Self {
190        SqlValue::UtcTime(v.to_owned())
191    }
192}
193
194impl From<::chrono::NaiveTime> for SqlValue {
195    fn from(v: ::chrono::NaiveTime) -> Self {
196        SqlValue::Time(v)
197    }
198}
199impl From<&::chrono::NaiveTime> for SqlValue {
200    fn from(v: &::chrono::NaiveTime) -> Self {
201        SqlValue::Time(v.to_owned())
202    }
203}
204
205
206impl From<::chrono::NaiveDate> for SqlValue {
207    fn from(v: ::chrono::NaiveDate) -> Self {
208        SqlValue::Date(v)
209    }
210}
211
212impl From<&::chrono::NaiveDate> for SqlValue {
213    fn from(v: &::chrono::NaiveDate) -> Self {
214        SqlValue::Date(v.to_owned())
215    }
216}
217
218impl From<::chrono::NaiveDateTime> for SqlValue {
219    fn from(v: ::chrono::NaiveDateTime) -> Self {
220        SqlValue::DateTime(v)
221    }
222}
223
224impl From<&::chrono::NaiveDateTime> for SqlValue {
225    fn from(v: &::chrono::NaiveDateTime) -> Self {
226        SqlValue::DateTime(v.to_owned())
227    }
228}
229impl From<serde_json::Value> for SqlValue {
230    fn from(v: serde_json::Value) -> Self {
231        SqlValue::Json(v)
232    }
233}
234impl From<&serde_json::Value> for SqlValue {
235    fn from(v: &serde_json::Value) -> Self {
236        SqlValue::Json(v.clone())
237    }
238}
239
240impl From<i32> for SqlValue {
241    fn from(v: i32) -> Self {
242        SqlValue::Num(v as i64)
243    }
244}
245impl From<&i32> for SqlValue {
246    fn from(v: &i32) -> Self {
247        SqlValue::Num(*v as i64)
248    }
249}
250
251impl From<i64> for SqlValue {
252    fn from(v: i64) -> Self {
253        SqlValue::Num(v)
254    }
255}
256impl From<&i64> for SqlValue {
257    fn from(v: &i64) -> Self {
258        SqlValue::Num(*v as i64)
259    }
260}
261impl From<u64> for SqlValue {
262    fn from(v: u64) -> Self {
263        SqlValue::Num(v as i64)
264    }
265}
266
267impl From<&u64> for SqlValue {
268    fn from(v: &u64) -> Self {
269        SqlValue::Num(*v as i64)
270    }
271}
272impl From<f64> for SqlValue {
273    fn from(v: f64) -> Self {
274        SqlValue::Float(v)
275    }
276}
277impl From<&f64> for SqlValue {
278    fn from(v: &f64) -> Self {
279        SqlValue::Float(*v)
280    }
281}
282
283impl From<bool> for SqlValue {
284    fn from(v: bool) -> Self {
285        SqlValue::Bool(v)
286    }
287}
288impl From<&bool> for SqlValue {
289    fn from(v: &bool) -> Self {
290        SqlValue::Bool(*v)
291    }
292}
293
294impl From<&str> for SqlValue {
295    fn from(v: &str) -> Self {
296        SqlValue::Str(v.to_string())
297    }
298}
299
300impl From<String> for SqlValue {
301    fn from(v: String) -> Self {
302        SqlValue::Str(v)
303    }
304}
305impl From<&String> for SqlValue {
306    fn from(v: &String) -> Self {
307        SqlValue::Str(v.to_string())
308    }
309}
310impl From<Vec<u8>> for SqlValue {
311    fn from(v: Vec<u8>) -> Self {
312        SqlValue::Buff(v)
313    }
314}
315
316impl From<&[u8]> for SqlValue {
317    fn from(v: &[u8]) -> Self {
318        SqlValue::Buff(v.to_vec())
319    }
320}
321
322impl<T: Into<SqlValue> + Clone> From<&Option<T>> for SqlValue {
323    fn from(opt: &Option<T>) -> Self {
324        match opt {
325            | Some(v) => v.clone().into(),
326            | None => SqlValue::Null,
327        }
328    }
329}
330
331
332impl<T> From<Option<T>> for SqlValue 
333where 
334    SqlValue: From<T>,  // 更清晰:SqlValue 能从 T 构造
335{
336    fn from(opt: Option<T>) -> Self {
337        match opt {
338            Some(v) => Self::from(v),  // 或 v.into()
339            None => SqlValue::Null,
340        }
341    }
342}
343
344
345#[derive(Debug, serde::Serialize,  PartialEq, Clone,serde::Deserialize)]
346pub struct BuildConditionItem {
347    pub column: String,
348    pub values: WhereValue,
349    pub operator: Operator,
350    pub logical: Logical,
351}
352
353
354fn _from_str(v: &str) -> SqlValue {
355    // 尝试解析带时区的 UTC/ISO 8601 时间
356    if let Ok(dt) = ::chrono::DateTime::parse_from_rfc3339(v) {
357        return SqlValue::UtcTime(dt.with_timezone(&::chrono::Utc));
358    }
359    // 尝试解析本地日期时间
360    if let Ok(dt) = ::chrono::NaiveDateTime::parse_from_str(v, "%Y-%m-%d %H:%M:%S") {
361        return SqlValue::DateTime(dt);
362    }
363    // 尝试解析日期
364    if let Ok(d) = ::chrono::NaiveDate::parse_from_str(v, "%Y-%m-%d") {
365        return SqlValue::Date(d);
366    }
367    // 尝试解析时间
368    if let Ok(t) = ::chrono::NaiveTime::parse_from_str(v, "%H:%M:%S") {
369        return SqlValue::Time(t);
370    }
371    // 默认当作普通字符串
372    SqlValue::Str(v.to_string())
373}