Skip to content

World's first open-source enterprise world model.

37.8 KB
Raw Blame
-- 出处链不许跨库。
--
-- 引用完整性只保证「指着的行存在」,不保证「指着的东西在同一个库」。导出把
-- 引用对象的 id 铸进**本库**的 IRI(urn:utopia:kb:A:fact:{B 库的事实}),
-- 一份看着完整、实则指着不存在之物的文件就这么出去了;而能被导出器解析的
-- 引用(谓词、属性类型、实体类型、父类、domain/range)落到别库时更安静——
-- 查表落空,那一截语义**不声不响地消失**。
--
-- 所以不变量是一条,不是一条边:**出处与归属语义上的每一个引用,两端必须
-- 同属一个库。** 实现按「这条边的库归属谁来作证」分两层:
--
--   §1b 声明式(26 条边):引用行**自己带 kb_id**,且以它为准——复合外键
--        `(kb_id, ref_id) REFERENCES target (kb_id, id)` 把「存在且同库」合成
--        一条约束。RI 检查在内核层跑,比行级 PL/pgSQL 调用便宜;`session_
--        replication_role = replica` 的批量装载(pg_restore --disable-triggers
--        的形状)也绕不过它——那一层用户触发器全体静默,约束触发器照查。
--        同表自指(supersedes / from_statement_id / inverse_of /
--        sub_property_of)用 `DEFERRABLE INITIALLY DEFERRED`:目标行可能在本
--        语句之后才落盘,**提交边界**重估时整批都在——顺带替掉了原先的递延
--        约束触发器。inverse_of / sub_property_of 的 ON DELETE SET NULL 带
--        列清单(`SET NULL (inverse_of)`,PG15+):复合键的 SET NULL 会把
--        kb_id 一起置空,必须限定到引用列。
--   §1c 触发器(13 条边):库归属**不在引用行自己手上**的边——
--        fact_evidence / fact_qualifiers / typed_fact_sources /
--        statement_qualifiers 跟所属 fact 的库,fact_derivations 跟派生事实的
--        库,entity_type_parents 跟子类的库,relation_type_domains/_ranges/
--        _qualifiers 跟关系的库,attribute_rule_conditions 跟规则的库。这些行
--        没有 kb_id 列;加一列反正规化的 kb_id 让复合外键够得着,等于造出第二
--        条「列值必须等于父行 kb_id」的不变量再拿触发器去守它——用触发器直接
--        查父行的库,比那份冗余+同步便宜。
--
-- 所有者逐条列出(★ = 声明式,○ = 触发器):
--
--   所有者行          引用列 → 被引表
--   fact_evidence     ○ chunk_id → chunks · ○ document_id → documents
--                     (以所属 fact 的 kb 为准)
--   chunks            ★ document_id → documents(以 chunk 自己的 kb_id 为准)
--   fact_derivations  ○ premise_fact_id → facts · ○ premise_derived_id →
--                     derived_facts(以 derived_fact 的 kb 为准)
--   fact_qualifiers   ○ qualifier_type_id → relation_types · ○ entity_id →
--                     entities(以所属 fact 的 kb 为准)
--   facts             ★ subject_id/object_id → entities · ★ predicate_id →
--                     relation_types · ★ supersedes/from_statement_id → facts
--                     (同表自指,递延)
--   derived_facts     ★ subject_id/object_id → entities · ★ predicate_id →
--                     relation_types · ★ rule_id → rules · ★ attribute_rule_id →
--                     attribute_rules
--   entities          ★ type_id → entity_types
--   entity_type_parents ○ parent_id → entity_types(以 child 的 kb 为准)
--   entity_type_disjoint ★ a_id/b_id → entity_types(以行自己的 kb_id 为准)
--   relation_type_domains / _ranges  ○ entity_type_id → entity_types
--                     (以 relation 的 kb 为准)
--   relation_type_qualifiers  ○ qualifier_type_id → relation_types
--                     (以 relation 的 kb 为准)
--   relation_types    ★ inverse_of / sub_property_of → relation_types
--                     (同表自指,递延)
--   rules             ★ predicate_id → relation_types
--   attribute_rules   ★ subject_type_id / conclude_type_id → entity_types ·
--                     ★ conclude_predicate_id → relation_types
--   attribute_rule_conditions  ○ predicate_id → relation_types
--                     (归属按**所属规则**的库判——条件行自己没有 kb 列。
--                     rule_id → attribute_rules 是普通外键:不存在的规则
--                     装不进来,规则删了条件跟着删)
--   typed_fact_sources  ○ statement_id → facts(以所属 fact 的 kb 为准)
--   statement_qualifiers  ○ entity_id → entities(以所属 fact 的 kb 为准)
--   time_mentions     ★ fact_id → facts · ★ chunk_id → chunks
--                     (以行自己的 kb_id 为准)
--   type_bindings     ★ type_id → entity_types(以行自己的 kb_id 为准)
--   phrase_bindings   ★ subject_type_id / object_type_id → entity_types ·
--                     ★ relation_type_id → relation_types(以行自己的 kb_id 为准)
--
-- 例外:attribute_rules.conclude_expr 与算式 operand 里 `attr` 叶子嵌着的
-- 谓词引用。jsonb 列装不下外键,行级触发器去逐棵 JSON 树拆,等于把求值侧
-- 的表达式语法再抄一遍——这类引用的执行层是**导出侧校验**(export.rs:
-- 取数时按库挡、序列化时按词汇表解析,越库/悬空/连 uuid 都解析不出的
-- 一律拒导)。本迁移管的是列级引用。
--
-- 三层防线,各管一段:
--   §0 前置检查  —— 迁移本身先数一遍存量:库里已有越界行就**整体中止**,
--                  报出是哪条边、坏了几行。装上不变量却对已违反它的账本报喜,
--                  等于替坏数据背书。不修数据的人不该拿到「迁移成功」。
--                  这段查询同时是**运维审计**:升级前拿它在真实库上跑一遍,
--                  就知道这次升级会不会在半截停下。
--   §1 复合外键 + 触发器 —— 挡在一切写入路径的下游(原生 API、手写 SQL、
--                  还没写出来的那些路径)。复合键同时管住「改引用列」与「改
--                  kb_id 过户」(被引行的 kb_id 动了,键就悬空)。
--   §2 kb 不可过户 —— 把已被引用的行挪到别的库,等于把指着它的行一次全变
--                  坏行。复合外键只护住**被指着**的行;§1c 那些跟父行库走的
--                  边,父行 kb 一动就脱锚——所以不可过户是全量保留的。
--
-- §1c 的函数体全部**限定到 public schema 且钉死 search_path**:pg_restore 会
-- 把会话 search_path 置空再灌数据,裸表名在那里解析不到任何东西——数据恢复
-- 会炸在半截,留下一个说不清的残库。正确性不许依赖环境。
-- 同一个理由,本文件的 DDL 标识符也一律 `public.*` 限定:迁移在
-- `SET search_path=''` 或首位被恶意 schema 占住的会话里跑,都不能把函数、
-- 触发器和约束建错地方——一个落在别处的约束等于没有约束。
--
-- 触发器与复合外键只管落在它们之后的写;存量坏行由 §0 挡在迁移门口,由导出
-- 侧的体检(provenance_integrity)与逐页校验拦在序列化之前。

-- =====================================================================
-- §0 前置检查:存量越界行 → 整份中止
-- =====================================================================
DO $$
DECLARE
    report text;
BEGIN
    SELECT string_agg(edge || ' x' || n, '; ' ORDER BY edge) INTO report
      FROM (
        SELECT edge, COUNT(*) AS n FROM (
            SELECT 'evidence.chunk' AS edge, f.kb_id AS owner_kb, c.kb_id AS ref_kb
              FROM public.fact_evidence e
              JOIN public.facts f ON f.id = e.fact_id
              LEFT JOIN public.chunks c ON c.id = e.chunk_id
            UNION ALL
            SELECT 'evidence.document', f.kb_id, d.kb_id
              FROM public.fact_evidence e
              JOIN public.facts f ON f.id = e.fact_id
              LEFT JOIN public.documents d ON d.id = e.document_id
             WHERE e.document_id IS NOT NULL
            UNION ALL
            SELECT 'chunk.document', c.kb_id, d.kb_id
              FROM public.chunks c
              LEFT JOIN public.documents d ON d.id = c.document_id
            UNION ALL
            SELECT 'derivation.premise_fact', d.kb_id, p.kb_id
              FROM public.fact_derivations fd
              JOIN public.derived_facts d ON d.id = fd.derived_fact_id
              LEFT JOIN public.facts p ON p.id = fd.premise_fact_id
             WHERE fd.premise_fact_id IS NOT NULL
            UNION ALL
            SELECT 'derivation.premise_derived', d.kb_id, p.kb_id
              FROM public.fact_derivations fd
              JOIN public.derived_facts d ON d.id = fd.derived_fact_id
              LEFT JOIN public.derived_facts p ON p.id = fd.premise_derived_id
             WHERE fd.premise_derived_id IS NOT NULL
            UNION ALL
            SELECT 'qualifier.type', f.kb_id, r.kb_id
              FROM public.fact_qualifiers q
              JOIN public.facts f ON f.id = q.fact_id
              LEFT JOIN public.relation_types r ON r.id = q.qualifier_type_id
            UNION ALL
            SELECT 'qualifier.entity', f.kb_id, e.kb_id
              FROM public.fact_qualifiers q
              JOIN public.facts f ON f.id = q.fact_id
              LEFT JOIN public.entities e ON e.id = q.entity_id
             WHERE q.entity_id IS NOT NULL
            UNION ALL
            SELECT 'fact.subject', f.kb_id, s.kb_id
              FROM public.facts f
              LEFT JOIN public.entities s ON s.id = f.subject_id
            UNION ALL
            SELECT 'fact.object', f.kb_id, o.kb_id
              FROM public.facts f
              LEFT JOIN public.entities o ON o.id = f.object_id
             WHERE f.object_id IS NOT NULL
            UNION ALL
            SELECT 'fact.predicate', f.kb_id, r.kb_id
              FROM public.facts f
              LEFT JOIN public.relation_types r ON r.id = f.predicate_id
             WHERE f.predicate_id IS NOT NULL
            UNION ALL
            SELECT 'fact.supersedes', f.kb_id, s.kb_id
              FROM public.facts f
              LEFT JOIN public.facts s ON s.id = f.supersedes
             WHERE f.supersedes IS NOT NULL
            UNION ALL
            SELECT 'fact.from_statement', f.kb_id, s.kb_id
              FROM public.facts f
              LEFT JOIN public.facts s ON s.id = f.from_statement_id
             WHERE f.from_statement_id IS NOT NULL
            UNION ALL
            SELECT 'derived.subject', d.kb_id, s.kb_id
              FROM public.derived_facts d
              LEFT JOIN public.entities s ON s.id = d.subject_id
            UNION ALL
            SELECT 'derived.object', d.kb_id, o.kb_id
              FROM public.derived_facts d
              LEFT JOIN public.entities o ON o.id = d.object_id
             WHERE d.object_id IS NOT NULL
            UNION ALL
            SELECT 'derived.predicate', d.kb_id, r.kb_id
              FROM public.derived_facts d
              LEFT JOIN public.relation_types r ON r.id = d.predicate_id
            UNION ALL
            SELECT 'derived.rule', d.kb_id, r.kb_id
              FROM public.derived_facts d
              LEFT JOIN public.rules r ON r.id = d.rule_id
             WHERE d.rule_id IS NOT NULL
            UNION ALL
            SELECT 'derived.attribute_rule', d.kb_id, r.kb_id
              FROM public.derived_facts d
              LEFT JOIN public.attribute_rules r ON r.id = d.attribute_rule_id
             WHERE d.attribute_rule_id IS NOT NULL
            UNION ALL
            SELECT 'entity.type', e.kb_id, t.kb_id
              FROM public.entities e
              LEFT JOIN public.entity_types t ON t.id = e.type_id
             WHERE e.type_id IS NOT NULL
            UNION ALL
            SELECT 'class.parent', c.kb_id, p.kb_id
              FROM public.entity_type_parents x
              JOIN public.entity_types c ON c.id = x.child_id
              LEFT JOIN public.entity_types p ON p.id = x.parent_id
            UNION ALL
            SELECT 'class.disjoint', dd.kb_id, a.kb_id
              FROM public.entity_type_disjoint dd
              LEFT JOIN public.entity_types a ON a.id = dd.a_id
            UNION ALL
            SELECT 'class.disjoint', dd.kb_id, b.kb_id
              FROM public.entity_type_disjoint dd
              LEFT JOIN public.entity_types b ON b.id = dd.b_id
            UNION ALL
            SELECT 'relation.domain', r.kb_id, t.kb_id
              FROM public.relation_type_domains x
              JOIN public.relation_types r ON r.id = x.relation_type_id
              LEFT JOIN public.entity_types t ON t.id = x.entity_type_id
            UNION ALL
            SELECT 'relation.range', r.kb_id, t.kb_id
              FROM public.relation_type_ranges x
              JOIN public.relation_types r ON r.id = x.relation_type_id
              LEFT JOIN public.entity_types t ON t.id = x.entity_type_id
            UNION ALL
            SELECT 'relation.qualifier', r.kb_id, q.kb_id
              FROM public.relation_type_qualifiers x
              JOIN public.relation_types r ON r.id = x.relation_type_id
              LEFT JOIN public.relation_types q ON q.id = x.qualifier_type_id
            UNION ALL
            SELECT 'relation.inverse', r.kb_id, t.kb_id
              FROM public.relation_types r
              LEFT JOIN public.relation_types t ON t.id = r.inverse_of
             WHERE r.inverse_of IS NOT NULL
            UNION ALL
            SELECT 'relation.sub_property', r.kb_id, t.kb_id
              FROM public.relation_types r
              LEFT JOIN public.relation_types t ON t.id = r.sub_property_of
             WHERE r.sub_property_of IS NOT NULL
            UNION ALL
            SELECT 'rule.predicate', u.kb_id, p.kb_id
              FROM public.rules u
              LEFT JOIN public.relation_types p ON p.id = u.predicate_id
            UNION ALL
            SELECT 'arule.subject_type', a.kb_id, t.kb_id
              FROM public.attribute_rules a
              LEFT JOIN public.entity_types t ON t.id = a.subject_type_id
            UNION ALL
            SELECT 'arule.conclude_type', a.kb_id, t.kb_id
              FROM public.attribute_rules a
              LEFT JOIN public.entity_types t ON t.id = a.conclude_type_id
             WHERE a.conclude_type_id IS NOT NULL
            UNION ALL
            SELECT 'arule.conclude_predicate', a.kb_id, p.kb_id
              FROM public.attribute_rules a
              LEFT JOIN public.relation_types p ON p.id = a.conclude_predicate_id
             WHERE a.conclude_predicate_id IS NOT NULL
            UNION ALL
            -- 条件行自己没有 kb 列:归属按所属规则的库判
            SELECT 'condition.predicate', a.kb_id, p.kb_id
              FROM public.attribute_rule_conditions c
              JOIN public.attribute_rules a ON a.id = c.rule_id
              LEFT JOIN public.relation_types p ON p.id = c.predicate_id
            UNION ALL
            -- 来源边行自己没有 kb 列:归属按所属 fact 的库判
            SELECT 'factsource.statement', f.kb_id, s.kb_id
              FROM public.typed_fact_sources ts
              JOIN public.facts f ON f.id = ts.fact_id
              LEFT JOIN public.facts s ON s.id = ts.statement_id
            UNION ALL
            -- 开放陈述的属性行自己没有 kb 列:归属按所属 fact 的库判
            SELECT 'squalifier.entity', f.kb_id, e.kb_id
              FROM public.statement_qualifiers q
              JOIN public.facts f ON f.id = q.fact_id
              LEFT JOIN public.entities e ON e.id = q.entity_id
             WHERE q.entity_id IS NOT NULL
            UNION ALL
            SELECT 'timemention.fact', t.kb_id, f.kb_id
              FROM public.time_mentions t
              LEFT JOIN public.facts f ON f.id = t.fact_id
            UNION ALL
            SELECT 'timemention.chunk', t.kb_id, c.kb_id
              FROM public.time_mentions t
              LEFT JOIN public.chunks c ON c.id = t.chunk_id
            UNION ALL
            SELECT 'binding.type', b.kb_id, t.kb_id
              FROM public.type_bindings b
              LEFT JOIN public.entity_types t ON t.id = b.type_id
             WHERE b.type_id IS NOT NULL
            UNION ALL
            SELECT 'pbinding.subject_type', b.kb_id, t.kb_id
              FROM public.phrase_bindings b
              LEFT JOIN public.entity_types t ON t.id = b.subject_type_id
             WHERE b.subject_type_id IS NOT NULL
            UNION ALL
            SELECT 'pbinding.object_type', b.kb_id, t.kb_id
              FROM public.phrase_bindings b
              LEFT JOIN public.entity_types t ON t.id = b.object_type_id
             WHERE b.object_type_id IS NOT NULL
            UNION ALL
            SELECT 'pbinding.relation', b.kb_id, r.kb_id
              FROM public.phrase_bindings b
              LEFT JOIN public.relation_types r ON r.id = b.relation_type_id
             WHERE b.relation_type_id IS NOT NULL
        ) refs
        WHERE ref_kb IS DISTINCT FROM owner_kb
        GROUP BY edge
    ) bad;
    IF report IS NOT NULL THEN
        RAISE EXCEPTION 'cross-KB references already present (%) — repair the ledger before this invariant can be installed', report
            USING ERRCODE = 'integrity_constraint_violation';
    END IF;
END;
$$;

-- =====================================================================
-- §1a 复合键的支撑唯一约束:每个被引表一个 (kb_id, id)
-- =====================================================================
-- 复合外键要求被引列上有恰好匹配的唯一约束;主键只有 (id),不够宽。
ALTER TABLE public.documents
    ADD CONSTRAINT documents_kb_id_key UNIQUE (kb_id, id);
ALTER TABLE public.chunks
    ADD CONSTRAINT chunks_kb_id_key UNIQUE (kb_id, id);
ALTER TABLE public.entities
    ADD CONSTRAINT entities_kb_id_key UNIQUE (kb_id, id);
ALTER TABLE public.entity_types
    ADD CONSTRAINT entity_types_kb_id_key UNIQUE (kb_id, id);
ALTER TABLE public.relation_types
    ADD CONSTRAINT relation_types_kb_id_key UNIQUE (kb_id, id);
ALTER TABLE public.facts
    ADD CONSTRAINT facts_kb_id_key UNIQUE (kb_id, id);
ALTER TABLE public.rules
    ADD CONSTRAINT rules_kb_id_key UNIQUE (kb_id, id);
ALTER TABLE public.attribute_rules
    ADD CONSTRAINT attribute_rules_kb_id_key UNIQUE (kb_id, id);

-- =====================================================================
-- §1b 声明式边:源行自己带 kb_id 的引用 → 复合外键(26 条)
-- =====================================================================
-- 每条换掉原来的单列外键:`(kb_id, ref)` 同时证明「存在」与「同库」,一次
-- 内核层点查顶掉原来「FK 查存在 + 触发器查同库」的两次。删除行为与原外键
-- 逐条对齐。
ALTER TABLE public.chunks
    DROP CONSTRAINT chunks_document_id_fkey,
    ADD CONSTRAINT chunks_document_same_kb
        FOREIGN KEY (kb_id, document_id) REFERENCES public.documents (kb_id, id)
        ON DELETE CASCADE;

ALTER TABLE public.facts
    DROP CONSTRAINT facts_subject_id_fkey,
    DROP CONSTRAINT facts_object_id_fkey,
    DROP CONSTRAINT facts_predicate_id_fkey,
    DROP CONSTRAINT facts_supersedes_fkey,
    DROP CONSTRAINT facts_from_statement_id_fkey,
    ADD CONSTRAINT facts_subject_same_kb
        FOREIGN KEY (kb_id, subject_id) REFERENCES public.entities (kb_id, id)
        ON DELETE CASCADE,
    ADD CONSTRAINT facts_object_same_kb
        FOREIGN KEY (kb_id, object_id) REFERENCES public.entities (kb_id, id)
        ON DELETE CASCADE,
    ADD CONSTRAINT facts_predicate_same_kb
        FOREIGN KEY (kb_id, predicate_id) REFERENCES public.relation_types (kb_id, id)
        ON DELETE CASCADE,
    -- 同表自指:目标行可能在本语句之后才落(COPY/多行 INSERT/同事务顺序
    -- 插入)——递延到提交边界重估,那时整批都在
    ADD CONSTRAINT facts_supersedes_same_kb
        FOREIGN KEY (kb_id, supersedes) REFERENCES public.facts (kb_id, id)
        DEFERRABLE INITIALLY DEFERRED,
    ADD CONSTRAINT facts_from_statement_same_kb
        FOREIGN KEY (kb_id, from_statement_id) REFERENCES public.facts (kb_id, id)
        ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED;

ALTER TABLE public.derived_facts
    DROP CONSTRAINT derived_facts_subject_id_fkey,
    DROP CONSTRAINT derived_facts_object_id_fkey,
    DROP CONSTRAINT derived_facts_predicate_id_fkey,
    DROP CONSTRAINT derived_facts_rule_id_fkey,
    DROP CONSTRAINT derived_facts_attribute_rule_id_fkey,
    ADD CONSTRAINT derived_facts_subject_same_kb
        FOREIGN KEY (kb_id, subject_id) REFERENCES public.entities (kb_id, id)
        ON DELETE CASCADE,
    ADD CONSTRAINT derived_facts_object_same_kb
        FOREIGN KEY (kb_id, object_id) REFERENCES public.entities (kb_id, id)
        ON DELETE CASCADE,
    ADD CONSTRAINT derived_facts_predicate_same_kb
        FOREIGN KEY (kb_id, predicate_id) REFERENCES public.relation_types (kb_id, id)
        ON DELETE CASCADE,
    ADD CONSTRAINT derived_facts_rule_same_kb
        FOREIGN KEY (kb_id, rule_id) REFERENCES public.rules (kb_id, id),
    ADD CONSTRAINT derived_facts_attribute_rule_same_kb
        FOREIGN KEY (kb_id, attribute_rule_id) REFERENCES public.attribute_rules (kb_id, id)
        ON DELETE CASCADE;

ALTER TABLE public.entities
    DROP CONSTRAINT entities_type_id_fkey,
    ADD CONSTRAINT entities_type_same_kb
        FOREIGN KEY (kb_id, type_id) REFERENCES public.entity_types (kb_id, id)
        ON DELETE RESTRICT;

ALTER TABLE public.entity_type_disjoint
    DROP CONSTRAINT entity_type_disjoint_a_id_fkey,
    DROP CONSTRAINT entity_type_disjoint_b_id_fkey,
    ADD CONSTRAINT entity_type_disjoint_a_same_kb
        FOREIGN KEY (kb_id, a_id) REFERENCES public.entity_types (kb_id, id)
        ON DELETE CASCADE,
    ADD CONSTRAINT entity_type_disjoint_b_same_kb
        FOREIGN KEY (kb_id, b_id) REFERENCES public.entity_types (kb_id, id)
        ON DELETE CASCADE;

ALTER TABLE public.relation_types
    DROP CONSTRAINT relation_types_inverse_of_fkey,
    DROP CONSTRAINT relation_types_sub_property_of_fkey,
    -- 同表自指 → 递延;SET NULL 限定到引用列——不限定会把 kb_id 一起置空,
    -- 撞上 NOT NULL 变成「删目标行直接报错」(PG15+ 的列清单语法)
    ADD CONSTRAINT relation_types_inverse_same_kb
        FOREIGN KEY (kb_id, inverse_of) REFERENCES public.relation_types (kb_id, id)
        ON DELETE SET NULL (inverse_of) DEFERRABLE INITIALLY DEFERRED,
    ADD CONSTRAINT relation_types_sub_property_same_kb
        FOREIGN KEY (kb_id, sub_property_of) REFERENCES public.relation_types (kb_id, id)
        ON DELETE SET NULL (sub_property_of) DEFERRABLE INITIALLY DEFERRED;

ALTER TABLE public.rules
    DROP CONSTRAINT rules_predicate_id_fkey,
    ADD CONSTRAINT rules_predicate_same_kb
        FOREIGN KEY (kb_id, predicate_id) REFERENCES public.relation_types (kb_id, id)
        ON DELETE CASCADE;

ALTER TABLE public.attribute_rules
    DROP CONSTRAINT attribute_rules_subject_type_id_fkey,
    DROP CONSTRAINT attribute_rules_conclude_type_id_fkey,
    DROP CONSTRAINT attribute_rules_conclude_predicate_id_fkey,
    ADD CONSTRAINT attribute_rules_subject_type_same_kb
        FOREIGN KEY (kb_id, subject_type_id) REFERENCES public.entity_types (kb_id, id)
        ON DELETE CASCADE,
    ADD CONSTRAINT attribute_rules_conclude_type_same_kb
        FOREIGN KEY (kb_id, conclude_type_id) REFERENCES public.entity_types (kb_id, id)
        ON DELETE CASCADE,
    ADD CONSTRAINT attribute_rules_conclude_predicate_same_kb
        FOREIGN KEY (kb_id, conclude_predicate_id) REFERENCES public.relation_types (kb_id, id)
        ON DELETE CASCADE;

ALTER TABLE public.time_mentions
    DROP CONSTRAINT time_mentions_fact_id_fkey,
    DROP CONSTRAINT time_mentions_chunk_id_fkey,
    ADD CONSTRAINT time_mentions_fact_same_kb
        FOREIGN KEY (kb_id, fact_id) REFERENCES public.facts (kb_id, id)
        ON DELETE CASCADE,
    ADD CONSTRAINT time_mentions_chunk_same_kb
        FOREIGN KEY (kb_id, chunk_id) REFERENCES public.chunks (kb_id, id)
        ON DELETE CASCADE;

ALTER TABLE public.type_bindings
    DROP CONSTRAINT type_bindings_type_id_fkey,
    ADD CONSTRAINT type_bindings_type_same_kb
        FOREIGN KEY (kb_id, type_id) REFERENCES public.entity_types (kb_id, id)
        ON DELETE CASCADE;

ALTER TABLE public.phrase_bindings
    DROP CONSTRAINT phrase_bindings_subject_type_id_fkey,
    DROP CONSTRAINT phrase_bindings_object_type_id_fkey,
    DROP CONSTRAINT phrase_bindings_relation_type_id_fkey,
    ADD CONSTRAINT phrase_bindings_subject_type_same_kb
        FOREIGN KEY (kb_id, subject_type_id) REFERENCES public.entity_types (kb_id, id)
        ON DELETE CASCADE,
    ADD CONSTRAINT phrase_bindings_object_type_same_kb
        FOREIGN KEY (kb_id, object_type_id) REFERENCES public.entity_types (kb_id, id)
        ON DELETE CASCADE,
    ADD CONSTRAINT phrase_bindings_relation_type_same_kb
        FOREIGN KEY (kb_id, relation_type_id) REFERENCES public.relation_types (kb_id, id)
        ON DELETE CASCADE;

-- =====================================================================
-- §1c 触发器边:库归属在父行手上、引用行没有 kb_id 的 13 条
-- =====================================================================

-- 证据行:事实、段落、冗余文档指针必须同属一个库。
-- 父行不存在交给外键报错;这里只管「都存在,却不在同一个库」。
CREATE FUNCTION public.fact_evidence_stays_inside_its_kb() RETURNS trigger
LANGUAGE plpgsql SET search_path = pg_catalog AS $$
DECLARE
    fact_kb uuid;
    ref_kb  uuid;
BEGIN
    SELECT kb_id INTO fact_kb FROM public.facts WHERE id = NEW.fact_id;
    SELECT kb_id INTO ref_kb FROM public.chunks WHERE id = NEW.chunk_id;
    IF fact_kb IS NOT NULL AND ref_kb IS NOT NULL AND ref_kb <> fact_kb THEN
        RAISE EXCEPTION 'fact_evidence cannot pair fact % with chunk % across knowledge bases',
            NEW.fact_id, NEW.chunk_id;
    END IF;
    IF NEW.document_id IS NOT NULL AND fact_kb IS NOT NULL THEN
        SELECT kb_id INTO ref_kb FROM public.documents WHERE id = NEW.document_id;
        IF ref_kb IS NOT NULL AND ref_kb <> fact_kb THEN
            RAISE EXCEPTION 'fact_evidence cannot point at document % across knowledge bases',
                NEW.document_id;
        END IF;
    END IF;
    RETURN NEW;
END;
$$;

-- `ON CONFLICT DO UPDATE` 只改 quote/proposed_predicate,不在列清单里,
-- 常规的证据合并路径不会唤醒它
CREATE TRIGGER fact_evidence_same_kb
    BEFORE INSERT OR UPDATE OF fact_id, chunk_id, document_id ON public.fact_evidence
    FOR EACH ROW EXECUTE FUNCTION public.fact_evidence_stays_inside_its_kb();

-- 证明树:前提(断言或派生)必须与结论同属一个库。前提在导出里铸成
-- prov:used → fact:/derived: IRI——别库的前提挂上本库的结论,伪造的就是身份。
CREATE FUNCTION public.derivation_premise_stays_inside_its_kb() RETURNS trigger
LANGUAGE plpgsql SET search_path = pg_catalog AS $$
DECLARE
    derived_kb uuid;
    ref_kb     uuid;
BEGIN
    SELECT kb_id INTO derived_kb FROM public.derived_facts WHERE id = NEW.derived_fact_id;
    IF derived_kb IS NULL THEN
        RETURN NEW;
    END IF;
    IF NEW.premise_fact_id IS NOT NULL THEN
        SELECT kb_id INTO ref_kb FROM public.facts WHERE id = NEW.premise_fact_id;
    ELSE
        SELECT kb_id INTO ref_kb FROM public.derived_facts WHERE id = NEW.premise_derived_id;
    END IF;
    IF ref_kb IS NOT NULL AND ref_kb <> derived_kb THEN
        RAISE EXCEPTION 'derivation premise % cannot live outside the derived fact''s knowledge base',
            COALESCE(NEW.premise_fact_id, NEW.premise_derived_id);
    END IF;
    RETURN NEW;
END;
$$;

CREATE TRIGGER fact_derivations_same_kb
    BEFORE INSERT OR UPDATE OF derived_fact_id, premise_fact_id, premise_derived_id
    ON public.fact_derivations
    FOR EACH ROW EXECUTE FUNCTION public.derivation_premise_stays_inside_its_kb();

-- 边上的属性:属性类型必须在本库词汇表里可解析(别库的类型在导出里会被
-- 静默跳过——坏行不是消失,是当场报错);实体值不许把别库实体铸进本库 IRI。
CREATE FUNCTION public.qualifier_stays_inside_its_facts_kb() RETURNS trigger
LANGUAGE plpgsql SET search_path = pg_catalog AS $$
DECLARE
    fact_kb uuid;
    ref_kb  uuid;
BEGIN
    SELECT kb_id INTO fact_kb FROM public.facts WHERE id = NEW.fact_id;
    IF fact_kb IS NULL THEN
        RETURN NEW;
    END IF;
    SELECT kb_id INTO ref_kb FROM public.relation_types WHERE id = NEW.qualifier_type_id;
    IF ref_kb IS NOT NULL AND ref_kb <> fact_kb THEN
        RAISE EXCEPTION 'qualifier type % cannot live outside the fact''s knowledge base',
            NEW.qualifier_type_id;
    END IF;
    IF NEW.entity_id IS NOT NULL THEN
        SELECT kb_id INTO ref_kb FROM public.entities WHERE id = NEW.entity_id;
        IF ref_kb IS NOT NULL AND ref_kb <> fact_kb THEN
            RAISE EXCEPTION 'qualifier entity % cannot live outside the fact''s knowledge base',
                NEW.entity_id;
        END IF;
    END IF;
    RETURN NEW;
END;
$$;

CREATE TRIGGER fact_qualifiers_same_kb
    BEFORE INSERT OR UPDATE OF fact_id, qualifier_type_id, entity_id ON public.fact_qualifiers
    FOR EACH ROW EXECUTE FUNCTION public.qualifier_stays_inside_its_facts_kb();

-- 类层级:父类必须与子类同库。
CREATE FUNCTION public.type_parent_stays_inside_its_kb() RETURNS trigger
LANGUAGE plpgsql SET search_path = pg_catalog AS $$
DECLARE
    child_kb uuid;
    ref_kb   uuid;
BEGIN
    SELECT kb_id INTO child_kb FROM public.entity_types WHERE id = NEW.child_id;
    SELECT kb_id INTO ref_kb FROM public.entity_types WHERE id = NEW.parent_id;
    IF child_kb IS NOT NULL AND ref_kb IS NOT NULL AND ref_kb <> child_kb THEN
        RAISE EXCEPTION 'class % cannot parent % across knowledge bases',
            NEW.parent_id, NEW.child_id;
    END IF;
    RETURN NEW;
END;
$$;

CREATE TRIGGER entity_type_parents_same_kb
    BEFORE INSERT OR UPDATE OF child_id, parent_id ON public.entity_type_parents
    FOR EACH ROW EXECUTE FUNCTION public.type_parent_stays_inside_its_kb();

-- 关系的 domain/range:类必须与关系同库。两张表同形,共用一个函数。
CREATE FUNCTION public.relation_scope_stays_inside_its_kb() RETURNS trigger
LANGUAGE plpgsql SET search_path = pg_catalog AS $$
DECLARE
    rel_kb uuid;
    ref_kb uuid;
BEGIN
    SELECT kb_id INTO rel_kb FROM public.relation_types WHERE id = NEW.relation_type_id;
    SELECT kb_id INTO ref_kb FROM public.entity_types WHERE id = NEW.entity_type_id;
    IF rel_kb IS NOT NULL AND ref_kb IS NOT NULL AND ref_kb <> rel_kb THEN
        RAISE EXCEPTION '% cannot name class % outside the relation''s knowledge base',
            TG_TABLE_NAME, NEW.entity_type_id;
    END IF;
    RETURN NEW;
END;
$$;

CREATE TRIGGER relation_type_domains_same_kb
    BEFORE INSERT OR UPDATE OF relation_type_id, entity_type_id ON public.relation_type_domains
    FOR EACH ROW EXECUTE FUNCTION public.relation_scope_stays_inside_its_kb();

CREATE TRIGGER relation_type_ranges_same_kb
    BEFORE INSERT OR UPDATE OF relation_type_id, entity_type_id ON public.relation_type_ranges
    FOR EACH ROW EXECUTE FUNCTION public.relation_scope_stays_inside_its_kb();

-- 关系挂的边属性声明:qualifier 必须是**同一个库**里的行(形态校验——
-- 必须是 kind='attribute'——在 store 层,这里是归属层)。
CREATE FUNCTION public.relation_qualifier_stays_inside_the_kb() RETURNS trigger
LANGUAGE plpgsql SET search_path = pg_catalog AS $$
DECLARE
    rel_kb uuid;
    ref_kb uuid;
BEGIN
    SELECT kb_id INTO rel_kb FROM public.relation_types WHERE id = NEW.relation_type_id;
    SELECT kb_id INTO ref_kb FROM public.relation_types WHERE id = NEW.qualifier_type_id;
    IF rel_kb IS NOT NULL AND ref_kb IS NOT NULL AND ref_kb <> rel_kb THEN
        RAISE EXCEPTION 'relation qualifier % cannot live outside the relation''s knowledge base',
            NEW.qualifier_type_id;
    END IF;
    RETURN NEW;
END;
$$;

CREATE TRIGGER relation_type_qualifiers_same_kb
    BEFORE INSERT OR UPDATE OF relation_type_id, qualifier_type_id ON public.relation_type_qualifiers
    FOR EACH ROW EXECUTE FUNCTION public.relation_qualifier_stays_inside_the_kb();

-- 规则条件读的谓词:条件行没有自己的 kb 列,归属按所属规则的库判——
-- 导出把 predicate_id 铸成本库谓词 IRI,别库的谓词会被词汇表查空。
-- rule_id 是普通外键:不存在的规则装不进来(串行写时点检查就够——
-- 谓词与规则都必须在 INSERT 时已存在,kb 又都不可过户)
CREATE FUNCTION public.rule_condition_refs_stay_inside_the_kb() RETURNS trigger
LANGUAGE plpgsql SET search_path = pg_catalog AS $$
DECLARE
    rule_kb uuid;
    ref_kb  uuid;
BEGIN
    SELECT kb_id INTO rule_kb FROM public.attribute_rules WHERE id = NEW.rule_id;
    IF rule_kb IS NOT NULL THEN
        SELECT kb_id INTO ref_kb FROM public.relation_types WHERE id = NEW.predicate_id;
        IF ref_kb IS NOT NULL AND ref_kb <> rule_kb THEN
            RAISE EXCEPTION 'rule condition % predicate % cannot live outside the rule''s knowledge base',
                NEW.id, NEW.predicate_id;
        END IF;
    END IF;
    RETURN NEW;
END;
$$;

CREATE TRIGGER attribute_rule_conditions_same_kb
    BEFORE INSERT OR UPDATE OF rule_id, predicate_id ON public.attribute_rule_conditions
    FOR EACH ROW EXECUTE FUNCTION public.rule_condition_refs_stay_inside_the_kb();

-- 陈述→类型化事实的来源边:statement 必须与行主(fact)同库。
-- 两端都是必填外键,写入时必然在场——串行写时点检查就够,kb 又都不可过户。
CREATE FUNCTION public.typed_source_stays_inside_its_kb() RETURNS trigger
LANGUAGE plpgsql SET search_path = pg_catalog AS $$
DECLARE
    fact_kb uuid;
    ref_kb  uuid;
BEGIN
    SELECT kb_id INTO fact_kb FROM public.facts WHERE id = NEW.fact_id;
    SELECT kb_id INTO ref_kb FROM public.facts WHERE id = NEW.statement_id;
    IF fact_kb IS NOT NULL AND ref_kb IS NOT NULL AND ref_kb <> fact_kb THEN
        RAISE EXCEPTION 'typed fact source % cannot live outside the fact''s knowledge base',
            NEW.statement_id;
    END IF;
    RETURN NEW;
END;
$$;

CREATE TRIGGER typed_fact_sources_same_kb
    BEFORE INSERT OR UPDATE OF fact_id, statement_id ON public.typed_fact_sources
    FOR EACH ROW EXECUTE FUNCTION public.typed_source_stays_inside_its_kb();

-- 开放陈述的属性:实体值必须与所属事实同库(归属按 fact 的库判——
-- 属性行自己没有 kb 列)。
CREATE FUNCTION public.squalifier_stays_inside_its_facts_kb() RETURNS trigger
LANGUAGE plpgsql SET search_path = pg_catalog AS $$
DECLARE
    fact_kb uuid;
    ref_kb  uuid;
BEGIN
    IF NEW.entity_id IS NULL THEN
        RETURN NEW;
    END IF;
    SELECT kb_id INTO fact_kb FROM public.facts WHERE id = NEW.fact_id;
    SELECT kb_id INTO ref_kb FROM public.entities WHERE id = NEW.entity_id;
    IF fact_kb IS NOT NULL AND ref_kb IS NOT NULL AND ref_kb <> fact_kb THEN
        RAISE EXCEPTION 'statement qualifier entity % cannot live outside the fact''s knowledge base',
            NEW.entity_id;
    END IF;
    RETURN NEW;
END;
$$;

CREATE TRIGGER statement_qualifiers_same_kb
    BEFORE INSERT OR UPDATE OF fact_id, entity_id ON public.statement_qualifiers
    FOR EACH ROW EXECUTE FUNCTION public.squalifier_stays_inside_its_facts_kb();

-- =====================================================================
-- §2 库归属不可过户:把被引用的行挪走,等于把指着它的行一次全变坏行
-- =====================================================================
-- 复合外键护住的是「被指着的那一行」的 kb_id;§1c 的边拿**父行**的 kb 作证,
-- 父行 kb 一动整批脱锚,所以不可过户一条不能少。
CREATE FUNCTION public.kb_ownership_is_not_reassigned() RETURNS trigger
LANGUAGE plpgsql SET search_path = pg_catalog AS $$
BEGIN
    IF NEW.kb_id IS DISTINCT FROM OLD.kb_id THEN
        RAISE EXCEPTION 'kb ownership of % is immutable', TG_TABLE_NAME;
    END IF;
    RETURN NEW;
END;
$$;

CREATE TRIGGER facts_keep_their_kb
    BEFORE UPDATE OF kb_id ON public.facts
    FOR EACH ROW EXECUTE FUNCTION public.kb_ownership_is_not_reassigned();

CREATE TRIGGER derived_facts_keep_their_kb
    BEFORE UPDATE OF kb_id ON public.derived_facts
    FOR EACH ROW EXECUTE FUNCTION public.kb_ownership_is_not_reassigned();

CREATE TRIGGER documents_keep_their_kb
    BEFORE UPDATE OF kb_id ON public.documents
    FOR EACH ROW EXECUTE FUNCTION public.kb_ownership_is_not_reassigned();

CREATE TRIGGER entities_keep_their_kb
    BEFORE UPDATE OF kb_id ON public.entities
    FOR EACH ROW EXECUTE FUNCTION public.kb_ownership_is_not_reassigned();

CREATE TRIGGER entity_types_keep_their_kb
    BEFORE UPDATE OF kb_id ON public.entity_types
    FOR EACH ROW EXECUTE FUNCTION public.kb_ownership_is_not_reassigned();

CREATE TRIGGER relation_types_keep_their_kb
    BEFORE UPDATE OF kb_id ON public.relation_types
    FOR EACH ROW EXECUTE FUNCTION public.kb_ownership_is_not_reassigned();

CREATE TRIGGER rules_keep_their_kb
    BEFORE UPDATE OF kb_id ON public.rules
    FOR EACH ROW EXECUTE FUNCTION public.kb_ownership_is_not_reassigned();

CREATE TRIGGER attribute_rules_keep_their_kb
    BEFORE UPDATE OF kb_id ON public.attribute_rules
    FOR EACH ROW EXECUTE FUNCTION public.kb_ownership_is_not_reassigned();

CREATE TRIGGER entity_type_disjoint_keep_their_kb
    BEFORE UPDATE OF kb_id ON public.entity_type_disjoint
    FOR EACH ROW EXECUTE FUNCTION public.kb_ownership_is_not_reassigned();

CREATE TRIGGER time_mentions_keep_their_kb
    BEFORE UPDATE OF kb_id ON public.time_mentions
    FOR EACH ROW EXECUTE FUNCTION public.kb_ownership_is_not_reassigned();

CREATE TRIGGER type_bindings_keep_their_kb
    BEFORE UPDATE OF kb_id ON public.type_bindings
    FOR EACH ROW EXECUTE FUNCTION public.kb_ownership_is_not_reassigned();

CREATE TRIGGER phrase_bindings_keep_their_kb
    BEFORE UPDATE OF kb_id ON public.phrase_bindings
    FOR EACH ROW EXECUTE FUNCTION public.kb_ownership_is_not_reassigned();