#[allow(dead_code)] pub const MYSQL_MAX_VARCHAR_LENGTH: usize = 16_383;
#[allow(dead_code)] pub const POSTGRES_MAX_VARCHAR_LENGTH: usize = 10_485_760;
#[cfg(all(feature = "mysql", not(feature = "postgres")))]
pub const MAX_VARCHAR_LENGTH: usize = MYSQL_MAX_VARCHAR_LENGTH;
#[cfg(feature = "postgres")]
pub const MAX_VARCHAR_LENGTH: usize = POSTGRES_MAX_VARCHAR_LENGTH;
#[cfg(not(any(feature = "mysql", feature = "postgres")))]
pub const MAX_VARCHAR_LENGTH: usize = MYSQL_MAX_VARCHAR_LENGTH;
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)]
#[non_exhaustive]
pub enum FieldType {
String {
max_length: usize,
},
Integer,
BigInt,
Float,
Double,
Decimal {
precision: u8,
scale: u8,
},
Boolean,
Date,
DateTime,
Timestamp,
Json,
Text,
Enum {
values: Vec<String>,
},
Uuid,
Bytes,
Array(Box<FieldType>),
}
impl FieldType {
pub fn display_name(&self) -> &str {
match self {
FieldType::String { .. } => "字符串",
FieldType::Integer => "整数",
FieldType::BigInt => "长整数",
FieldType::Float => "单精度浮点数",
FieldType::Double => "双精度浮点数",
FieldType::Decimal { .. } => "定点小数",
FieldType::Boolean => "布尔值",
FieldType::Date => "日期",
FieldType::DateTime => "日期时间",
FieldType::Timestamp => "时间戳",
FieldType::Json => "JSON",
FieldType::Text => "文本",
FieldType::Enum { .. } => "枚举",
FieldType::Uuid => "UUID",
FieldType::Bytes => "二进制",
FieldType::Array(_) => "数组",
}
}
pub fn array(element: FieldType) -> Self {
FieldType::Array(Box::new(element))
}
pub fn is_uuid(&self) -> bool {
matches!(self, FieldType::Uuid)
}
pub fn is_binary(&self) -> bool {
matches!(self, FieldType::Bytes)
}
pub fn is_array(&self) -> bool {
matches!(self, FieldType::Array(_))
}
pub fn is_numeric(&self) -> bool {
matches!(
self,
FieldType::Integer
| FieldType::BigInt
| FieldType::Float
| FieldType::Double
| FieldType::Decimal { .. }
)
}
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.as_i64().is_some() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望 i64 范围内的长整数,实际值: {}", 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::Decimal { precision, scale } => {
validate_decimal(field_name, value, *precision, *scale)
}
FieldType::Boolean => {
if value.is_boolean() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望布尔类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Date => validate_date(field_name, value),
FieldType::DateTime => validate_datetime(field_name, value),
FieldType::Timestamp => validate_timestamp(field_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 value.is_object() || value.is_array() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望 JSON 对象或数组,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Text => {
if value.as_str().is_some() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望文本字符串类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Uuid => {
if value.as_str().is_some() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望 UUID 字符串,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Bytes => {
if value.as_str().is_some() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!(
"期望 Base64 二进制字符串,实际类型: {}",
value_type_name(value)
),
))
}
}
FieldType::Array(element) => {
let Some(items) = value.as_array() else {
return Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望 JSON 数组,实际类型: {}", value_type_name(value)),
));
};
for item in items {
if !item.is_null() {
element.validate(field_name, item)?;
}
}
Ok(())
}
}
}
}
fn validate_decimal(
field_name: &str,
value: &serde_json::Value,
precision: u8,
scale: u8,
) -> Result<(), BaseError> {
let text = match value {
serde_json::Value::String(value) => std::borrow::Cow::Borrowed(value.as_str()),
serde_json::Value::Number(value) => std::borrow::Cow::Owned(value.to_string()),
_ => {
return Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!(
"期望十进制数字或字符串,实际类型: {}",
value_type_name(value)
),
));
}
};
let unsigned = text.strip_prefix('-').unwrap_or(text.as_ref());
let (integer, fraction) = unsigned.split_once('.').unwrap_or((unsigned, ""));
let digits = integer.len() + fraction.len();
let valid = !integer.is_empty()
&& integer.bytes().all(|byte| byte.is_ascii_digit())
&& fraction.bytes().all(|byte| byte.is_ascii_digit())
&& digits <= usize::from(precision)
&& fraction.len() <= usize::from(scale);
if valid {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("值 {text} 不符合 DECIMAL({precision}, {scale})"),
))
}
}
fn validate_date(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
if let Some(s) = value.as_str() {
chrono::NaiveDate::parse_from_str(s, "%Y-%m-%d")
.map(|_| ())
.map_err(|_| {
BaseError::InvalidFieldType(
field_name.to_string(),
format!("日期格式无效,期望 YYYY-MM-DD,实际: {}", s),
)
})
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望日期字符串类型,实际类型: {}", value_type_name(value)),
))
}
}
fn validate_datetime(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
if let Some(s) = value.as_str() {
chrono::DateTime::parse_from_rfc3339(s)
.map(|_| ())
.map_err(|_| {
BaseError::InvalidFieldType(
field_name.to_string(),
format!("日期时间格式无效,期望 RFC 3339,实际: {s}"),
)
})
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!(
"期望日期时间字符串类型,实际类型: {}",
value_type_name(value)
),
))
}
}
fn validate_timestamp(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
if let Some(ts) = value.as_i64() {
chrono::DateTime::<chrono::Utc>::from_timestamp_secs(ts)
.map(|_| ())
.ok_or_else(|| {
BaseError::InvalidFieldType(
field_name.to_string(),
format!("时间戳超出有效范围,实际: {}", ts),
)
})
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望 Unix 时间戳整数,实际类型: {}", value_type_name(value)),
))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn varchar_limit_follows_backend_dialect() {
assert_eq!(MYSQL_MAX_VARCHAR_LENGTH, 16_383);
assert_eq!(POSTGRES_MAX_VARCHAR_LENGTH, 10_485_760);
#[cfg(all(feature = "mysql", not(feature = "postgres")))]
assert_eq!(MAX_VARCHAR_LENGTH, MYSQL_MAX_VARCHAR_LENGTH);
#[cfg(feature = "postgres")]
assert_eq!(MAX_VARCHAR_LENGTH, POSTGRES_MAX_VARCHAR_LENGTH);
#[cfg(not(any(feature = "mysql", feature = "postgres")))]
assert_eq!(MAX_VARCHAR_LENGTH, MYSQL_MAX_VARCHAR_LENGTH);
}
#[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(),
"枚举"
);
}
#[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_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());
assert!(
matches!(result, Err(BaseError::StringTooLong(ref field, 16, 10)) if field == "name"),
"期望 StringTooLong 错误,实际: {:?}",
result
);
}
#[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());
assert!(field_type
.validate("id", &serde_json::json!(u64::MAX))
.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_decimal_preserves_fixed_point_contract() {
let field_type = FieldType::Decimal {
precision: 8,
scale: 2,
};
assert!(field_type
.validate("amount", &serde_json::json!("123456.78"))
.is_ok());
assert!(field_type
.validate("amount", &serde_json::json!("1234567.89"))
.is_err());
assert!(field_type
.validate("amount", &serde_json::json!("1.234"))
.is_err());
assert!(field_type
.validate("amount", &serde_json::json!("not-a-number"))
.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_date_success() {
let field_type = FieldType::Date;
assert!(field_type
.validate("birthday", &serde_json::json!("2026-05-27"))
.is_ok());
}
#[test]
fn test_validate_date_invalid_format() {
let field_type = FieldType::Date;
let result = field_type.validate("birthday", &serde_json::json!("2026/05/27"));
assert!(result.is_err());
assert!(
matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
);
}
#[test]
fn test_validate_date_invalid_type() {
let field_type = FieldType::Date;
let result = field_type.validate("birthday", &serde_json::json!(20260527));
assert!(result.is_err());
assert!(
matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
);
}
#[test]
fn test_validate_datetime_success() {
let field_type = FieldType::DateTime;
assert!(field_type
.validate(
"created_at",
&serde_json::json!("2026-05-27T13:45:30+08:00"),
)
.is_ok());
assert!(field_type
.validate("created_at", &serde_json::json!("2026-05-27T05:45:30Z"))
.is_ok());
}
#[test]
fn test_validate_datetime_invalid_format() {
let field_type = FieldType::DateTime;
assert!(field_type
.validate("created_at", &serde_json::json!("2026-05-27T13:45:30"))
.is_err());
assert!(field_type
.validate("created_at", &serde_json::json!("2026-05-27 13:45:30"))
.is_err());
let result = field_type.validate("created_at", &serde_json::json!("2026/05/27 13:45:30"));
assert!(result.is_err());
assert!(
matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
);
}
#[test]
fn test_validate_datetime_matches_json_schema_date_time_format() {
let field_type = FieldType::DateTime;
let value = serde_json::json!("2026-05-27T13:45:30.123+08:00");
assert!(field_type.validate("created_at", &value).is_ok());
}
#[test]
fn test_validate_timestamp_success() {
let field_type = FieldType::Timestamp;
assert!(field_type
.validate("created_at", &serde_json::json!(1_764_221_130_i64))
.is_ok());
}
#[test]
fn test_validate_timestamp_invalid_type() {
let field_type = FieldType::Timestamp;
let result = field_type.validate("created_at", &serde_json::json!("2026-05-27 13:45:30"));
assert!(result.is_err());
assert!(
matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
);
}
#[test]
fn test_validate_text_success() {
let field_type = FieldType::Text;
assert!(field_type
.validate("content", &serde_json::json!("hello"))
.is_ok());
assert!(field_type
.validate("content", &serde_json::json!("a".repeat(100_000)))
.is_ok());
assert!(field_type
.validate("content", &serde_json::json!(""))
.is_ok());
}
#[test]
fn test_validate_text_invalid_type() {
let field_type = FieldType::Text;
let result = field_type.validate("content", &serde_json::json!(123));
assert!(
matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "content")
);
assert!(field_type
.validate("content", &serde_json::json!(true))
.is_err());
assert!(field_type
.validate("content", &serde_json::json!(null))
.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());
assert!(
matches!(result, Err(BaseError::InvalidEnumValue(ref field, ref value)) if field == "status" && value == "invalid"),
"期望 InvalidEnumValue 错误,实际: {:?}",
result
);
}
#[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());
}
#[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());
assert!(field_type
.validate("data", &serde_json::json!("{\"key\": \"value\"}"))
.is_err());
assert!(field_type
.validate("data", &serde_json::json!("[1, 2, 3]"))
.is_err());
assert!(
matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "data"),
"期望 InvalidFieldType 错误,实际: {:?}",
result
);
}
#[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());
}
#[test]
fn test_new_variants_display_name_and_predicates() {
assert_eq!(FieldType::Uuid.display_name(), "UUID");
assert_eq!(FieldType::Bytes.display_name(), "二进制");
assert_eq!(FieldType::array(FieldType::Integer).display_name(), "数组");
assert!(FieldType::Uuid.is_uuid());
assert!(!FieldType::Bytes.is_uuid());
assert!(FieldType::Bytes.is_binary());
assert!(!FieldType::Uuid.is_binary());
let array = FieldType::array(FieldType::Text);
assert!(array.is_array());
assert!(!FieldType::Text.is_array());
assert!(!array.is_text());
assert!(!array.is_numeric());
}
#[test]
fn test_validate_uuid_and_bytes_require_strings() {
assert!(FieldType::Uuid
.validate(
"uid",
&serde_json::json!("11111111-1111-1111-1111-111111111111")
)
.is_ok());
assert!(FieldType::Uuid
.validate("uid", &serde_json::json!(123))
.is_err());
assert!(FieldType::Bytes
.validate("payload", &serde_json::json!("3q2+7w=="))
.is_ok());
assert!(FieldType::Bytes
.validate("payload", &serde_json::json!([1, 2]))
.is_err());
}
#[test]
fn test_validate_array_recurses_scalar_rules_and_allows_null_elements() {
let field_type = FieldType::array(FieldType::Integer);
assert!(field_type
.validate("numbers", &serde_json::json!([1, 2, null]))
.is_ok());
assert!(field_type
.validate("numbers", &serde_json::json!([1, "two"]))
.is_err());
assert!(field_type
.validate("numbers", &serde_json::json!(1))
.is_err());
let text_array = FieldType::array(FieldType::Text);
assert!(text_array
.validate("tags", &serde_json::json!(["a", null, "c"]))
.is_ok());
assert!(text_array
.validate("tags", &serde_json::json!([1]))
.is_err());
}
}