From cbb3a76760ff271df12fe41cb03befbae53aa08e Mon Sep 17 00:00:00 2001 From: admin Date: Sun, 20 Sep 2026 22:10:02 +0800 Subject: [PATCH] =?UTF-8?q?fix(ontology):=20=E7=BB=88=E5=AE=A1=E4=BF=AE?= =?UTF-8?q?=E5=A4=8D=E2=80=94=E2=80=94axioms=20PUT=20=E4=B8=89=E6=80=81?= =?UTF-8?q?=E4=BF=9D=E6=8C=81=20+=20=E7=BC=93=E5=AD=98=E9=94=81=E7=BB=9F?= =?UTF-8?q?=E4=B8=80(classMu)+=E5=A4=B1=E6=95=88=E9=98=B2=E6=B1=A1?= =?UTF-8?q?=E6=9F=93+dateOrder=20=E9=97=AD=E5=8C=85=E5=A3=B0=E6=98=8E+merg?= =?UTF-8?q?e=20=E7=BC=93=E5=AD=98=E5=A4=B1=E6=95=88+=E7=88=B6=E5=AD=90?= =?UTF-8?q?=E4=BA=92=E6=96=A5=E8=A1=A5=E9=BD=90+=E6=96=87=E6=A1=A3?= =?UTF-8?q?=E6=8E=AA=E8=BE=9E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 4.8 --- docs/README.md | 2 +- server/CHANGELOG.md | 4 +- server/classification.go | 86 ++++++++++++---------- server/gb48000_absorb_test.go | 102 +++++++++++++++++++++++++- server/handlers_ontology.go | 6 +- server/handlers_ontology_cleanup.go | 24 +++++-- server/instance_governance.go | 3 +- server/ontology_axioms_check.go | 106 +++++++++++++++++++++++----- server/property_uri_check.go | 51 +++++++++---- 9 files changed, 304 insertions(+), 80 deletions(-) diff --git a/docs/README.md b/docs/README.md index e102207..6250a56 100644 --- a/docs/README.md +++ b/docs/README.md @@ -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 个连接器接口 | diff --git a/server/CHANGELOG.md b/server/CHANGELOG.md index 3a3ed3f..0021b10 100644 --- a/server/CHANGELOG.md +++ b/server/CHANGELOG.md @@ -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` "公理与类型写入校验" 节)。 diff --git a/server/classification.go b/server/classification.go index 34d7a27..3130f10 100644 --- a/server/classification.go +++ b/server/classification.go @@ -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 } diff --git a/server/gb48000_absorb_test.go b/server/gb48000_absorb_test.go index 7d49303..d9b9a59 100644 --- a/server/gb48000_absorb_test.go +++ b/server/gb48000_absorb_test.go @@ -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 步暖好的 diff --git a/server/handlers_ontology.go b/server/handlers_ontology.go index 45a38b8..23439c2 100644 --- a/server/handlers_ontology.go +++ b/server/handlers_ontology.go @@ -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) } diff --git a/server/handlers_ontology_cleanup.go b/server/handlers_ontology_cleanup.go index 48005f2..77f5e30 100644 --- a/server/handlers_ontology_cleanup.go +++ b/server/handlers_ontology_cleanup.go @@ -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}) } diff --git a/server/instance_governance.go b/server/instance_governance.go index 0a60c6d..ff65669 100644 --- a/server/instance_governance.go +++ b/server/instance_governance.go @@ -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 diff --git a/server/ontology_axioms_check.go b/server/ontology_axioms_check.go index 1d0f89c..5492394 100644 --- a/server/ontology_axioms_check.go +++ b/server/ontology_axioms_check.go @@ -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) { diff --git a/server/property_uri_check.go b/server/property_uri_check.go index 811f24c..e7a311f 100644 --- a/server/property_uri_check.go +++ b/server/property_uri_check.go @@ -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 }