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