fix(ontology): 终审修复——axioms PUT 三态保持 + 缓存锁统一(classMu)+失效防污染+dateOrder 闭包声明+merge 缓存失效+父子互斥补齐+文档措辞

Co-Authored-By: Claude Opus 4.8 <[email protected]>
This commit is contained in:
adminandClaude Opus 4.8 committed 2026-09-20 22:10:02 +08:00
1 parent e16bca882c
commit cbb3a76760
9 files changed
+304 -80

No files matched your search

+1 -1
View File
@@ -31,7 +31,7 @@
| 组件 | 数据表 | 当前状态 |
|---|---|---|
| Object | `object_types` / `objects` | ✅ 已实现,含 title_property / subtitle_property / color / primary_key;`iri` 列存全球唯一标识;`axioms` 公理声明五类 / `parent_id` SubclassOf 类型继承 / `display_name_lang` 多语标签(2026-09-20) |
| Property | `properties` | ✅ 已实现,含 format / default_value / indexable / vector_index / backing_column;data_type 扩展 geoshape / geopoint / media / timeseries / timestamp / uri(绝对 URI 写入校验 + `xsd:anyURI` 导出);`iri` 列存全球唯一标识;`display_name_lang` 多语标签;子类型读路径合并祖先属性(标 `inherited=true`) |
| Property | `properties` | ✅ 已实现,含 format / default_value / indexable / vector_index / backing_column;data_type 扩展 geoshape / geopoint / media / timeseries / timestamp / uri(绝对 URI 写入校验 + `xsd:anyURI` 导出);`iri` 列存全球唯一标识;`display_name_lang` 多语标签;管理读路径子类型合并祖先属性(标 `inherited=true`;连接器/MCP `get_object_types` 视图仍按自身属性,写校验闭包对子实例生效) |
| Link | `link_types` / `links` | ✅ 已实现,含 directional;链接本身可带字段(link_properties 子表);`iri` 列存全球唯一标识;`display_name_lang` 多语标签;functionalLinks 公理对边写入生效 |
| Schema Version | `schema_versions` | ✅ 已实现,append-only 全局版本流水(schemaAudit 挂钩点即管理 API 五类 schema 增删改单调 +1;AI 摄取/合并清理等旁路写入暂不进流水,与 ontology_audit_log 同覆盖,PLAN.md 后续项),`details` 与 ontology_audit_log 同构含 before/after |
| Interface | `interface_types` | ✅ 已实现,含 shared_properties / parent_interface_id 多态;自动登记 6 个连接器接口 |
+2 -2
View File
@@ -23,8 +23,8 @@ AI 客户端在使用本平台过程中发现 bug 或有改进建议,**请提
**影响**:本体的"模型层声明式约束 + 完整元数据描述项"补齐——声明一次,跨 REST/MCP/批量写入路径统一守约;OWL 工具链可见。平台对标准 A 类通用方法的可声明覆盖面至此与闭合类型(§5.3)对齐:B 类标准领域实体不内置,SHACL/OWL2 推理不做,等价类合并查询不做。
**改动**:
- **公理声明**:`object_types.axioms JSONB` 五类(disjointWith / equivalentTo / functionalLinks / inverseOf / dateOrder),三层校验(形状 / schema 良构 / 实例/边写入);经 `applyObjectUpsert` / `createLink` / `batchCreateLinks` 在所有管理 API 写路径生效,`validate_axioms=false` 可豁免(与 `validate_enum` 同策略)。随 `/api/v1/ontology/export?format=turtle` 输出为 OWL 公理:`owl:disjointWith` / `owl:equivalentClass` / `owl:inverseOf` / `owl:FunctionalProperty`。`dateOrder` 是跨属性时序规则,OWL2 不可表达——运行期由 `validateDateOrder` 统一守约,不导出。
- **类型继承**:`object_types.parent_id` 声明 SubclassOf(GB/T 48000.3 §7.1.1 + 附录 A.1.6-7);读路径子类型合并祖先属性(同名自身覆盖,祖先来源标 `inherited=true`);`validateEnumProps` / `validateDateOrder` / `validateURIProps` / `validateFunctionalLink` 全部走 `typeClosure` 闭包,父类型声明对子实例一并生效。环校验 / 自指 / 父子互斥守卫在声明期拦截(本平台单亲继承 + 实例单类型下,disjointWith/equivalentTo 无实例层可达违例,以"声明 + 守卫 + OWL 导出"满足,GAP §5.3 不做推理边界)。Turtle 导出 `rdfs:subClassOf`。
- **公理声明**:`object_types.axioms JSONB` 五类(disjointWith / equivalentTo / functionalLinks / inverseOf / dateOrder),三层校验(形状 / schema 良构 / 实例/边写入);`dateOrder` / enum / uri 实例校验经 `applyObjectUpsert` 在管理 API 写路径生效,`validate_axioms=false` 可豁免(与 `validate_enum` 同策略);`functionalLinks` 边校验经 `createLink` / `batchCreateLinks` 生效,**无豁免**——声明即约束,撤回声明即解除。随 `/api/v1/ontology/export?format=turtle` 输出为 OWL 公理:`owl:disjointWith` / `owl:equivalentClass` / `owl:inverseOf` / `owl:FunctionalProperty`。`dateOrder` 是跨属性时序规则,OWL2 不可表达——运行期由 `validateDateOrder` 统一守约,不导出。
- **类型继承**:`object_types.parent_id` 声明 SubclassOf(GB/T 48000.3 §7.1.1 + 附录 A.1.6-7);管理读路径子类型合并祖先属性(同名自身覆盖,祖先来源标 `inherited=true`;连接器/MCP `get_object_types` 视图仍按自身属性,写校验闭包对子实例生效);`validateEnumProps` / `validateDateOrder` / `validateURIProps` / `validateFunctionalLink` 全部走 `typeClosure` 闭包,父类型声明对子实例一并生效。环校验 / 自指 / 父子互斥守卫在声明期拦截(本平台单亲继承 + 实例单类型下,disjointWith/equivalentTo 无实例层可达违例,以"声明 + 守卫 + OWL 导出"满足,GAP §5.3 不做推理边界)。Turtle 导出 `rdfs:subClassOf`。
- **多语标签**:三表 `display_name_lang JSONB`(GB/T 48000.3 §A.1.3),空 `{}` 回退旧 `display_name` 单语。Turtle 导出多语 `rdfs:label "value"@tag`(键排序保确定性);`display_name_lang` 入参按 BCP47 典型形式校验(主标签 2-3 字母;子标签须以大写字母开头,如 `zh-CN` / `zh-Hans`;`zh-cn` 等非法形式 400)。
- **URI 数据类型**(§A.3):`data_type` 增 `uri`;`validateURIProps` 写库校验绝对 URI(`http` / `https` / `mailto` / `urn` 等),`turtleRange('uri') = xsd:anyURI`。AI / MCP 词表同步补 `uri`。无 `validate_uri` 后门——与 `functionalLinks` 同策略(新 opt-in 类型无存量负担)。
- **覆盖面对齐**:公理/枚举/URI 写入校验挂在统一入口 `applyObjectUpsert`,边级公理/枚举挂在 `createLink`/`batchCreateLinks`。AI 自动摄取的 `ApplySuggestion` / KM 导入的 `upsertObject` / `restore_instance` / `seed` 走旁路 INSERT,与既有的 schemaAudit 覆盖范围一致——不通过该入口的写入不守约,文档化为已知局限(见 `docs/INSTANCE_GOVERNANCE.md` "公理与类型写入校验" 节)。
+50 -36
View File
@@ -308,6 +308,7 @@ func (a *app) loadEnumMap(ctx context.Context) map[string]map[string][]string {
// 第一段:拉声明了枚举的 own 属性(附 parent 名,顺手收集 parentOf)。
out := map[string]map[string][]string{}
parentOf := map[string]string{}
complete := true
rows, err := a.pool.Query(ctx,
`SELECT ot.api_name, p.api_name, COALESCE(p.enum_values,'[]'::jsonb),
COALESCE(pa.api_name,'')
@@ -316,42 +317,51 @@ func (a *app) loadEnumMap(ctx context.Context) map[string]map[string][]string {
LEFT JOIN object_types pa ON pa.id = ot.parent_id
WHERE jsonb_array_length(COALESCE(p.enum_values,'[]'::jsonb)) > 0`)
if err != nil {
classMu.Lock()
enumCache, enumAt = out, time.Now()
classMu.Unlock()
return out
}
for rows.Next() {
var t, p, parent string
var ev []byte
if err := rows.Scan(&t, &p, &ev, &parent); err != nil {
continue
}
vals := parseStringArray(ev)
if len(vals) == 0 {
continue
}
if out[t] == nil {
out[t] = map[string][]string{}
}
out[t][p] = vals
if parent != "" {
parentOf[t] = parent
}
}
rows.Close()
// 第二段:补全 parentOf。第一段只覆盖「自身声明了枚举属性」的类型;
// 有父但自身无枚举的子类型同样要进合并循环,否则继承不到父 enum(校验漏网)。
if prow, err := a.pool.Query(ctx,
`SELECT ot.api_name, pa.api_name
FROM object_types ot JOIN object_types pa ON pa.id = ot.parent_id`); err == nil {
for prow.Next() {
var t, pa string
if err := prow.Scan(&t, &pa); err == nil {
parentOf[t] = pa
complete = false
} else {
for rows.Next() {
var t, p, parent string
var ev []byte
if err := rows.Scan(&t, &p, &ev, &parent); err != nil {
complete = false
break
}
vals := parseStringArray(ev)
if len(vals) == 0 {
continue
}
if out[t] == nil {
out[t] = map[string][]string{}
}
out[t][p] = vals
if parent != "" {
parentOf[t] = parent
}
}
if rows.Err() != nil {
complete = false
}
rows.Close()
}
// 第二段:补全 parentOf。第一段只覆盖「自身声明了枚举属性」的类型;
// 有父但自身无枚举的子类型同样要进合并循环,否则继承不到父 enum(校验漏网)。
if prow, perr := a.pool.Query(ctx,
`SELECT ot.api_name, pa.api_name
FROM object_types ot JOIN object_types pa ON pa.id = ot.parent_id`); perr == nil {
for prow.Next() {
var t, pa string
if err := prow.Scan(&t, &pa); err != nil {
complete = false
break
}
parentOf[t] = pa
}
if prow.Err() != nil {
complete = false
}
prow.Close()
} else {
complete = false
}
// 闭包合并:对每个有父类型 t,沿 typeClosure([self, parent, ..., root]) 自近而远
// overlay 祖先 enum;仅填自身缺失的 key(子覆盖父、近祖覆盖远祖)。
@@ -374,9 +384,13 @@ func (a *app) loadEnumMap(ctx context.Context) map[string]map[string][]string {
}
}
}
classMu.Lock()
enumCache, enumAt = out, time.Now()
classMu.Unlock()
// 只在全量读取成功时标 fresh(与 loadTypeAxioms/loadURIProps 同策略):
// 失败的部分结果缓存 60s 会对所有写入方静默关闭 enum 校验(fail-open 跨请求)。
if complete {
classMu.Lock()
enumCache, enumAt = out, time.Now()
classMu.Unlock()
}
return out
}
+101 -1
View File
@@ -548,6 +548,21 @@ func TestIntegration_ParentSubclassOf(t *testing.T) {
map[string]any{"axioms": map[string]any{"disjointWith": []string{root}}}, h); code != 400 {
t.Errorf("父子互斥应 400, got %d", code)
}
// 父侧守卫(补子侧之外的洞):root 后来 PUT 涉及已有直系子 → 400
if code, _ := env.httpDo(t, "PUT", "/api/v1/ontology/object-types/"+root,
map[string]any{"axioms": map[string]any{"disjointWith": []string{child}}}, h); code != 400 {
t.Errorf("父侧 disjointWith 涉及子应 400, got %d", code)
}
// 父子等价双向:root equivalentTo:[child] → 400(坍缩层级)
if code, _ := env.httpDo(t, "PUT", "/api/v1/ontology/object-types/"+root,
map[string]any{"axioms": map[string]any{"equivalentTo": []string{child}}}, h); code != 400 {
t.Errorf("父侧 equivalentTo 涉及子应 400, got %d", code)
}
// 子侧等价:child equivalentTo:[root] → 400(与父侧对称)
if code, _ := env.httpDo(t, "PUT", "/api/v1/ontology/object-types/"+child,
map[string]any{"axioms": map[string]any{"equivalentTo": []string{root}}}, h); code != 400 {
t.Errorf("子侧 equivalentTo 涉及父应 400, got %d", code)
}
// 环:把 root 的 parent 设成 child → 400
if code, _ := env.httpDo(t, "PUT", "/api/v1/ontology/object-types/"+root,
map[string]any{"parent": child}, h); code != 400 {
@@ -657,6 +672,66 @@ func TestIntegration_ParentTriState_PreserveOnMissing(t *testing.T) {
}
}
// axioms 三态契约回归:PUT 不带 axioms 字段不应清空既有公理声明。
// 修复前 bug:updateObjectType 无条件绑定 axiomsUpdate="{}"(非 NULL),
// COALESCE($16::jsonb, axioms) 永不落回 → 任何 PUT(如仅改名)静默洗掉公理。
// 规约:不带/null → 保持;显式 {} → 清空。与 parent 三态同款问题。
func TestIntegration_AxiomsTriState_PreserveOnMissing(t *testing.T) {
env, _ := setupTestEnv(t)
h := map[string]string{"X-Principal": "manager"}
key, other := env.typeKey, env.typeKey+"_o"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/ontology/object-types/"+key, nil, h)
env.httpDo(t, "DELETE", "/api/v1/ontology/object-types/"+other, nil, h)
})
if code, _ := env.httpDo(t, "POST", "/api/v1/ontology/object-types",
map[string]any{"api_name": other, "display_name": "X"}, h); code != 201 {
t.Fatalf("create other: %d", code)
}
if code, _ := env.httpDo(t, "POST", "/api/v1/ontology/object-types",
map[string]any{"api_name": key, "display_name": "T",
"axioms": map[string]any{"disjointWith": []string{other}}}, h); code != 201 {
t.Fatalf("create T: %d", code)
}
axOf := func(body map[string]any) map[string]any {
ot, _ := body["object_type"].(map[string]any)
ax, _ := ot["axioms"].(map[string]any)
return ax
}
// 1) 创建后 GET 回显 disjointWith=[other]
_, got := env.httpDo(t, "GET", "/api/v1/ontology/object-types/"+key, nil, h)
if dw, _ := axOf(got)["disjointWith"].([]any); len(dw) != 1 || dw[0] != other {
t.Fatalf("初始 axioms 回显错: %v", axOf(got))
}
// 2) PUT 仅改名(不带 axioms)→ 200,公理必须保持
if code, _ := env.httpDo(t, "PUT", "/api/v1/ontology/object-types/"+key,
map[string]any{"display_name": "改名"}, h); code != 200 {
t.Fatalf("PUT 不带 axioms 应 200, got %d", code)
}
_, got2 := env.httpDo(t, "GET", "/api/v1/ontology/object-types/"+key, nil, h)
if dw, _ := axOf(got2)["disjointWith"].([]any); len(dw) != 1 || dw[0] != other {
t.Errorf("PUT 不带 axioms 却清空了公理: axioms=%v want disjointWith=[%s]", axOf(got2), other)
}
// 2b) 显式 null 同样保持(三态:不带/null=保持)
if code, _ := env.httpDo(t, "PUT", "/api/v1/ontology/object-types/"+key,
map[string]any{"axioms": nil, "description": "带 null"}, h); code != 200 {
t.Fatalf("PUT axioms=null 应 200, got %d", code)
}
_, gotNull := env.httpDo(t, "GET", "/api/v1/ontology/object-types/"+key, nil, h)
if dw, _ := axOf(gotNull)["disjointWith"].([]any); len(dw) != 1 {
t.Errorf("PUT axioms=null 应保持不变: axioms=%v", axOf(gotNull))
}
// 3) 显式 {} → 清空(回显 omitempty → 键缺席)
if code, _ := env.httpDo(t, "PUT", "/api/v1/ontology/object-types/"+key,
map[string]any{"axioms": map[string]any{}}, h); code != 200 {
t.Fatalf("PUT axioms={} 应 200, got %d", code)
}
_, got3 := env.httpDo(t, "GET", "/api/v1/ontology/object-types/"+key, nil, h)
if ax := axOf(got3); len(ax) != 0 {
t.Errorf("PUT axioms={} 应清空公理, got %v", ax)
}
}
// 父声明属性 + 枚举;子继承(读路径合并)+ enum 校验闭包生效。
func TestIntegration_PropertyInheritance(t *testing.T) {
env, _ := setupTestEnv(t)
@@ -666,10 +741,12 @@ func TestIntegration_PropertyInheritance(t *testing.T) {
env.httpDo(t, "DELETE", "/api/v1/ontology/object-types/"+child, nil, h)
env.httpDo(t, "DELETE", "/api/v1/ontology/object-types/"+root, nil, h)
})
// root 带枚举属性 role
// root 带枚举属性 role + 两个日期属性 p1/p2(供子类型 dateOrder 闭包声明测试)
if code, _ := env.httpDo(t, "POST", "/api/v1/ontology/object-types",
map[string]any{"api_name": root, "display_name": "R", "properties": []map[string]any{
{"api_name": "role", "display_name": "角色", "data_type": "enum", "enum_values": []string{"a", "b"}},
{"api_name": "p1", "display_name": "P1", "data_type": "date"},
{"api_name": "p2", "display_name": "P2", "data_type": "datetime"},
}}, h); code != 201 {
t.Fatalf("create root")
}
@@ -715,6 +792,29 @@ func TestIntegration_PropertyInheritance(t *testing.T) {
if code != 400 {
t.Errorf("子覆盖后 role=b 应被拒, got %d", code)
}
// dateOrder 声明按 SubclassOf 闭包解析:子类型直接对继承来的 date/datetime 属性
// 声明时序规则 → 200(旧行为只查自身,400 "未在本类型声明")。
if code, _ := env.httpDo(t, "PUT", "/api/v1/ontology/object-types/"+child,
map[string]any{"axioms": map[string]any{"dateOrder": []map[string]string{{"before": "p1", "after": "p2"}}}}, h); code != 200 {
t.Errorf("子对继承日期属性声明 dateOrder 应 200, got %d", code)
}
// 闭包内非 date 属性(role,子覆盖后仍在闭包中)仍按 data_type 拒绝
if code, _ := env.httpDo(t, "PUT", "/api/v1/ontology/object-types/"+child,
map[string]any{"axioms": map[string]any{"dateOrder": []map[string]string{{"before": "p1", "after": "role"}}}}, h); code != 400 {
t.Errorf("dateOrder 引用闭包内非日期属性应 400, got %d", code)
}
// 闭包外属性一律 400
if code, _ := env.httpDo(t, "PUT", "/api/v1/ontology/object-types/"+child,
map[string]any{"axioms": map[string]any{"dateOrder": []map[string]string{{"before": "p1", "after": "no_such"}}}}, h); code != 400 {
t.Errorf("dateOrder 引用闭包外属性应 400, got %d", code)
}
// 子实例写入同样受子声明的 dateOrder 约束(p1 晚于 p2 → 400)
if code, _ := env.httpDo(t, "POST", "/api/v1/objects",
map[string]any{"type": child, "pk": "d1", "properties": map[string]any{
"p1": "2026-06-01", "p2": "2026-05-01T00:00:00",
}}, h); code != 400 {
t.Errorf("子声明 dateOrder 对子实例应生效, got %d", code)
}
}
// createObjectType 必须失效 enum 缓存:若缺失,本测试第 4 步会读到第 2 步暖好的
+5 -1
View File
@@ -244,8 +244,11 @@ func (a *app) updateObjectType(c *gin.Context) {
}
}
// 公理形状校验(GB/T 48000.3-2026 §8.2):未知键/类型错误一律拒绝,避免拼写错误静默丢失。
// 三态契约(与 parent/display_name_lang 一致):不带 axioms 或显式 null → 保持既有声明
// (绑定 NULL,COALESCE($16::jsonb, axioms) 落回原列);显式 `{}`/解析后空集 → 清空(写 "{}");
// 非空 → 覆盖。早期实现把"不带"也当 "{}" 写回,PUT 其他字段会静默洗掉公理。
axiomsRaw := in.Axioms
axiomsUpdate := "{}"
var axiomsUpdate any // nil = 保持
var ax typeAxioms
axiomsPresent := len(axiomsRaw) > 0 && string(axiomsRaw) != "null"
if axiomsPresent {
@@ -259,6 +262,7 @@ func (a *app) updateObjectType(c *gin.Context) {
c.JSON(400, gin.H{"error": err.Error()})
return
}
axiomsUpdate = "{}"
if !ax.empty() {
axiomsUpdate = mustJSON(ax)
}
+19 -5
View File
@@ -505,7 +505,12 @@ func (a *app) mergeExecute(c *gin.Context) {
// 4) action_types 不带 target_type 字段 (target 存在 params jsonb), 跳过
// 5) 属性合并
rows, err := tx.Query(ctx, `SELECT api_name, display_name, data_type, required, enum_values, description FROM properties WHERE object_type_id=$1`, srcID)
// 列清单与 properties 表当前列手工同步:display_name_lang 是本轮新增列,不带上就是
// 本轮造成的丢数据,故补齐。format / default_value / sensitivity / backing_column 等
// 更早的列同样未携带 —— pre-existing 缺口(follow-up:改为 information_schema 动态列或
// INSERT ... SELECT 全列),本次不扩范围。
rows, err := tx.Query(ctx, `SELECT api_name, display_name, data_type, required, enum_values, description,
COALESCE(display_name_lang,'{}'::jsonb) FROM properties WHERE object_type_id=$1`, srcID)
if err != nil {
c.JSON(500, gin.H{"error": "查询源属性失败: " + err.Error()})
return
@@ -514,8 +519,8 @@ func (a *app) mergeExecute(c *gin.Context) {
for rows.Next() {
var apiN, dispN, dType, desc string
var required bool
var enumRaw []byte
if err := rows.Scan(&apiN, &dispN, &dType, &required, &enumRaw, &desc); err != nil {
var enumRaw, dispLangRaw []byte
if err := rows.Scan(&apiN, &dispN, &dType, &required, &enumRaw, &desc, &dispLangRaw); err != nil {
continue
}
var exists bool
@@ -523,8 +528,8 @@ func (a *app) mergeExecute(c *gin.Context) {
if exists {
continue
}
if _, err := tx.Exec(ctx, `INSERT INTO properties(object_type_id, api_name, display_name, data_type, required, enum_values, description)
VALUES($1,$2,$3,$4,$5,$6,$7)`, targetID, apiN, dispN, dType, required, enumRaw, desc); err != nil {
if _, err := tx.Exec(ctx, `INSERT INTO properties(object_type_id, api_name, display_name, data_type, required, enum_values, description, display_name_lang)
VALUES($1,$2,$3,$4,$5,$6,$7,COALESCE($8::jsonb,'{}'::jsonb))`, targetID, apiN, dispN, dType, required, enumRaw, desc, dispLangRaw); err != nil {
log.Printf("[cleanup] 属性 %s 插入失败: %v", apiN, err)
} else {
inserts++
@@ -552,6 +557,10 @@ func (a *app) mergeExecute(c *gin.Context) {
}
committed = true
// 合并改动了 schema(源类型删除 + 属性搬移):失效 class/enum/axioms/uri 四层缓存,
// 否则源类型上的公理/枚举声明在 TTL(60s)内仍被写入校验按陈旧命中执行。
invalidateClassCache()
// 属性搬移走旁路 INSERT(不带 iri),提交后治愈空值;失败仅记日志,不影响合并结果
if err := backfillMissingIRI(ctx, a.pool); err != nil {
log.Printf("[cleanup] merge 后 iri 回填失败: %v", err)
@@ -594,6 +603,11 @@ func (a *app) deleteZeroInstTypes(c *gin.Context) {
}
}
// 有类型被删(可能带 parent_id/公理/属性)→ 失效四层缓存,与 deleteObjectType 对齐。
if len(deleted) > 0 {
invalidateClassCache()
}
a.writeAudit(ctx, c, "delete_zero_inst", "", map[string]any{"deleted": deleted}, len(deleted))
c.JSON(200, gin.H{"ok": true, "deleted": deleted})
}
+2 -1
View File
@@ -720,7 +720,8 @@ func (a *app) batchCreateLinks(c *gin.Context) {
// 走 tx(同事务读已落库的先前条);不设 validate_axioms 后门。
if err := a.validateFunctionalLink(c, tx, it.Type, it.SourceType, it.SourcePK, it.TargetType, it.TargetPK); err != nil {
failed++
results = append(results, itemOut{Index: i, Type: it.Type, Status: "failed", Error: "functional_violation: " + err.Error()})
// err 文本自带 "functional_violation: " 前缀(与 createLink 单前缀一致),不再叠加。
results = append(results, itemOut{Index: i, Type: it.Type, Status: "failed", Error: err.Error()})
if in.StopOnError {
c.JSON(400, gin.H{"error": fmt.Sprintf("第 %d 条公理违例,已回滚", i), "results": results})
return
+88 -18
View File
@@ -10,9 +10,12 @@ import (
// validateAxiomsWellFormed 公理声明的 schema 级良构校验。
// 拦截点:createObjectType / updateObjectType 写入口,任一不合法 → 400。
// 涉及闭包(versionClosure)的规则(父子互斥等)由类型继承任务(任务 7)补全。
//
// M4:dateOrder 引用的属性只查 self 自身;任务 8(属性继承)接入后升级为闭包。
// 父子互斥/等价守卫是双向的:子侧由 checkParentDisjoint(设父/带公理建子路径)负责,
// 父侧由本函数负责(更新 axioms 时反查直接子类型,防止父后来 PUT 绕过守卫)。
//
// dateOrder 引用的属性沿 SubclassOf 闭包解析(自身优先,就近者胜)——
// 子类型可直接对继承来的 date/datetime 属性声明时序规则。
func (a *app) validateAxiomsWellFormed(ctx context.Context, selfName string, ax typeAxioms) error {
if ax.empty() {
return nil
@@ -51,6 +54,36 @@ func (a *app) validateAxiomsWellFormed(ctx context.Context, selfName string, ax
return fmt.Errorf("axioms.equivalentTo: 类型 %q 不存在", n)
}
}
// 父侧守卫:本类型的 disjointWith/equivalentTo 不得涉及自己的直接子类型。
// 子实例必然属于父(subClassOf),互斥声明必致每个子实例违例;等价声明则令层级坍缩。
// 子侧声明由 checkParentDisjoint 覆盖,此处补"父后来 PUT 涉及已有子"的路径。
if selfName != "" && (len(ax.DisjointWith) > 0 || len(ax.EquivalentTo) > 0) {
crows, err := a.pool.Query(ctx,
`SELECT api_name FROM object_types WHERE parent_id=(SELECT id FROM object_types WHERE api_name=$1)`,
selfName)
if err != nil {
return fmt.Errorf("axioms: 查询直接子类型失败: %w", err)
}
childConflict := ""
for crows.Next() {
var child string
if err := crows.Scan(&child); err != nil {
continue
}
if containsString(ax.DisjointWith, child) {
childConflict = fmt.Sprintf("axioms.disjointWith: %q 是 %q 的直接子类型,父子不可互斥(每个子实例必违例)", child, selfName)
break
}
if containsString(ax.EquivalentTo, child) {
childConflict = fmt.Sprintf("axioms.equivalentTo: %q 是 %q 的直接子类型,父子等价会坍缩 SubclassOf 层级", child, selfName)
break
}
}
crows.Close()
if childConflict != "" {
return fmt.Errorf("%s", childConflict)
}
}
for _, n := range ax.FunctionalLinks {
_, src, _, ok := linkOf(n)
if !ok {
@@ -73,14 +106,27 @@ func (a *app) validateAxiomsWellFormed(ctx context.Context, selfName string, ax
return fmt.Errorf("axioms.inverseOf: %q(%s→%s) 与 %q(%s→%s) 定义域/值域不互换", a, srcA, tgtA, b, srcB, tgtB)
}
}
// 属性解析沿 SubclassOf 闭包(typeClosure 返回 自身→根 序,首个命中即就近者胜,
// 同名属性自身覆盖祖先),子类型可对继承的 date/datetime 属性声明 dateOrder。
var closure []string
if len(ax.DateOrder) > 0 {
closure = a.typeClosure(ctx, selfName)
}
for _, r := range ax.DateOrder {
if r.Before == "" || r.After == "" {
return fmt.Errorf("axioms.dateOrder: before/after 属性名必填")
}
for _, p := range []string{r.Before, r.After} {
dt, ok := propDataType(selfName, p)
if !ok {
return fmt.Errorf("axioms.dateOrder: 属性 %q 未在本类型声明", p)
var dt string
found := false
for _, t := range closure {
if v, ok := propDataType(t, p); ok {
dt, found = v, true
break
}
}
if !found {
return fmt.Errorf("axioms.dateOrder: 属性 %q 未在本类型或其祖先声明", p)
}
if dt != "date" && dt != "datetime" {
return fmt.Errorf("axioms.dateOrder: 属性 %q data_type=%q 需为 date/datetime", p, dt)
@@ -103,8 +149,10 @@ func sortedStringPairs(m map[string]string) [][2]string {
// ---------- 实例写入校验(dateOrder,GB/T 48000.3-2026 §8.2)----------
// 类型公理缓存(TTL 与 classCacheTTL 一致)。失效由 invalidateClassCache() 统一负责。
// 锁直接用 classMu:classCache/enumCache/axiomsCache/uriCache 四层共用同一把 RWMutex,
// invalidateClassCache 一次重置四个时间戳才原子;复制一把锁(= classMu 赋值)会得到
// 两把互不相干的锁,失效与装载竞态导致丢失效(go vet copylocks 即拦这个)。
var (
axiomsMu = classMu
axiomsCache map[string]typeAxioms
axiomsAt time.Time
)
@@ -112,34 +160,47 @@ var (
// loadTypeAxioms 一次性拉所有 object_types 的 axioms JSONB,过滤空集后缓存。
// 仅缓存解析后非空集合;空集留给 typeClosure 那条分支直接跳过。
func (a *app) loadTypeAxioms(ctx context.Context) map[string]typeAxioms {
axiomsMu.RLock()
classMu.RLock()
if time.Since(axiomsAt) < classCacheTTL && axiomsCache != nil {
m := axiomsCache
axiomsMu.RUnlock()
classMu.RUnlock()
return m
}
axiomsMu.RUnlock()
classMu.RUnlock()
out := map[string]typeAxioms{}
if rows, err := a.pool.Query(ctx,
`SELECT api_name, COALESCE(axioms,'{}'::jsonb) FROM object_types`); err == nil {
complete := true
rows, err := a.pool.Query(ctx,
`SELECT api_name, COALESCE(axioms,'{}'::jsonb) FROM object_types`)
if err != nil {
complete = false
} else {
for rows.Next() {
var name string
var b []byte
if err := rows.Scan(&name, &b); err != nil {
continue
complete = false
break
}
ax, err := parseAxioms(b)
if err != nil || ax.empty() {
ax, perr := parseAxioms(b)
if perr != nil || ax.empty() {
continue
}
out[name] = ax
}
if rows.Err() != nil {
complete = false
}
rows.Close()
}
axiomsMu.Lock()
axiomsCache, axiomsAt = out, time.Now()
axiomsMu.Unlock()
// 只在全量读取成功时把结果标为 fresh:Query 失败/ctx 中途取消留下的空或部分
// 结果集若也缓存,会在 TTL(60s)内对所有写入方静默关闭公理校验(fail-open 跨请求)。
// 失败时照常返回本次结果(调用方按缺失=无公理处理),下一个调用方重试装载。
if complete {
classMu.Lock()
axiomsCache, axiomsAt = out, time.Now()
classMu.Unlock()
}
return out
}
@@ -184,6 +245,9 @@ func (a *app) resolveParentID(ctx context.Context, name string) (*int64, error)
// checkParentCycle parent 链上行是否撞到 selfID(更新路径用);同时清空父 P 的 axioms.
// DisjointWith 与 self 互斥的检查(每个子实例必违例,父不可能为互斥对)。
//
// 尽力而为:检查与写入之间无强一致(非同一事务/无锁),并发窗口内父子可能双双通过守卫;
// 声明式守约以撤回声明即可解除,不做跨请求串行化。
func (a *app) checkParentCycle(ctx context.Context, selfAPI string, selfID int64, parentID int64) error {
cur := parentID
for i := 0; i < 32; i++ {
@@ -202,11 +266,16 @@ func (a *app) checkParentCycle(ctx context.Context, selfAPI string, selfID int64
return fmt.Errorf("parent 链超深(>32),疑似脏数据环")
}
// checkParentDisjoint 父子互斥守卫:任一方向声明的 disjointWith 涉及对方 = 拒。
// checkParentDisjoint 父子互斥/等价守卫(子侧,设父与带公理建子/改公理路径):
// 任一方向声明的 disjointWith 涉及对方 = 拒;equivalentTo 同理(父子等价坍缩层级,
// 与 validateAxiomsWellFormed 的父侧反查互补)。
func (a *app) checkParentDisjoint(ctx context.Context, selfAPI string, selfAx typeAxioms, parentAPI string, parentAx typeAxioms) error {
if containsString(selfAx.DisjointWith, parentAPI) || containsString(parentAx.DisjointWith, selfAPI) {
return fmt.Errorf("parent(%s) 与 child(%s) 不可互斥(每个子实例必违例)", parentAPI, selfAPI)
}
if containsString(selfAx.EquivalentTo, parentAPI) || containsString(parentAx.EquivalentTo, selfAPI) {
return fmt.Errorf("parent(%s) 与 child(%s) 不可等价(会坍缩 SubclassOf 层级)", parentAPI, selfAPI)
}
return nil
}
@@ -223,6 +292,7 @@ func containsString(list []string, v string) bool {
// validateFunctionalLink 边写入校验:链接 L 在 source 类型闭包内某类型的 functionalLinks 中
// 声明 → 同一 source 现有 L 出边指向不同 target = 违例。同 target 重设允许。
// 不设 validate_axioms 后门:功能公理是类型属主自声明,撤销声明即解除,新边校验无历史包袱。
// 尽力而为:count 检查与 INSERT 之间无强一致,并发窗口内两条边可能双双通过;撤销声明即解除约束。
func (a *app) validateFunctionalLink(ctx context.Context, db dbExec, linkType, srcType, srcPK, tgtType, tgtPK string) error {
for _, t := range a.typeClosure(ctx, srcType) {
if !containsString(a.axiomsOf(ctx, t).FunctionalLinks, linkType) {
+36 -15
View File
@@ -12,51 +12,68 @@ import (
// URI 数据类型(GB/T 48000.3-2026 附录 A.3):写入校验绝对 URI;xsd:anyURI 导出;
// 与 enum 校验同面 applyObjectUpsert、同缓存模式(classMu + TTL)。
// 锁直接用 classMu(与 classCache/enumCache/axiomsCache 同一把,失效原子);
// 复制 classMu 得到的是另一把锁,会与 invalidateClassCache 竞态(go vet copylocks)。
var (
uriMu = classMu
uriCache map[string]map[string]bool
uriAt time.Time
)
// loadURIProps 类型 → 闭包合并后 uri 属性集。
// 闭包合并策略:查 parent 关系 → 逐类型 typeClosure 根→自身 overlay(子覆盖父同名)。
// 闭包合并策略:查 parent 关系 → 逐类型 typeClosure(自身→根序)自远及近 overlay(子覆盖父同名)。
func (a *app) loadURIProps(ctx context.Context) map[string]map[string]bool {
uriMu.RLock()
classMu.RLock()
if time.Since(uriAt) < classCacheTTL && uriCache != nil {
m := uriCache
uriMu.RUnlock()
classMu.RUnlock()
return m
}
uriMu.RUnlock()
classMu.RUnlock()
out := map[string]map[string]bool{}
if rows, err := a.pool.Query(ctx,
complete := true
rows, err := a.pool.Query(ctx,
`SELECT ot.api_name, p.api_name FROM properties p
JOIN object_types ot ON ot.id=p.object_type_id
WHERE p.data_type='uri'`); err == nil {
WHERE p.data_type='uri'`)
if err != nil {
complete = false
} else {
for rows.Next() {
var t, p string
if err := rows.Scan(&t, &p); err != nil {
continue
complete = false
break
}
if out[t] == nil {
out[t] = map[string]bool{}
}
out[t][p] = true
}
if rows.Err() != nil {
complete = false
}
rows.Close()
}
// parentOf 单独一段拉全量父子对:「有父但自身无 uri 属性」的子类型同样要进合并循环,
// 否则继承不到父 uri 校验(与 loadEnumMap 第二段同策略)。
parentOf := map[string]string{}
if prow, err := a.pool.Query(ctx,
prow, perr := a.pool.Query(ctx,
`SELECT ot.api_name, pa.api_name
FROM object_types ot JOIN object_types pa ON pa.id = ot.parent_id`); err == nil {
FROM object_types ot JOIN object_types pa ON pa.id = ot.parent_id`)
if perr != nil {
complete = false
} else {
for prow.Next() {
var t, pa string
if err := prow.Scan(&t, &pa); err == nil {
parentOf[t] = pa
if err := prow.Scan(&t, &pa); err != nil {
complete = false
break
}
parentOf[t] = pa
}
if prow.Err() != nil {
complete = false
}
prow.Close()
}
@@ -75,9 +92,13 @@ func (a *app) loadURIProps(ctx context.Context) map[string]map[string]bool {
}
}
}
uriMu.Lock()
uriCache, uriAt = out, time.Now()
uriMu.Unlock()
// 只在全量读取成功时标 fresh:失败/ctx 取消的部分结果缓存 60s 会对所有写入方
// 静默关闭 uri 校验(fail-open 跨请求);失败时照常返回,下一个调用方重试装载。
if complete {
classMu.Lock()
uriCache, uriAt = out, time.Now()
classMu.Unlock()
}
return out
}