use crate::error::BaseError;
use serde::{Deserialize, Serialize};
fn value_type_name(value: &serde_json::Value) -> &'static str {
match value {
serde_json::Value::Null => "null",
serde_json::Value::Bool(_) => "boolean",
serde_json::Value::Number(_) => "number",
serde_json::Value::String(_) => "string",
serde_json::Value::Array(_) => "array",
serde_json::Value::Object(_) => "object",
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum FieldType {
String {
max_length: usize,
},
Integer,
BigInt,
Float,
Double,
Boolean,
Date,
DateTime,
Timestamp,
Json,
Text,
Enum {
values: Vec<String>,
},
ForeignKey {
table: String,
field: String,
},
}
impl FieldType {
pub fn display_name(&self) -> &str {
match self {
FieldType::String { .. } => "字符串",
FieldType::Integer => "整数",
FieldType::BigInt => "长整数",
FieldType::Float => "单精度浮点数",
FieldType::Double => "双精度浮点数",
FieldType::Boolean => "布尔值",
FieldType::Date => "日期",
FieldType::DateTime => "日期时间",
FieldType::Timestamp => "时间戳",
FieldType::Json => "JSON",
FieldType::Text => "文本",
FieldType::Enum { .. } => "枚举",
FieldType::ForeignKey { .. } => "外键",
}
}
pub fn is_numeric(&self) -> bool {
matches!(
self,
FieldType::Integer | FieldType::BigInt | FieldType::Float | FieldType::Double
)
}
pub fn is_temporal(&self) -> bool {
matches!(
self,
FieldType::Date | FieldType::DateTime | FieldType::Timestamp
)
}
pub fn is_text(&self) -> bool {
matches!(self, FieldType::String { .. } | FieldType::Text)
}
pub fn validate(&self, field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
match self {
FieldType::String { max_length } => {
if let Some(s) = value.as_str() {
let len = s.chars().count();
if len > *max_length {
return Err(BaseError::StringTooLong(
field_name.to_string(),
len,
*max_length,
));
}
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望字符串类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Integer => {
if value.is_i64() || value.is_u64() {
if let Some(n) = value.as_i64() {
if n >= i32::MIN as i64 && n <= i32::MAX as i64 {
return Ok(());
}
}
Err(BaseError::InvalidFieldType(
field_name.to_string(),
"整数值超出 i32 范围".to_string(),
))
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望整数类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::BigInt => {
if value.is_i64() || value.is_u64() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望长整数类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Float => {
if value.is_f64() || value.is_i64() || value.is_u64() {
if let Some(n) = value.as_f64() {
if n.is_finite() && n.abs() <= f32::MAX as f64 {
return Ok(());
}
}
Err(BaseError::InvalidFieldType(
field_name.to_string(),
"浮点数值超出 f32 范围".to_string(),
))
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望浮点数类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Double => {
if value.is_f64() || value.is_i64() || value.is_u64() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望双精度浮点数类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Boolean => {
if value.is_boolean() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望布尔类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Enum { values } => {
if let Some(s) = value.as_str() {
if values.contains(&s.to_string()) {
Ok(())
} else {
Err(BaseError::InvalidEnumValue(
field_name.to_string(),
s.to_string(),
))
}
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!(
"期望字符串类型的枚举值,实际类型: {}",
value_type_name(value)
),
))
}
}
FieldType::Json => {
if let Some(s) = value.as_str() {
serde_json::from_str::<serde_json::Value>(s)
.map(|_| ())
.map_err(|e| {
BaseError::InvalidJsonFormat(field_name.to_string(), e.to_string())
})
} else {
if value.is_object() || value.is_array() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望 JSON 对象或数组,实际类型: {}", value_type_name(value)),
))
}
}
}
_ => Ok(()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_field_type_display_name() {
assert_eq!(
FieldType::String { max_length: 50 }.display_name(),
"字符串"
);
assert_eq!(FieldType::Integer.display_name(), "整数");
assert_eq!(FieldType::BigInt.display_name(), "长整数");
assert_eq!(FieldType::Float.display_name(), "单精度浮点数");
assert_eq!(FieldType::Double.display_name(), "双精度浮点数");
assert_eq!(FieldType::Boolean.display_name(), "布尔值");
assert_eq!(FieldType::Date.display_name(), "日期");
assert_eq!(FieldType::DateTime.display_name(), "日期时间");
assert_eq!(FieldType::Timestamp.display_name(), "时间戳");
assert_eq!(FieldType::Json.display_name(), "JSON");
assert_eq!(FieldType::Text.display_name(), "文本");
assert_eq!(
FieldType::Enum {
values: vec!["a".to_string()]
}
.display_name(),
"枚举"
);
assert_eq!(
FieldType::ForeignKey {
table: "users".to_string(),
field: "id".to_string()
}
.display_name(),
"外键"
);
}
#[test]
fn test_is_numeric() {
assert!(FieldType::Integer.is_numeric());
assert!(FieldType::BigInt.is_numeric());
assert!(FieldType::Float.is_numeric());
assert!(FieldType::Double.is_numeric());
assert!(!FieldType::String { max_length: 50 }.is_numeric());
assert!(!FieldType::Boolean.is_numeric());
}
#[test]
fn test_is_temporal() {
assert!(FieldType::Date.is_temporal());
assert!(FieldType::DateTime.is_temporal());
assert!(FieldType::Timestamp.is_temporal());
assert!(!FieldType::String { max_length: 50 }.is_temporal());
assert!(!FieldType::Integer.is_temporal());
}
#[test]
fn test_is_text() {
assert!(FieldType::String { max_length: 50 }.is_text());
assert!(FieldType::Text.is_text());
assert!(!FieldType::Integer.is_text());
assert!(!FieldType::Boolean.is_text());
}
#[test]
fn test_field_type_equality() {
let type1 = FieldType::String { max_length: 50 };
let type2 = FieldType::String { max_length: 50 };
let type3 = FieldType::String { max_length: 100 };
assert_eq!(type1, type2);
assert_ne!(type1, type3);
}
#[test]
fn test_enum_type() {
let enum_type = FieldType::Enum {
values: vec![
"pending".to_string(),
"approved".to_string(),
"rejected".to_string(),
],
};
assert_eq!(enum_type.display_name(), "枚举");
assert!(!enum_type.is_numeric());
assert!(!enum_type.is_temporal());
assert!(!enum_type.is_text());
}
#[test]
fn test_foreign_key_type() {
let fk_type = FieldType::ForeignKey {
table: "users".to_string(),
field: "id".to_string(),
};
assert_eq!(fk_type.display_name(), "外键");
assert!(!fk_type.is_numeric());
assert!(!fk_type.is_temporal());
assert!(!fk_type.is_text());
}
#[test]
fn test_validate_string_success() {
let field_type = FieldType::String { max_length: 10 };
assert!(field_type
.validate("name", &serde_json::json!("hello"))
.is_ok());
assert!(field_type.validate("name", &serde_json::json!("")).is_ok());
assert!(field_type
.validate("name", &serde_json::json!("1234567890"))
.is_ok());
}
#[test]
fn test_validate_string_too_long() {
let field_type = FieldType::String { max_length: 10 };
let result = field_type.validate("name", &serde_json::json!("this is too long"));
assert!(result.is_err());
if let Err(BaseError::StringTooLong(field, len, max)) = result {
assert_eq!(field, "name");
assert_eq!(len, 16);
assert_eq!(max, 10);
} else {
panic!("期望 StringTooLong 错误");
}
}
#[test]
fn test_validate_string_invalid_type() {
let field_type = FieldType::String { max_length: 10 };
assert!(field_type
.validate("name", &serde_json::json!(123))
.is_err());
assert!(field_type
.validate("name", &serde_json::json!(true))
.is_err());
assert!(field_type
.validate("name", &serde_json::json!(null))
.is_err());
}
#[test]
fn test_validate_integer_success() {
let field_type = FieldType::Integer;
assert!(field_type.validate("age", &serde_json::json!(25)).is_ok());
assert!(field_type.validate("age", &serde_json::json!(0)).is_ok());
assert!(field_type.validate("age", &serde_json::json!(-100)).is_ok());
assert!(field_type
.validate("age", &serde_json::json!(i32::MAX))
.is_ok());
assert!(field_type
.validate("age", &serde_json::json!(i32::MIN))
.is_ok());
}
#[test]
fn test_validate_integer_out_of_range() {
let field_type = FieldType::Integer;
let result = field_type.validate("age", &serde_json::json!(i64::MAX));
assert!(result.is_err());
}
#[test]
fn test_validate_integer_invalid_type() {
let field_type = FieldType::Integer;
assert!(field_type
.validate("age", &serde_json::json!("not a number"))
.is_err());
assert!(field_type
.validate("age", &serde_json::json!(true))
.is_err());
assert!(field_type.validate("age", &serde_json::json!(3.5)).is_err());
}
#[test]
fn test_validate_bigint_success() {
let field_type = FieldType::BigInt;
assert!(field_type
.validate("id", &serde_json::json!(123456789))
.is_ok());
assert!(field_type
.validate("id", &serde_json::json!(i64::MAX))
.is_ok());
assert!(field_type
.validate("id", &serde_json::json!(i64::MIN))
.is_ok());
}
#[test]
fn test_validate_bigint_invalid_type() {
let field_type = FieldType::BigInt;
assert!(field_type
.validate("id", &serde_json::json!("not a number"))
.is_err());
assert!(field_type.validate("id", &serde_json::json!(3.5)).is_err());
}
#[test]
fn test_validate_float_success() {
let field_type = FieldType::Float;
assert!(field_type
.validate("price", &serde_json::json!(3.5))
.is_ok());
assert!(field_type
.validate("price", &serde_json::json!(0.0))
.is_ok());
assert!(field_type
.validate("price", &serde_json::json!(-1.5))
.is_ok());
assert!(field_type
.validate("price", &serde_json::json!(100))
.is_ok());
}
#[test]
fn test_validate_float_invalid_type() {
let field_type = FieldType::Float;
assert!(field_type
.validate("price", &serde_json::json!("not a number"))
.is_err());
assert!(field_type
.validate("price", &serde_json::json!(true))
.is_err());
}
#[test]
fn test_validate_double_success() {
let field_type = FieldType::Double;
assert!(field_type
.validate("amount", &serde_json::json!(123.456))
.is_ok());
assert!(field_type
.validate("amount", &serde_json::json!(0.0))
.is_ok());
assert!(field_type
.validate("amount", &serde_json::json!(100))
.is_ok());
}
#[test]
fn test_validate_double_invalid_type() {
let field_type = FieldType::Double;
assert!(field_type
.validate("amount", &serde_json::json!("not a number"))
.is_err());
assert!(field_type
.validate("amount", &serde_json::json!(true))
.is_err());
}
#[test]
fn test_validate_boolean_success() {
let field_type = FieldType::Boolean;
assert!(field_type
.validate("active", &serde_json::json!(true))
.is_ok());
assert!(field_type
.validate("active", &serde_json::json!(false))
.is_ok());
}
#[test]
fn test_validate_boolean_invalid_type() {
let field_type = FieldType::Boolean;
assert!(field_type
.validate("active", &serde_json::json!("true"))
.is_err());
assert!(field_type
.validate("active", &serde_json::json!(1))
.is_err());
assert!(field_type
.validate("active", &serde_json::json!(0))
.is_err());
}
#[test]
fn test_validate_enum_success() {
let field_type = FieldType::Enum {
values: vec![
"pending".to_string(),
"approved".to_string(),
"rejected".to_string(),
],
};
assert!(field_type
.validate("status", &serde_json::json!("pending"))
.is_ok());
assert!(field_type
.validate("status", &serde_json::json!("approved"))
.is_ok());
assert!(field_type
.validate("status", &serde_json::json!("rejected"))
.is_ok());
}
#[test]
fn test_validate_enum_invalid_value() {
let field_type = FieldType::Enum {
values: vec![
"pending".to_string(),
"approved".to_string(),
"rejected".to_string(),
],
};
let result = field_type.validate("status", &serde_json::json!("invalid"));
assert!(result.is_err());
if let Err(BaseError::InvalidEnumValue(field, value)) = result {
assert_eq!(field, "status");
assert_eq!(value, "invalid");
} else {
panic!("期望 InvalidEnumValue 错误");
}
}
#[test]
fn test_validate_enum_invalid_type() {
let field_type = FieldType::Enum {
values: vec!["pending".to_string()],
};
assert!(field_type
.validate("status", &serde_json::json!(123))
.is_err());
assert!(field_type
.validate("status", &serde_json::json!(true))
.is_err());
}
#[test]
fn test_validate_json_success() {
let field_type = FieldType::Json;
assert!(field_type
.validate("data", &serde_json::json!({"key": "value"}))
.is_ok());
assert!(field_type
.validate("data", &serde_json::json!([1, 2, 3]))
.is_ok());
assert!(field_type
.validate("data", &serde_json::json!("{\"key\": \"value\"}"))
.is_ok());
assert!(field_type
.validate("data", &serde_json::json!("[1, 2, 3]"))
.is_ok());
}
#[test]
fn test_validate_json_invalid_format() {
let field_type = FieldType::Json;
let result = field_type.validate("data", &serde_json::json!("not a json"));
assert!(result.is_err());
if let Err(BaseError::InvalidJsonFormat(field, _)) = result {
assert_eq!(field, "data");
} else {
panic!("期望 InvalidJsonFormat 错误");
}
}
#[test]
fn test_validate_json_invalid_type() {
let field_type = FieldType::Json;
assert!(field_type
.validate("data", &serde_json::json!(123))
.is_err());
assert!(field_type
.validate("data", &serde_json::json!(true))
.is_err());
assert!(field_type
.validate("data", &serde_json::json!(null))
.is_err());
}
}