//! model —— 解析 baseline 的 `f_tables_data`(表结构定义)。 //! //! ## 数据结构(实测) //! //! ```json //! [ //! { //! "table": "test_receivable", //! "tableName": "应收费用主表", //! "typeId": "1", // "1" = 主表, "0" = 子表 //! "relationTable": "", //! "relationField": "", //! "tableField": "", //! "fields": [ //! { //! "field": "F_Id", // 设计态字段名(权威) //! "columnName": null, // 物理列名 —— **常常是 null**! //! "fieldName": "主键", // 显示名 //! "dataType": "varchar", //! "dataLength": "50", //! "primaryKey": 1, //! "allowNull": 0, //! "autoIncrement": 0, //! "identity": 0 //! } //! ] //! } //! ] //! ``` //! //! ## 🔴 最重要的一条:`columnName` 不可信 //! //! 实测数据里 `columnName` **大量为 null** ——「设计完还没建表」的商品态就是这样。 //! 所以物理列名必须从 `field` 推导(规则与 `form::v_model_to_column` 同一份实现): //! //! ```text //! F_Id → f_id //! F_Room → f_room //! F_CertificatesType → f_certificatestype ← 注意没有下划线 //! ``` //! //! ⇒ **不要指望「驼峰转下划线」**。真实列名最终以数据库 `information_schema` 为准, //! 本模块只负责「设计态 → 预期列名」的推导与一致性校验。 use serde_json::{Map, Value}; use crate::form::v_model_to_column; /// 解析失败原因。 #[derive(Debug, Clone, PartialEq, Eq)] pub enum ModelError { /// 不是数组。 NotAnArray, /// 空数组。 Empty, } impl ModelError { /// 机器可读码。 pub fn code(&self) -> &'static str { match self { ModelError::NotAnArray => "MODEL_NOT_ARRAY", ModelError::Empty => "MODEL_EMPTY", } } /// 人话说明。 pub fn message(&self) -> &'static str { match self { ModelError::NotAnArray => { "f_tables_data 不是数组 —— 它应该是多张表的定义列表([{table,tableName,typeId,fields}])" } ModelError::Empty => "f_tables_data 是空数组,没有任何表定义", } } } /// 一列的定义。 #[derive(Debug, Clone, PartialEq)] pub struct ColumnDef { /// 设计态字段名(`F_Id`)。**这是权威字段名**。 pub field: String, /// 官方给的物理列名 —— 可能为 null(尚未建表)。 pub column_name: Option, /// 显示名(`主键`)。 pub field_name: String, /// 数据类型(`varchar` / `int4` / `timestamp` …)。 pub data_type: String, /// 长度(字符串形态,官方如此)。 pub data_length: String, /// 是否主键。 pub primary_key: bool, /// 是否允许 NULL。 pub allow_null: bool, /// 是否自增。 pub auto_increment: bool, } impl ColumnDef { /// 实际使用的物理列名:`columnName` 优先,否则从 `field` 推导。 /// /// 🔴 只在**非空**时才信 `columnName` —— 实测大量为 `null`。 pub fn resolved_column(&self) -> Option { match &self.column_name { Some(c) if !c.is_empty() => Some(c.to_lowercase()), _ => v_model_to_column(&self.field), } } } /// 一张表的定义。 #[derive(Debug, Clone, PartialEq)] pub struct TableSchema { /// 物理表名。 pub table: String, /// 显示名。 pub table_name: String, /// `"1"` = 主表,`"0"` = 子表。 pub type_id: String, /// 列定义(顺序即建表顺序)。 pub fields: Vec, /// 🔴 **子表外键列**(`tableField`)—— 子表里指向主表主键的那一列。 /// /// ## 溯源 /// /// Java `FlowFormDataUtil.createMastTable()`: /// ```java /// String foreignKey = tableModel.getTableField(); /// GeneralInsertDSL dsl = insertInto(sqlTable).set(sqlTable.column(foreignKey)).toValue(foreignValue); /// ``` /// /// ⇒ 外键列名**来自模型**,不是常量。实测 `test_details` 的 `tableField` 是 /// `F_Receivableid` ⇒ 物理列 `f_receivableid`,**不是** `f_foreign_id`。 /// /// 🔴 之前硬编码 `f_foreign_id` 会在真实数据上直接 `column does not exist`。 pub table_field: Option, /// 🔴 **主表关联字段**(`relationField`)—— 主表里被子表外键引用的那一列。 /// /// Java:`Object foreignValue = dataNewMap.get(tableModel.getRelationField());` pub relation_field: Option, /// 本表关联到的主表名(`relationTable`;主表自身为空串)。 pub relation_table: Option, } impl TableSchema { /// 是否主表。 pub fn is_main(&self) -> bool { self.type_id == "1" } /// 子表外键列的**物理列名**(`tableField` 推导)。 pub fn foreign_key_column(&self) -> Option { self.table_field .as_deref() .and_then(crate::form::v_model_to_column) } /// 主表关联列的**物理列名**(`relationField` 推导)。 pub fn relation_column(&self) -> Option { self.relation_field .as_deref() .and_then(crate::form::v_model_to_column) } /// 按 `F_xxx` 风格的设计态字段名找列(大小写不敏感)。 pub fn column_by_field(&self, field: &str) -> Option<&ColumnDef> { self.fields .iter() .find(|c| c.field.eq_ignore_ascii_case(field)) } /// 按物理列名找列(大小写不敏感)。 pub fn column_by_name(&self, name: &str) -> Option<&ColumnDef> { self.fields.iter().find(|c| { c.resolved_column() .is_some_and(|r| r.eq_ignore_ascii_case(name)) }) } /// 全部物理列名(已推导)。 pub fn column_names(&self) -> Vec { self.fields .iter() .filter_map(|c| c.resolved_column()) .collect() } /// 主键列名(可能为空 —— 设计态没标主键)。 pub fn primary_keys(&self) -> Vec { self.fields .iter() .filter(|c| c.primary_key) .filter_map(|c| c.resolved_column()) .collect() } } /// 解析后的模型(保留原始 JSON)。 #[derive(Debug, Clone)] pub struct ModelSchema { /// 原始 JSON —— 同构保存时原样写回。 pub raw: Value, /// 表清单。 pub tables: Vec, } impl ModelSchema { /// 解析 `f_tables_data`。 pub fn parse(raw: &Value) -> Result { let Some(arr) = raw.as_array() else { return Err(ModelError::NotAnArray); }; if arr.is_empty() { return Err(ModelError::Empty); } Ok(Self { raw: raw.clone(), tables: arr.iter().filter_map(parse_table).collect(), }) } /// 从 JSON 文本解析。 pub fn from_str(s: &str) -> Result { let v: Value = serde_json::from_str(s).map_err(|_| ModelError::NotAnArray)?; Self::parse(&v) } /// 主表(`typeId == "1"`)。多个主表时取第一个。 pub fn main_table(&self) -> Option<&TableSchema> { self.tables.iter().find(|t| t.is_main()) } /// 按物理表名查找(大小写不敏感 —— 官方数据里有大小写混用)。 pub fn table(&self, name: &str) -> Option<&TableSchema> { self.tables .iter() .find(|t| t.table.eq_ignore_ascii_case(name)) } /// 子表清单。 pub fn sub_tables(&self) -> Vec<&TableSchema> { self.tables.iter().filter(|t| !t.is_main()).collect() } } fn parse_table(v: &Value) -> Option { let obj = v.as_object()?; let table = obj.get("table").and_then(Value::as_str)?.trim().to_string(); if table.is_empty() { return None; } Some(TableSchema { table, table_name: str_of(obj, "tableName"), type_id: match obj.get("typeId") { Some(Value::String(s)) => s.clone(), Some(Value::Number(n)) => n.to_string(), _ => "0".to_string(), }, // 🔴 官方数据里这三个字段是空串(主表)或具体列名(子表)⇒ 空串视作「没有」。 table_field: opt_str(obj, "tableField"), relation_field: opt_str(obj, "relationField"), relation_table: opt_str(obj, "relationTable"), fields: obj .get("fields") .and_then(Value::as_array) .map(|a| a.iter().filter_map(parse_column).collect()) .unwrap_or_default(), }) } /// 取一个非空字符串字段(空串 ⇒ `None`)。 fn opt_str(obj: &Map, key: &str) -> Option { obj.get(key) .and_then(Value::as_str) .map(str::trim) .filter(|s| !s.is_empty()) .map(str::to_string) } fn parse_column(v: &Value) -> Option { let obj = v.as_object()?; let field = obj.get("field").and_then(Value::as_str)?.trim().to_string(); if field.is_empty() { return None; } Some(ColumnDef { field, column_name: obj .get("columnName") .and_then(Value::as_str) .map(str::to_string), field_name: str_of(obj, "fieldName"), data_type: str_of(obj, "dataType"), data_length: match obj.get("dataLength") { Some(Value::String(s)) => s.clone(), Some(Value::Number(n)) => n.to_string(), _ => String::new(), }, primary_key: truthy(obj.get("primaryKey")), allow_null: truthy(obj.get("allowNull")), auto_increment: truthy(obj.get("autoIncrement")), }) } /// 官方的布尔字段是 `0/1` 数字,但也见过 `true/false` 与 `"1"` 字符串。 fn truthy(v: Option<&Value>) -> bool { match v { Some(Value::Bool(b)) => *b, Some(Value::Number(n)) => n.as_i64().unwrap_or(0) != 0, Some(Value::String(s)) => s == "1" || s.eq_ignore_ascii_case("true"), _ => false, } } fn str_of(obj: &Map, key: &str) -> String { obj.get(key) .and_then(Value::as_str) .unwrap_or("") .to_string() } #[cfg(test)] mod tests { use super::*; use serde_json::json; fn model() -> Value { json!([ { "table": "t_main", "tableName": "主表", "typeId": "1", "fields": [ {"field":"F_Id","columnName":null,"fieldName":"主键","dataType":"varchar", "dataLength":"50","primaryKey":1,"allowNull":0}, {"field":"F_Title","columnName":null,"fieldName":"标题","dataType":"varchar", "dataLength":"200","primaryKey":0,"allowNull":1}, {"field":"F_Amount","columnName":"f_amount","fieldName":"金额","dataType":"numeric", "dataLength":"","primaryKey":0,"allowNull":1} ] }, { "table": "t_child", "tableName": "子表", "typeId": "0", "fields": [ {"field":"F_Item","columnName":null,"fieldName":"项目","dataType":"varchar", "dataLength":"100","primaryKey":0,"allowNull":1} ] } ]) } #[test] fn parses_tables_and_flags() { let m = ModelSchema::parse(&model()).unwrap(); assert_eq!(m.tables.len(), 2); assert_eq!(m.main_table().unwrap().table, "t_main"); assert_eq!(m.sub_tables().len(), 1); assert!(m.main_table().unwrap().is_main()); } /// 🔴 `columnName` 为 null 时必须从 `field` 推导 —— 实测数据大量如此。 #[test] fn resolves_column_name_when_null() { let m = ModelSchema::parse(&model()).unwrap(); let t = m.main_table().unwrap(); assert_eq!(t.column_names(), vec!["f_id", "f_title", "f_amount"]); assert_eq!( t.column_by_field("F_Title").unwrap().resolved_column().as_deref(), Some("f_title") ); } /// 官方给了 `columnName` 时以它为准(可能与推导结果不同)。 #[test] fn prefers_explicit_column_name() { let m = ModelSchema::parse(&model()).unwrap(); let t = m.main_table().unwrap(); let c = t.column_by_field("F_Amount").unwrap(); assert_eq!(c.column_name.as_deref(), Some("f_amount")); assert_eq!(c.resolved_column().as_deref(), Some("f_amount")); } #[test] fn primary_keys_are_reported() { let m = ModelSchema::parse(&model()).unwrap(); assert_eq!(m.main_table().unwrap().primary_keys(), vec!["f_id"]); } #[test] fn rejects_wrong_shapes() { assert_eq!(ModelSchema::parse(&json!({})).unwrap_err(), ModelError::NotAnArray); assert_eq!(ModelSchema::parse(&json!([])).unwrap_err(), ModelError::Empty); } /// 主表可能缺失(用户只建了子表)—— 调用方要能处理。 #[test] fn missing_main_table_is_none_not_panic() { let m = ModelSchema::parse(&json!([ {"table":"t_child","typeId":"0","fields":[]} ])) .unwrap(); assert!(m.main_table().is_none()); assert_eq!(m.sub_tables().len(), 1); } /// 布尔字段可能是 0/1、"1"、true —— 三种都要认。 #[test] fn truthy_accepts_three_encodings() { assert!(truthy(Some(&json!(1)))); assert!(truthy(Some(&json!("1")))); assert!(truthy(Some(&json!(true)))); assert!(!truthy(Some(&json!(0)))); assert!(!truthy(Some(&json!("0")))); assert!(!truthy(None)); } #[test] fn raw_is_preserved() { let v = model(); let m = ModelSchema::parse(&v).unwrap(); assert_eq!(m.raw, v); } }