Skip to main content

yang_base/table/
field_type.rs

1//! 字段类型定义
2//!
3//! 提供数据表字段的类型系统,支持基本类型、时间类型、复杂类型和关联类型。
4
5use crate::error::BaseError;
6use serde::{Deserialize, Serialize};
7
8/// 获取 JSON 值的类型名称
9///
10/// # 参数
11///
12/// - `value`: JSON 值
13///
14/// # 返回值
15///
16/// 返回类型名称的字符串
17fn value_type_name(value: &serde_json::Value) -> &'static str {
18    match value {
19        serde_json::Value::Null => "null",
20        serde_json::Value::Bool(_) => "boolean",
21        serde_json::Value::Number(_) => "number",
22        serde_json::Value::String(_) => "string",
23        serde_json::Value::Array(_) => "array",
24        serde_json::Value::Object(_) => "object",
25    }
26}
27
28/// 字段类型
29///
30/// 定义数据表字段支持的所有类型,包括:
31/// - 基本类型:String, Integer, BigInt, Float, Double, Boolean
32/// - 时间类型:Date, DateTime, Timestamp
33/// - 复杂类型:Json, Text
34/// - 枚举类型:Enum
35/// - 外键类型:ForeignKey
36///
37/// # 示例
38///
39/// ```rust
40/// use yang_base::table::FieldType;
41///
42/// // 创建字符串类型,最大长度 50
43/// let name_type = FieldType::String { max_length: 50 };
44///
45/// // 创建整数类型
46/// let age_type = FieldType::Integer;
47///
48/// // 创建枚举类型
49/// let status_type = FieldType::Enum {
50///     values: vec!["active".to_string(), "inactive".to_string()],
51/// };
52///
53/// // 创建外键类型
54/// let user_id_type = FieldType::ForeignKey {
55///     table: "users".to_string(),
56///     field: "id".to_string(),
57/// };
58/// ```
59#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
60#[non_exhaustive]
61pub enum FieldType {
62    /// 字符串类型
63    ///
64    /// 用于存储文本数据,需要指定最大长度。
65    ///
66    /// # 字段
67    ///
68    /// - `max_length`: 字符串的最大长度(字符数)
69    ///
70    /// # 示例
71    ///
72    /// ```rust
73    /// use yang_base::table::FieldType;
74    ///
75    /// let field_type = FieldType::String { max_length: 100 };
76    /// ```
77    String {
78        /// 最大长度(字符数)
79        max_length: usize,
80    },
81
82    /// 整数类型
83    ///
84    /// 用于存储 32 位有符号整数(i32)。
85    ///
86    /// # 示例
87    ///
88    /// ```rust
89    /// use yang_base::table::FieldType;
90    ///
91    /// let field_type = FieldType::Integer;
92    /// ```
93    Integer,
94
95    /// 长整数类型
96    ///
97    /// 用于存储 64 位有符号整数(i64)。
98    ///
99    /// # 示例
100    ///
101    /// ```rust
102    /// use yang_base::table::FieldType;
103    ///
104    /// let field_type = FieldType::BigInt;
105    /// ```
106    BigInt,
107
108    /// 单精度浮点数类型
109    ///
110    /// 用于存储 32 位浮点数(f32)。
111    ///
112    /// # 示例
113    ///
114    /// ```rust
115    /// use yang_base::table::FieldType;
116    ///
117    /// let field_type = FieldType::Float;
118    /// ```
119    Float,
120
121    /// 双精度浮点数类型
122    ///
123    /// 用于存储 64 位浮点数(f64)。
124    ///
125    /// # 示例
126    ///
127    /// ```rust
128    /// use yang_base::table::FieldType;
129    ///
130    /// let field_type = FieldType::Double;
131    /// ```
132    Double,
133
134    /// 布尔类型
135    ///
136    /// 用于存储布尔值(true/false)。
137    ///
138    /// # 示例
139    ///
140    /// ```rust
141    /// use yang_base::table::FieldType;
142    ///
143    /// let field_type = FieldType::Boolean;
144    /// ```
145    Boolean,
146
147    /// 日期类型
148    ///
149    /// 用于存储日期(年-月-日),不包含时间信息。
150    ///
151    /// # 示例
152    ///
153    /// ```rust
154    /// use yang_base::table::FieldType;
155    ///
156    /// let field_type = FieldType::Date;
157    /// ```
158    Date,
159
160    /// 日期时间类型
161    ///
162    /// 用于存储日期和时间(年-月-日 时:分:秒)。
163    ///
164    /// # 示例
165    ///
166    /// ```rust
167    /// use yang_base::table::FieldType;
168    ///
169    /// let field_type = FieldType::DateTime;
170    /// ```
171    DateTime,
172
173    /// 时间戳类型
174    ///
175    /// 用于存储 Unix 时间戳(秒数)。
176    ///
177    /// # 示例
178    ///
179    /// ```rust
180    /// use yang_base::table::FieldType;
181    ///
182    /// let field_type = FieldType::Timestamp;
183    /// ```
184    Timestamp,
185
186    /// JSON 类型
187    ///
188    /// 用于存储 JSON 格式的复杂数据结构。
189    ///
190    /// # 示例
191    ///
192    /// ```rust
193    /// use yang_base::table::FieldType;
194    ///
195    /// let field_type = FieldType::Json;
196    /// ```
197    Json,
198
199    /// 文本类型
200    ///
201    /// 用于存储大文本数据,没有长度限制。
202    ///
203    /// # 示例
204    ///
205    /// ```rust
206    /// use yang_base::table::FieldType;
207    ///
208    /// let field_type = FieldType::Text;
209    /// ```
210    Text,
211
212    /// 枚举类型
213    ///
214    /// 用于存储预定义的可选值列表中的一个值。
215    ///
216    /// # 字段
217    ///
218    /// - `values`: 可选值列表
219    ///
220    /// # 示例
221    ///
222    /// ```rust
223    /// use yang_base::table::FieldType;
224    ///
225    /// let field_type = FieldType::Enum {
226    ///     values: vec![
227    ///         "pending".to_string(),
228    ///         "approved".to_string(),
229    ///         "rejected".to_string(),
230    ///     ],
231    /// };
232    /// ```
233    Enum {
234        /// 可选值列表
235        values: Vec<String>,
236    },
237
238    /// 外键类型
239    ///
240    /// 用于关联其他表的字段,建立表之间的关系。
241    ///
242    /// # 字段
243    ///
244    /// - `table`: 关联的目标表名
245    /// - `field`: 关联的目标字段名
246    ///
247    /// # 示例
248    ///
249    /// ```rust
250    /// use yang_base::table::FieldType;
251    ///
252    /// let field_type = FieldType::ForeignKey {
253    ///     table: "users".to_string(),
254    ///     field: "id".to_string(),
255    /// };
256    /// ```
257    ForeignKey {
258        /// 关联的目标表名
259        table: String,
260        /// 关联的目标字段名
261        field: String,
262    },
263}
264
265impl FieldType {
266    /// 获取字段类型的显示名称
267    ///
268    /// # 返回值
269    ///
270    /// 返回字段类型的中文显示名称
271    ///
272    /// # 示例
273    ///
274    /// ```rust
275    /// use yang_base::table::FieldType;
276    ///
277    /// let field_type = FieldType::String { max_length: 50 };
278    /// assert_eq!(field_type.display_name(), "字符串");
279    ///
280    /// let field_type = FieldType::Integer;
281    /// assert_eq!(field_type.display_name(), "整数");
282    /// ```
283    pub fn display_name(&self) -> &str {
284        match self {
285            FieldType::String { .. } => "字符串",
286            FieldType::Integer => "整数",
287            FieldType::BigInt => "长整数",
288            FieldType::Float => "单精度浮点数",
289            FieldType::Double => "双精度浮点数",
290            FieldType::Boolean => "布尔值",
291            FieldType::Date => "日期",
292            FieldType::DateTime => "日期时间",
293            FieldType::Timestamp => "时间戳",
294            FieldType::Json => "JSON",
295            FieldType::Text => "文本",
296            FieldType::Enum { .. } => "枚举",
297            FieldType::ForeignKey { .. } => "外键",
298        }
299    }
300
301    /// 检查字段类型是否为数值类型
302    ///
303    /// # 返回值
304    ///
305    /// 如果是数值类型(Integer, BigInt, Float, Double)返回 true,否则返回 false
306    ///
307    /// # 示例
308    ///
309    /// ```rust
310    /// use yang_base::table::FieldType;
311    ///
312    /// assert!(FieldType::Integer.is_numeric());
313    /// assert!(FieldType::Float.is_numeric());
314    /// assert!(!FieldType::String { max_length: 50 }.is_numeric());
315    /// ```
316    pub fn is_numeric(&self) -> bool {
317        matches!(
318            self,
319            FieldType::Integer | FieldType::BigInt | FieldType::Float | FieldType::Double
320        )
321    }
322
323    /// 检查字段类型是否为时间类型
324    ///
325    /// # 返回值
326    ///
327    /// 如果是时间类型(Date, DateTime, Timestamp)返回 true,否则返回 false
328    ///
329    /// # 示例
330    ///
331    /// ```rust
332    /// use yang_base::table::FieldType;
333    ///
334    /// assert!(FieldType::Date.is_temporal());
335    /// assert!(FieldType::DateTime.is_temporal());
336    /// assert!(!FieldType::String { max_length: 50 }.is_temporal());
337    /// ```
338    pub fn is_temporal(&self) -> bool {
339        matches!(
340            self,
341            FieldType::Date | FieldType::DateTime | FieldType::Timestamp
342        )
343    }
344
345    /// 检查字段类型是否为文本类型
346    ///
347    /// # 返回值
348    ///
349    /// 如果是文本类型(String, Text)返回 true,否则返回 false
350    ///
351    /// # 示例
352    ///
353    /// ```rust
354    /// use yang_base::table::FieldType;
355    ///
356    /// assert!(FieldType::String { max_length: 50 }.is_text());
357    /// assert!(FieldType::Text.is_text());
358    /// assert!(!FieldType::Integer.is_text());
359    /// ```
360    pub fn is_text(&self) -> bool {
361        matches!(self, FieldType::String { .. } | FieldType::Text)
362    }
363
364    /// 验证字段值是否符合字段类型要求
365    ///
366    /// # 参数
367    ///
368    /// - `field_name`: 字段名称(用于错误消息)
369    /// - `value`: 要验证的值
370    ///
371    /// # 返回值
372    ///
373    /// 如果验证通过返回 Ok(()),否则返回相应的错误
374    ///
375    /// # 示例
376    ///
377    /// ```rust
378    /// use yang_base::table::FieldType;
379    /// use serde_json::json;
380    ///
381    /// let field_type = FieldType::String { max_length: 10 };
382    /// assert!(field_type.validate("name", &json!("hello")).is_ok());
383    /// assert!(field_type.validate("name", &json!("this is too long")).is_err());
384    ///
385    /// let field_type = FieldType::Integer;
386    /// assert!(field_type.validate("age", &json!(25)).is_ok());
387    /// assert!(field_type.validate("age", &json!("not a number")).is_err());
388    /// ```
389    pub fn validate(&self, field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
390        match self {
391            // 字符串类型验证
392            FieldType::String { max_length } => {
393                if let Some(s) = value.as_str() {
394                    let len = s.chars().count();
395                    if len > *max_length {
396                        return Err(BaseError::StringTooLong(
397                            field_name.to_string(),
398                            len,
399                            *max_length,
400                        ));
401                    }
402                    Ok(())
403                } else {
404                    Err(BaseError::InvalidFieldType(
405                        field_name.to_string(),
406                        format!("期望字符串类型,实际类型: {}", value_type_name(value)),
407                    ))
408                }
409            }
410
411            // 整数类型验证
412            FieldType::Integer => {
413                if value.is_i64() || value.is_u64() {
414                    // 检查是否在 i32 范围内
415                    if let Some(n) = value.as_i64() {
416                        if n >= i32::MIN as i64 && n <= i32::MAX as i64 {
417                            return Ok(());
418                        }
419                    }
420                    Err(BaseError::InvalidFieldType(
421                        field_name.to_string(),
422                        "整数值超出 i32 范围".to_string(),
423                    ))
424                } else {
425                    Err(BaseError::InvalidFieldType(
426                        field_name.to_string(),
427                        format!("期望整数类型,实际类型: {}", value_type_name(value)),
428                    ))
429                }
430            }
431
432            // 长整数类型验证
433            FieldType::BigInt => {
434                if value.is_i64() || value.is_u64() {
435                    Ok(())
436                } else {
437                    Err(BaseError::InvalidFieldType(
438                        field_name.to_string(),
439                        format!("期望长整数类型,实际类型: {}", value_type_name(value)),
440                    ))
441                }
442            }
443
444            // 单精度浮点数类型验证
445            FieldType::Float => {
446                if value.is_f64() || value.is_i64() || value.is_u64() {
447                    // 检查是否在 f32 范围内
448                    if let Some(n) = value.as_f64() {
449                        if n.is_finite() && n.abs() <= f32::MAX as f64 {
450                            return Ok(());
451                        }
452                    }
453                    Err(BaseError::InvalidFieldType(
454                        field_name.to_string(),
455                        "浮点数值超出 f32 范围".to_string(),
456                    ))
457                } else {
458                    Err(BaseError::InvalidFieldType(
459                        field_name.to_string(),
460                        format!("期望浮点数类型,实际类型: {}", value_type_name(value)),
461                    ))
462                }
463            }
464
465            // 双精度浮点数类型验证
466            FieldType::Double => {
467                if value.is_f64() || value.is_i64() || value.is_u64() {
468                    Ok(())
469                } else {
470                    Err(BaseError::InvalidFieldType(
471                        field_name.to_string(),
472                        format!("期望双精度浮点数类型,实际类型: {}", value_type_name(value)),
473                    ))
474                }
475            }
476
477            // 布尔类型验证
478            FieldType::Boolean => {
479                if value.is_boolean() {
480                    Ok(())
481                } else {
482                    Err(BaseError::InvalidFieldType(
483                        field_name.to_string(),
484                        format!("期望布尔类型,实际类型: {}", value_type_name(value)),
485                    ))
486                }
487            }
488
489            // 日期类型验证
490            FieldType::Date => validate_date(field_name, value),
491
492            // 日期时间类型验证
493            FieldType::DateTime => validate_datetime(field_name, value),
494
495            // 时间戳类型验证
496            FieldType::Timestamp => validate_timestamp(field_name, value),
497
498            // 枚举类型验证
499            FieldType::Enum { values } => {
500                if let Some(s) = value.as_str() {
501                    if values.contains(&s.to_string()) {
502                        Ok(())
503                    } else {
504                        Err(BaseError::InvalidEnumValue(
505                            field_name.to_string(),
506                            s.to_string(),
507                        ))
508                    }
509                } else {
510                    Err(BaseError::InvalidFieldType(
511                        field_name.to_string(),
512                        format!(
513                            "期望字符串类型的枚举值,实际类型: {}",
514                            value_type_name(value)
515                        ),
516                    ))
517                }
518            }
519
520            // JSON 类型验证
521            FieldType::Json => {
522                // 如果值是字符串,尝试解析为 JSON
523                if let Some(s) = value.as_str() {
524                    serde_json::from_str::<serde_json::Value>(s)
525                        .map(|_| ())
526                        .map_err(|e| {
527                            BaseError::InvalidJsonFormat(field_name.to_string(), e.to_string())
528                        })
529                } else {
530                    // 如果值本身就是 JSON 对象或数组,直接通过
531                    if value.is_object() || value.is_array() {
532                        Ok(())
533                    } else {
534                        Err(BaseError::InvalidFieldType(
535                            field_name.to_string(),
536                            format!("期望 JSON 对象或数组,实际类型: {}", value_type_name(value)),
537                        ))
538                    }
539                }
540            }
541
542            // 文本类型验证:与 String 对等地要求字符串,但不施加长度上限
543            FieldType::Text => {
544                if value.as_str().is_some() {
545                    Ok(())
546                } else {
547                    Err(BaseError::InvalidFieldType(
548                        field_name.to_string(),
549                        format!("期望文本字符串类型,实际类型: {}", value_type_name(value)),
550                    ))
551                }
552            }
553
554            // 外键类型验证:FK 值类型由目标表约束决定,此处不强校验
555            FieldType::ForeignKey { .. } => Ok(()),
556        }
557    }
558}
559
560fn validate_date(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
561    if let Some(s) = value.as_str() {
562        chrono::NaiveDate::parse_from_str(s, "%Y-%m-%d")
563            .map(|_| ())
564            .map_err(|_| {
565                BaseError::InvalidFieldType(
566                    field_name.to_string(),
567                    format!("日期格式无效,期望 YYYY-MM-DD,实际: {}", s),
568                )
569            })
570    } else {
571        Err(BaseError::InvalidFieldType(
572            field_name.to_string(),
573            format!("期望日期字符串类型,实际类型: {}", value_type_name(value)),
574        ))
575    }
576}
577
578fn validate_datetime(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
579    if let Some(s) = value.as_str() {
580        // 先尝试 ISO 8601 形式("%Y-%m-%dT%H:%M:%S",与 DynamicRow 的 DATETIME 输出一致),
581        // 再退回到空格分隔形式("%Y-%m-%d %H:%M:%S",MySQL 文本形式)。
582        if chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%dT%H:%M:%S").is_ok()
583            || chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S").is_ok()
584        {
585            Ok(())
586        } else {
587            Err(BaseError::InvalidFieldType(
588                field_name.to_string(),
589                format!(
590                    "日期时间格式无效,期望 YYYY-MM-DDTHH:MM:SS 或 YYYY-MM-DD HH:MM:SS,实际: {}",
591                    s
592                ),
593            ))
594        }
595    } else {
596        Err(BaseError::InvalidFieldType(
597            field_name.to_string(),
598            format!(
599                "期望日期时间字符串类型,实际类型: {}",
600                value_type_name(value)
601            ),
602        ))
603    }
604}
605
606fn validate_timestamp(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
607    if let Some(ts) = value.as_i64() {
608        chrono::DateTime::<chrono::Utc>::from_timestamp_secs(ts)
609            .map(|_| ())
610            .ok_or_else(|| {
611                BaseError::InvalidFieldType(
612                    field_name.to_string(),
613                    format!("时间戳超出有效范围,实际: {}", ts),
614                )
615            })
616    } else {
617        Err(BaseError::InvalidFieldType(
618            field_name.to_string(),
619            format!("期望 Unix 时间戳整数,实际类型: {}", value_type_name(value)),
620        ))
621    }
622}
623
624#[cfg(test)]
625mod tests {
626    use super::*;
627
628    #[test]
629    fn test_field_type_display_name() {
630        assert_eq!(
631            FieldType::String { max_length: 50 }.display_name(),
632            "字符串"
633        );
634        assert_eq!(FieldType::Integer.display_name(), "整数");
635        assert_eq!(FieldType::BigInt.display_name(), "长整数");
636        assert_eq!(FieldType::Float.display_name(), "单精度浮点数");
637        assert_eq!(FieldType::Double.display_name(), "双精度浮点数");
638        assert_eq!(FieldType::Boolean.display_name(), "布尔值");
639        assert_eq!(FieldType::Date.display_name(), "日期");
640        assert_eq!(FieldType::DateTime.display_name(), "日期时间");
641        assert_eq!(FieldType::Timestamp.display_name(), "时间戳");
642        assert_eq!(FieldType::Json.display_name(), "JSON");
643        assert_eq!(FieldType::Text.display_name(), "文本");
644        assert_eq!(
645            FieldType::Enum {
646                values: vec!["a".to_string()]
647            }
648            .display_name(),
649            "枚举"
650        );
651        assert_eq!(
652            FieldType::ForeignKey {
653                table: "users".to_string(),
654                field: "id".to_string()
655            }
656            .display_name(),
657            "外键"
658        );
659    }
660
661    #[test]
662    fn test_is_numeric() {
663        assert!(FieldType::Integer.is_numeric());
664        assert!(FieldType::BigInt.is_numeric());
665        assert!(FieldType::Float.is_numeric());
666        assert!(FieldType::Double.is_numeric());
667        assert!(!FieldType::String { max_length: 50 }.is_numeric());
668        assert!(!FieldType::Boolean.is_numeric());
669    }
670
671    #[test]
672    fn test_is_temporal() {
673        assert!(FieldType::Date.is_temporal());
674        assert!(FieldType::DateTime.is_temporal());
675        assert!(FieldType::Timestamp.is_temporal());
676        assert!(!FieldType::String { max_length: 50 }.is_temporal());
677        assert!(!FieldType::Integer.is_temporal());
678    }
679
680    #[test]
681    fn test_is_text() {
682        assert!(FieldType::String { max_length: 50 }.is_text());
683        assert!(FieldType::Text.is_text());
684        assert!(!FieldType::Integer.is_text());
685        assert!(!FieldType::Boolean.is_text());
686    }
687
688    #[test]
689    fn test_field_type_equality() {
690        let type1 = FieldType::String { max_length: 50 };
691        let type2 = FieldType::String { max_length: 50 };
692        let type3 = FieldType::String { max_length: 100 };
693
694        assert_eq!(type1, type2);
695        assert_ne!(type1, type3);
696    }
697
698    #[test]
699    fn test_enum_type() {
700        let enum_type = FieldType::Enum {
701            values: vec![
702                "pending".to_string(),
703                "approved".to_string(),
704                "rejected".to_string(),
705            ],
706        };
707
708        assert_eq!(enum_type.display_name(), "枚举");
709        assert!(!enum_type.is_numeric());
710        assert!(!enum_type.is_temporal());
711        assert!(!enum_type.is_text());
712    }
713
714    #[test]
715    fn test_foreign_key_type() {
716        let fk_type = FieldType::ForeignKey {
717            table: "users".to_string(),
718            field: "id".to_string(),
719        };
720
721        assert_eq!(fk_type.display_name(), "外键");
722        assert!(!fk_type.is_numeric());
723        assert!(!fk_type.is_temporal());
724        assert!(!fk_type.is_text());
725    }
726
727    // ==================== validate 方法测试 ====================
728
729    #[test]
730    fn test_validate_string_success() {
731        let field_type = FieldType::String { max_length: 10 };
732
733        // 正常情况
734        assert!(field_type
735            .validate("name", &serde_json::json!("hello"))
736            .is_ok());
737        assert!(field_type.validate("name", &serde_json::json!("")).is_ok());
738
739        // 边界情况:正好 10 个字符
740        assert!(field_type
741            .validate("name", &serde_json::json!("1234567890"))
742            .is_ok());
743    }
744
745    #[test]
746    fn test_validate_string_too_long() {
747        let field_type = FieldType::String { max_length: 10 };
748
749        // 超过最大长度
750        let result = field_type.validate("name", &serde_json::json!("this is too long"));
751        assert!(result.is_err());
752
753        assert!(
754            matches!(result, Err(BaseError::StringTooLong(ref field, 16, 10)) if field == "name"),
755            "期望 StringTooLong 错误,实际: {:?}",
756            result
757        );
758    }
759
760    #[test]
761    fn test_validate_string_invalid_type() {
762        let field_type = FieldType::String { max_length: 10 };
763
764        // 类型不匹配
765        assert!(field_type
766            .validate("name", &serde_json::json!(123))
767            .is_err());
768        assert!(field_type
769            .validate("name", &serde_json::json!(true))
770            .is_err());
771        assert!(field_type
772            .validate("name", &serde_json::json!(null))
773            .is_err());
774    }
775
776    #[test]
777    fn test_validate_integer_success() {
778        let field_type = FieldType::Integer;
779
780        // 正常情况
781        assert!(field_type.validate("age", &serde_json::json!(25)).is_ok());
782        assert!(field_type.validate("age", &serde_json::json!(0)).is_ok());
783        assert!(field_type.validate("age", &serde_json::json!(-100)).is_ok());
784
785        // 边界情况:i32 范围
786        assert!(field_type
787            .validate("age", &serde_json::json!(i32::MAX))
788            .is_ok());
789        assert!(field_type
790            .validate("age", &serde_json::json!(i32::MIN))
791            .is_ok());
792    }
793
794    #[test]
795    fn test_validate_integer_out_of_range() {
796        let field_type = FieldType::Integer;
797
798        // 超出 i32 范围
799        let result = field_type.validate("age", &serde_json::json!(i64::MAX));
800        assert!(result.is_err());
801    }
802
803    #[test]
804    fn test_validate_integer_invalid_type() {
805        let field_type = FieldType::Integer;
806
807        // 类型不匹配
808        assert!(field_type
809            .validate("age", &serde_json::json!("not a number"))
810            .is_err());
811        assert!(field_type
812            .validate("age", &serde_json::json!(true))
813            .is_err());
814        assert!(field_type.validate("age", &serde_json::json!(3.5)).is_err());
815    }
816
817    #[test]
818    fn test_validate_bigint_success() {
819        let field_type = FieldType::BigInt;
820
821        // 正常情况
822        assert!(field_type
823            .validate("id", &serde_json::json!(123456789))
824            .is_ok());
825        assert!(field_type
826            .validate("id", &serde_json::json!(i64::MAX))
827            .is_ok());
828        assert!(field_type
829            .validate("id", &serde_json::json!(i64::MIN))
830            .is_ok());
831    }
832
833    #[test]
834    fn test_validate_bigint_invalid_type() {
835        let field_type = FieldType::BigInt;
836
837        // 类型不匹配
838        assert!(field_type
839            .validate("id", &serde_json::json!("not a number"))
840            .is_err());
841        assert!(field_type.validate("id", &serde_json::json!(3.5)).is_err());
842    }
843
844    #[test]
845    fn test_validate_float_success() {
846        let field_type = FieldType::Float;
847
848        // 正常情况
849        assert!(field_type
850            .validate("price", &serde_json::json!(3.5))
851            .is_ok());
852        assert!(field_type
853            .validate("price", &serde_json::json!(0.0))
854            .is_ok());
855        assert!(field_type
856            .validate("price", &serde_json::json!(-1.5))
857            .is_ok());
858
859        // 整数也可以转换为浮点数
860        assert!(field_type
861            .validate("price", &serde_json::json!(100))
862            .is_ok());
863    }
864
865    #[test]
866    fn test_validate_float_invalid_type() {
867        let field_type = FieldType::Float;
868
869        // 类型不匹配
870        assert!(field_type
871            .validate("price", &serde_json::json!("not a number"))
872            .is_err());
873        assert!(field_type
874            .validate("price", &serde_json::json!(true))
875            .is_err());
876    }
877
878    #[test]
879    fn test_validate_double_success() {
880        let field_type = FieldType::Double;
881
882        // 正常情况
883        assert!(field_type
884            .validate("amount", &serde_json::json!(123.456))
885            .is_ok());
886        assert!(field_type
887            .validate("amount", &serde_json::json!(0.0))
888            .is_ok());
889        assert!(field_type
890            .validate("amount", &serde_json::json!(100))
891            .is_ok());
892    }
893
894    #[test]
895    fn test_validate_double_invalid_type() {
896        let field_type = FieldType::Double;
897
898        // 类型不匹配
899        assert!(field_type
900            .validate("amount", &serde_json::json!("not a number"))
901            .is_err());
902        assert!(field_type
903            .validate("amount", &serde_json::json!(true))
904            .is_err());
905    }
906
907    #[test]
908    fn test_validate_boolean_success() {
909        let field_type = FieldType::Boolean;
910
911        // 正常情况
912        assert!(field_type
913            .validate("active", &serde_json::json!(true))
914            .is_ok());
915        assert!(field_type
916            .validate("active", &serde_json::json!(false))
917            .is_ok());
918    }
919
920    #[test]
921    fn test_validate_boolean_invalid_type() {
922        let field_type = FieldType::Boolean;
923
924        // 类型不匹配
925        assert!(field_type
926            .validate("active", &serde_json::json!("true"))
927            .is_err());
928        assert!(field_type
929            .validate("active", &serde_json::json!(1))
930            .is_err());
931        assert!(field_type
932            .validate("active", &serde_json::json!(0))
933            .is_err());
934    }
935
936    #[test]
937    fn test_validate_date_success() {
938        let field_type = FieldType::Date;
939
940        assert!(field_type
941            .validate("birthday", &serde_json::json!("2026-05-27"))
942            .is_ok());
943    }
944
945    #[test]
946    fn test_validate_date_invalid_format() {
947        let field_type = FieldType::Date;
948
949        let result = field_type.validate("birthday", &serde_json::json!("2026/05/27"));
950        assert!(result.is_err());
951        assert!(
952            matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
953        );
954    }
955
956    #[test]
957    fn test_validate_date_invalid_type() {
958        let field_type = FieldType::Date;
959
960        let result = field_type.validate("birthday", &serde_json::json!(20260527));
961        assert!(result.is_err());
962        assert!(
963            matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
964        );
965    }
966
967    #[test]
968    fn test_validate_datetime_success() {
969        let field_type = FieldType::DateTime;
970
971        assert!(field_type
972            .validate("created_at", &serde_json::json!("2026-05-27 13:45:30"))
973            .is_ok());
974    }
975
976    #[test]
977    fn test_validate_datetime_invalid_format() {
978        let field_type = FieldType::DateTime;
979
980        // T 分隔的 ISO 8601 形式现在被视为【有效】(与 DynamicRow 的 DATETIME 输出一致)
981        assert!(field_type
982            .validate("created_at", &serde_json::json!("2026-05-27T13:45:30"))
983            .is_ok());
984
985        // 真正非法的格式(斜杠分隔)仍然返回错误
986        let result = field_type.validate("created_at", &serde_json::json!("2026/05/27 13:45:30"));
987        assert!(result.is_err());
988        assert!(
989            matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
990        );
991    }
992
993    #[test]
994    fn test_validate_datetime_roundtrip_from_dynamic_row() {
995        // 回归:DynamicRow 读出的 DATETIME 值为 "%Y-%m-%dT%H:%M:%S" 形式,
996        // 应能原样回写并通过 DateTime 字段校验。
997        let field_type = FieldType::DateTime;
998        let read_back = serde_json::json!("2026-05-27T13:45:30");
999        assert!(field_type.validate("created_at", &read_back).is_ok());
1000    }
1001
1002    #[test]
1003    fn test_validate_timestamp_success() {
1004        let field_type = FieldType::Timestamp;
1005
1006        assert!(field_type
1007            .validate("created_at", &serde_json::json!(1_764_221_130_i64))
1008            .is_ok());
1009    }
1010
1011    #[test]
1012    fn test_validate_timestamp_invalid_type() {
1013        let field_type = FieldType::Timestamp;
1014
1015        let result = field_type.validate("created_at", &serde_json::json!("2026-05-27 13:45:30"));
1016        assert!(result.is_err());
1017        assert!(
1018            matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
1019        );
1020    }
1021
1022    #[test]
1023    fn test_validate_text_success() {
1024        let field_type = FieldType::Text;
1025
1026        // 任意长度字符串均可(无长度上限)
1027        assert!(field_type
1028            .validate("content", &serde_json::json!("hello"))
1029            .is_ok());
1030        assert!(field_type
1031            .validate("content", &serde_json::json!("a".repeat(100_000)))
1032            .is_ok());
1033        assert!(field_type
1034            .validate("content", &serde_json::json!(""))
1035            .is_ok());
1036    }
1037
1038    #[test]
1039    fn test_validate_text_invalid_type() {
1040        let field_type = FieldType::Text;
1041
1042        // 非字符串返回 InvalidFieldType
1043        let result = field_type.validate("content", &serde_json::json!(123));
1044        assert!(
1045            matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "content")
1046        );
1047        assert!(field_type
1048            .validate("content", &serde_json::json!(true))
1049            .is_err());
1050        assert!(field_type
1051            .validate("content", &serde_json::json!(null))
1052            .is_err());
1053    }
1054
1055    #[test]
1056    fn test_validate_foreign_key_not_enforced() {
1057        let field_type = FieldType::ForeignKey {
1058            table: "users".to_string(),
1059            field: "id".to_string(),
1060        };
1061
1062        // FK 值类型由目标表约束决定,此处不强校验:各类型都应通过
1063        assert!(field_type
1064            .validate("user_id", &serde_json::json!(1))
1065            .is_ok());
1066        assert!(field_type
1067            .validate("user_id", &serde_json::json!("uuid-string"))
1068            .is_ok());
1069        assert!(field_type
1070            .validate("user_id", &serde_json::json!(null))
1071            .is_ok());
1072    }
1073
1074    #[test]
1075    fn test_validate_enum_success() {
1076        let field_type = FieldType::Enum {
1077            values: vec![
1078                "pending".to_string(),
1079                "approved".to_string(),
1080                "rejected".to_string(),
1081            ],
1082        };
1083
1084        // 正常情况
1085        assert!(field_type
1086            .validate("status", &serde_json::json!("pending"))
1087            .is_ok());
1088        assert!(field_type
1089            .validate("status", &serde_json::json!("approved"))
1090            .is_ok());
1091        assert!(field_type
1092            .validate("status", &serde_json::json!("rejected"))
1093            .is_ok());
1094    }
1095
1096    #[test]
1097    fn test_validate_enum_invalid_value() {
1098        let field_type = FieldType::Enum {
1099            values: vec![
1100                "pending".to_string(),
1101                "approved".to_string(),
1102                "rejected".to_string(),
1103            ],
1104        };
1105
1106        // 枚举值不在列表中
1107        let result = field_type.validate("status", &serde_json::json!("invalid"));
1108        assert!(result.is_err());
1109
1110        assert!(
1111            matches!(result, Err(BaseError::InvalidEnumValue(ref field, ref value)) if field == "status" && value == "invalid"),
1112            "期望 InvalidEnumValue 错误,实际: {:?}",
1113            result
1114        );
1115    }
1116
1117    #[test]
1118    fn test_validate_enum_invalid_type() {
1119        let field_type = FieldType::Enum {
1120            values: vec!["pending".to_string()],
1121        };
1122
1123        // 类型不匹配
1124        assert!(field_type
1125            .validate("status", &serde_json::json!(123))
1126            .is_err());
1127        assert!(field_type
1128            .validate("status", &serde_json::json!(true))
1129            .is_err());
1130    }
1131
1132    #[test]
1133    fn test_validate_json_success() {
1134        let field_type = FieldType::Json;
1135
1136        // JSON 对象
1137        assert!(field_type
1138            .validate("data", &serde_json::json!({"key": "value"}))
1139            .is_ok());
1140
1141        // JSON 数组
1142        assert!(field_type
1143            .validate("data", &serde_json::json!([1, 2, 3]))
1144            .is_ok());
1145
1146        // JSON 字符串(合法的 JSON)
1147        assert!(field_type
1148            .validate("data", &serde_json::json!("{\"key\": \"value\"}"))
1149            .is_ok());
1150        assert!(field_type
1151            .validate("data", &serde_json::json!("[1, 2, 3]"))
1152            .is_ok());
1153    }
1154
1155    #[test]
1156    fn test_validate_json_invalid_format() {
1157        let field_type = FieldType::Json;
1158
1159        // 无效的 JSON 字符串
1160        let result = field_type.validate("data", &serde_json::json!("not a json"));
1161        assert!(result.is_err());
1162
1163        assert!(
1164            matches!(result, Err(BaseError::InvalidJsonFormat(ref field, _)) if field == "data"),
1165            "期望 InvalidJsonFormat 错误,实际: {:?}",
1166            result
1167        );
1168    }
1169
1170    #[test]
1171    fn test_validate_json_invalid_type() {
1172        let field_type = FieldType::Json;
1173
1174        // 类型不匹配(不是对象、数组或字符串)
1175        assert!(field_type
1176            .validate("data", &serde_json::json!(123))
1177            .is_err());
1178        assert!(field_type
1179            .validate("data", &serde_json::json!(true))
1180            .is_err());
1181        assert!(field_type
1182            .validate("data", &serde_json::json!(null))
1183            .is_err());
1184    }
1185}