Skip to main content

yang_base/table/
field_type.rs

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