World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
fix(export): use one snapshot and validate local references (#833)
Ansonnmff126d64c5ca
diff --git a/crates/utopia-server/src/api/export_routes.rs b/crates/utopia-server/src/api/export_routes.rsindex ff853c7c..6c995a0b 100644--- a/crates/utopia-server/src/api/export_routes.rs+++ b/crates/utopia-server/src/api/export_routes.rs@@ -4,6 +4,10 @@//! 一个十万条事实的库正是最需要导出的那种库,也正是「先拼成一个 String」会//! 把服务打死的那种库。//!+//! **同一份快照**:体检、词汇表与每一页查询跑在同一条只读 REPEATABLE READ+//! 事务里。若每页各自拿一条连接,词汇表发完之后才提交的规则会在派生页里+//! 留下一条指向它的 `wasGeneratedBy`——图里就出现没有本体的引用。+//!//! 中途出错只能截断——HTTP 头早就发出去了。所以错误进日志,而客户端拿到的是//! 一份短了一截的文件;这比先攒后发要好,那种做法在同样的库上根本发不出来。@@ -44,7 +48,9 @@ pub async fn export(})?;let names = Names::new(kb_id, q.base.as_deref()).map_err(AppError::Validation)?;- // 导出是一次「整个库离开这台机器」的动作,台账要记下(0014 的同一条理由)+ // 导出是一次「整个库离开这台机器」的动作,台账要记下(0014 的同一条理由)。+ // 必须在快照事务之前写完并放掉连接:下面那条事务一占就是整个流的时长,+ // 占着它再回头要连接,会把最小池(两条)上的并发导出互相饿死let _ = utopia_store::audit::record(&state.pool,Some(kb_id),@@ -56,13 +62,24 @@ pub async fn export().await;- let pool = state.pool.clone();+ // 整份导出占一条连接上的只读 REPEATABLE READ 事务:下面的预检与流里+ // 每一页查询读同一个快照,事务活到流结束+ let mut tx = state.pool.begin().await?;+ sqlx::query("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY")+ .execute(&mut *tx)+ .await?;++ // 出处链越库一律拒导(0070 挡新行,这里挡存量坏行):宁可不发一个字节,+ // 也不能把别库的对象安上本库的 IRI——那份文件看着完整、实则悬空。+ // 在流开始之前拦下:客户端拿到的是确定性的错误,不是一截断掉的文件+ utopia_store::export::provenance_integrity(&mut tx, kb_id).await?;+let stream = async_stream::try_stream! {let buf = SharedBuf::default();let mut sink = Sink::new(format, buf.clone());- let classes = utopia_store::export::classes(&pool, kb_id).await.map_err(io)?;- let relations = utopia_store::export::relations(&pool, kb_id).await.map_err(io)?;+ let classes = utopia_store::export::classes(&mut tx, kb_id).await.map_err(io)?;+ let relations = utopia_store::export::relations(&mut tx, kb_id).await.map_err(io)?;let vocab = rdf::vocabulary(&names, &classes, &relations);for c in &classes {rdf::emit_class(&mut sink, &vocab, c)?;@@ -74,7 +91,7 @@ pub async fn export(let mut after = None;loop {- let page = utopia_store::export::documents_page(&pool, kb_id, after).await.map_err(io)?;+ let page = utopia_store::export::documents_page(&mut tx, kb_id, after).await.map_err(io)?;let Some(last) = page.last() else { break };after = Some(last.id);for d in &page {@@ -85,7 +102,7 @@ pub async fn export(let mut after = None;loop {- let page = utopia_store::export::entities_page(&pool, kb_id, after).await.map_err(io)?;+ let page = utopia_store::export::entities_page(&mut tx, kb_id, after).await.map_err(io)?;let Some(last) = page.last() else { break };after = Some(last.id);for e in &page {@@ -99,7 +116,7 @@ pub async fn export(let now = chrono::Utc::now();let mut after = None;loop {- let page = utopia_store::export::facts_page(&pool, kb_id, after).await.map_err(io)?;+ let page = utopia_store::export::facts_page(&mut tx, kb_id, after).await.map_err(io)?;let Some(last) = page.last() else { break };after = Some(last.id);for f in &page {@@ -110,7 +127,7 @@ pub async fn export(let mut after = None;loop {- let page = utopia_store::export::derived_page(&pool, kb_id, after).await.map_err(io)?;+ let page = utopia_store::export::derived_page(&mut tx, kb_id, after).await.map_err(io)?;let Some(last) = page.last() else { break };after = Some(last.id);for d in &page {diff --git a/crates/utopia-server/src/api/mcp_tests.rs b/crates/utopia-server/src/api/mcp_tests.rsindex 5e2f92ad..13e6316e 100644--- a/crates/utopia-server/src/api/mcp_tests.rs+++ b/crates/utopia-server/src/api/mcp_tests.rs@@ -30,6 +30,11 @@ impl Fixture {return Ok(None);};let pool = sqlx::PgPool::connect(&url).await?;+ Self::with_pool(pool).await.map(Some)+ }++ /// 同一份种子,池子由调用方给——连池参数的测试(比如最小池)走这里+ async fn with_pool(pool: sqlx::PgPool) -> anyhow::Result<Self> {utopia_store::db::migrate(&pool).await?;let dir = std::env::temp_dir().join(format!("utopia-mcp-{}", Uuid::now_v7()));let search = Arc::new(utopia_search::SearchIndex::open(&dir.join("search"))?);@@ -148,7 +153,7 @@ impl Fixture {&f.document.to_string(),&[(f.chunk.to_string(), "orchard ".repeat(120))],)?;- Ok(Some(f))+ Ok(f)}async fn request(@@ -307,6 +312,82 @@ async fn record_axis_subseconds_survive_authenticated_rdf_export() -> anyhow::Reresult.and(cleanup)}+/// 每个导出的快照事务活满整个流——它占住一条连接直到文件发完。台账如果排在+/// 事务之后写,就是在「已经占了一条」的情况下再向池子要第二条:支持的最小池+/// (2 条连接)上两个并发导出会互相把对方的审计饿死到超时。所以顺序必须是:+/// 先写完台账、放掉连接,再开始占着不放的长事务。两个导出都该落得下一行+/// kb.exported,而不是在等一条永远不会来的连接+#[tokio::test]+async fn concurrent_exports_on_a_minimum_pool_still_record_their_audits() -> anyhow::Result<()> {+ use axum::body::{to_bytes, Body};+ use axum::http::{Request, StatusCode};+ use tower::ServiceExt;++ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ // 支持的最小池:两条连接。短的 acquire 超时只是为了不让失败的探测等太久——+ // 断言不依赖时钟,依赖台账行在不在+ let pool = sqlx::postgres::PgPoolOptions::new()+ .max_connections(2)+ .acquire_timeout(std::time::Duration::from_millis(400))+ .connect(&url)+ .await?;+ let f = Fixture::with_pool(pool).await?;++ let auth = utopia_store::tokens::authenticate(&f.state.pool, &f.token).await?;+ let jwt = crate::auth::issue_token(&f.state, auth.user_id)?;+ let app = crate::api::router(f.state.clone(), &Default::default());+ let uri = format!("/api/v1/kbs/{}/export?format=turtle", f.kb);++ let export = |app: axum::Router| {+ let uri = uri.clone();+ let jwt = jwt.clone();+ async move {+ let response = app+ .oneshot(+ Request::builder()+ .uri(uri)+ .header("authorization", format!("Bearer {jwt}"))+ .body(Body::empty())?,+ )+ .await?;+ let status = response.status();+ let bytes = to_bytes(response.into_body(), 8 * 1024 * 1024).await?;+ Ok::<(StatusCode, axum::body::Bytes), anyhow::Error>((status, bytes))+ }+ };+ // 一次性失败上限:真饿死也只是多等几秒,不该挂着不走+ let (a, b) = tokio::time::timeout(std::time::Duration::from_secs(30), async {+ let (a, b) = tokio::join!(export(app.clone()), export(app));+ (a.unwrap(), b.unwrap())+ })+ .await?;+ anyhow::ensure!(a.0 == StatusCode::OK, "export A rejected: {}", a.0);+ anyhow::ensure!(b.0 == StatusCode::OK, "export B rejected: {}", b.0);+ anyhow::ensure!(!a.1.is_empty() && !b.1.is_empty(), "export body empty");++ // 两份导出,两行台账——任何一份的审计被池子饿死这里都露馅+ let audits: i64 = sqlx::query_scalar(+ "SELECT COUNT(*) FROM audit_events WHERE kb_id = $1 AND action = 'kb.exported'",+ )+ .bind(f.kb)+ .fetch_one(&f.state.pool)+ .await?;+ anyhow::ensure!(+ audits == 2,+ "two exports must each record kb.exported, got {audits}"+ );++ // 两条流发完之后连接都得回家:接着借满整个池(两条)都该立刻拿到——+ // 快照事务没放下的话,这里就会撞 acquire 超时+ let c1 = f.state.pool.acquire().await?;+ let c2 = f.state.pool.acquire().await?;+ drop(c2);+ drop(c1);+ f.clean().await+}+#[tokio::test]async fn refused_and_executed_calls_are_each_audited_once() -> anyhow::Result<()> {let Some(f) = Fixture::new().await? else {@@ -622,7 +703,8 @@ async fn entity_facts_keeps_identity_values_filters_and_both_clocks() -> anyhow:assert!(derived["rule_id"].is_null());uuid(&derived["attribute_rule_id"]);// The same UUID is the RDF statement's identity, not a newly minted response ID.- let exported = utopia_store::export::facts_page(&f.state.pool, f.kb, None).await?;+ let exported =+ utopia_store::export::facts_page(&mut f.state.pool.begin().await?, f.kb, None).await?;assert!(exported.iter().any(|r| r.id == uuid(&corrected["id"]) && r.documents == vec![f.document]));diff --git a/crates/utopia-server/src/rdf.rs b/crates/utopia-server/src/rdf.rsindex 0da8f3fc..bcb2f9bc 100644--- a/crates/utopia-server/src/rdf.rs+++ b/crates/utopia-server/src/rdf.rs@@ -748,6 +748,14 @@ mod tests {documents: vec![],quotes: vec![],quote_origins: vec![],+ subject_kb: Some(kb()),+ object_kb: Some(kb()),+ predicate_kb: Some(kb()),+ supersedes_kb: None,+ foreign_document: false,+ foreign_chunk: false,+ subject_merged: false,+ object_merged: false,}}@@ -1164,6 +1172,15 @@ mod tests {rule_name: Some("Gas-bearing well".into()),premises: vec![id(5)],premises_derived: Vec::new(),+ subject_kb: Some(kb()),+ object_kb: None,+ predicate_kb: Some(kb()),+ rule_kb: None,+ attribute_rule_kb: Some(kb()),+ foreign_fact_premise: false,+ foreign_derived_premise: false,+ subject_merged: false,+ object_merged: false,};let quads = export(Format::Turtle, |sink, names, vocab| {emit_derived(sink, names, vocab, &derived).unwrap();@@ -1289,6 +1306,15 @@ mod tests {rule_name: None,premises: vec![id(5)],premises_derived: vec![id(6)],+ subject_kb: Some(kb()),+ object_kb: Some(kb()),+ predicate_kb: Some(kb()),+ rule_kb: Some(kb()),+ attribute_rule_kb: None,+ foreign_fact_premise: false,+ foreign_derived_premise: false,+ subject_merged: false,+ object_merged: false,};for format in [Format::Turtle, Format::JsonLd] {let quads = export(format, |sink, names, vocab| {diff --git a/crates/utopia-store/src/export.rs b/crates/utopia-store/src/export.rsindex 33fdc130..360aff38 100644--- a/crates/utopia-store/src/export.rs+++ b/crates/utopia-store/src/export.rs@@ -6,15 +6,285 @@//!//! 除本体外一律**按 id 分页**:一个库的事实可以有几十万条,全读进内存再序列化//! 会在最需要它的那种部署上炸掉。id 是 uuid v7,按它排序即按写入顺序排序。+//! 第一页没有下界(`$2 IS NULL OR id > $2`):uuid 没有更小的哨兵可垫——+//! `id > NIL` 会把主键恰为 NIL 的合法行永远挡在导出外,而指向它的+//! (document_id, version) 定位器照样解析,留下一条没有本体的边。+//!+//! **同一份快照**:所有取数口吃调用方的事务(`&mut Transaction`),路由侧把它+//! 定成只读 REPEATABLE READ——体检、词汇表与每一页读的是同一个时刻的库。+//! 若每页各自向连接池要一条连接,词汇表发完之后才提交的规则会在派生页里+//! 留下一条指向它的 `wasGeneratedBy`——图里就出现没有本体的引用。+//!+//! **逐页校验用的是留下的那几行自己**:每个 page 查询把被引行的+//! kb_id 与行本体**原子地一并选出**,校验在内存里跑。不能「先取一页、再去库里+//! 问一次」——第二次问的是另一个时刻的状态,留下的行早已不是它。+//!+//! 校验范围只覆盖**这份导出真正解析的引用**:会被铸成本库 IRI 的、会被按 id+//! 进本库词汇表查的。导出还没读的边(规则表自身、陈述属性、时间提及、+//! 文档版本定位器等)不在这里管——它们随各自的导出面一起带上自己的校验。use chrono::{DateTime, Utc};-use sqlx::PgPool;-use utopia_core::AppResult;+use sqlx::{Postgres, Transaction};+use utopia_core::{AppError, AppResult};use uuid::Uuid;/// 一次取多少行。够大以免把往返次数拉满,够小以免一页就撑爆内存。pub const PAGE: i64 = 500;+/// 出处链越界的一类引用。同库外键只认 id、不认库:A 库的+/// 行可以引用 B 库的对象,schema 什么都不拦。0070 的触发器挡新行;这里拦的是+/// **存量坏行**与绕过触发器写进来的行。+///+/// 处置一律是**整份拒导**:把别库对象的 id 铸进本库 IRI+/// (`urn:utopia:kb:A:document:{B 的文档}`)等于伪造身份——那份文件看着+/// 完整,实则悬空。被词汇表解析的引用(谓词、属性类型、实体类型)越库则+/// 静默消失——坏行一样不许放行。少导一行、换个 IRI 都不在选项里+#[derive(Debug, sqlx::FromRow)]+pub struct CrossKbViolation {+ /// 哪条边:evidence.chunk | derivation.premise_fact | …+ pub edge: String,+ pub rows: i64,+}++fn cross_kb_error(violations: &[CrossKbViolation]) -> AppError {+ let detail = violations+ .iter()+ .map(|v| format!("{}: {} row(s)", v.edge, v.rows))+ .collect::<Vec<_>>()+ .join("; ");+ AppError::invalid_detail(+ "cross_kb_provenance",+ "export refused: KB-scoped provenance points outside the knowledge base",+ detail,+ )+}++/// 引用指着的东西**在本库,却不在导出集里**(合并掉的实体是唯一会缺席的+/// 实体——`entities_page` 滤掉 `merged_into` 非空的行)。同库但缺席的引用+/// 不能换 IRI、也不能静默省略:整份拒导,与越库同一处置。+fn unexported_error(violations: &[CrossKbViolation]) -> AppError {+ let detail = violations+ .iter()+ .map(|v| format!("{}: {} row(s)", v.edge, v.rows))+ .collect::<Vec<_>>()+ .join("; ");+ AppError::invalid_detail(+ "unexported_target",+ "export refused: a reference points at a row that is not in this KB's exported set",+ detail,+ )+}++fn tally(violations: &mut Vec<CrossKbViolation>, edge: &str, rows: i64) {+ if rows > 0 {+ violations.push(CrossKbViolation {+ edge: edge.into(),+ rows,+ });+ }+}++/// 引用列的判定:**留下的是谁,就查谁**。`ref_kb` 由 page 查询与行本体原子地+/// 一并选出——别库、悬空(NULL)都不算本库,一律判违规+fn foreign(ref_kb: Option<Uuid>, kb_id: Uuid) -> bool {+ ref_kb != Some(kb_id)+}++/// 导出前的出处体检。逐类数一遍越界引用,有一行就整份拒导。+/// 越界有两类,各自一条错:**别库/悬空**(`cross_kb`)与**同库但不在导出集**+/// (`unexported`——合并掉的实体)。只报哪条边坏了、坏了几行——具体哪些行+/// 坏是库里的事,不进面向导出的报错+///+/// 扫的边与导出面一一对应:只查这份导出会解析的引用(IRI 会铸出去的、+/// 词汇表会按 id 查的)。**必须在导出用的那条事务里跑**(REPEATABLE READ):+/// 体检与每一页查询看的是同一个快照,先体检后换连接会在两个时刻之间+/// 漏掉刚提交的坏行+pub async fn provenance_integrity(+ tx: &mut Transaction<'_, Postgres>,+ kb_id: Uuid,+) -> AppResult<()> {+ #[derive(sqlx::FromRow)]+ struct ScanViolation {+ edge: String,+ kind: String,+ rows: i64,+ }+ let violations: Vec<ScanViolation> = sqlx::query_as(+ "SELECT edge, kind, COUNT(*) AS rows FROM (+ -- 证据的段落:quote_origins 按它 JOIN chunks 取 origin——别库/悬空+ -- 的段落会让引文来源静默消失+ SELECT 'evidence.chunk'::text AS edge, 'cross_kb'::text AS kind,+ c.kb_id IS DISTINCT FROM f.kb_id AS bad+ FROM fact_evidence e+ JOIN facts f ON f.id = e.fact_id+ LEFT JOIN chunks c ON c.id = e.chunk_id+ WHERE f.kb_id = $1+ UNION ALL+ -- 证据的文档指针:铸成 prov:wasDerivedFrom 的文档 IRI+ SELECT 'evidence.document', 'cross_kb', d.kb_id IS DISTINCT FROM f.kb_id+ FROM fact_evidence e+ JOIN facts f ON f.id = e.fact_id+ LEFT JOIN documents d ON d.id = e.document_id+ WHERE f.kb_id = $1 AND e.document_id IS NOT NULL+ UNION ALL+ -- 派生前提:铸成 prov:used 的事实/派生 IRI+ SELECT 'derivation.premise_fact', 'cross_kb', p.kb_id IS DISTINCT FROM d.kb_id+ FROM fact_derivations fd+ JOIN derived_facts d ON d.id = fd.derived_fact_id+ LEFT JOIN facts p ON p.id = fd.premise_fact_id+ WHERE d.kb_id = $1 AND fd.premise_fact_id IS NOT NULL+ UNION ALL+ SELECT 'derivation.premise_derived', 'cross_kb', p.kb_id IS DISTINCT FROM d.kb_id+ FROM fact_derivations fd+ JOIN derived_facts d ON d.id = fd.derived_fact_id+ LEFT JOIN derived_facts p ON p.id = fd.premise_derived_id+ WHERE d.kb_id = $1 AND fd.premise_derived_id IS NOT NULL+ UNION ALL+ -- 边上的属性:类型进词汇表按 id 查(查不着静默丢),实体值铸 IRI+ SELECT 'qualifier.type', 'cross_kb', r.kb_id IS DISTINCT FROM f.kb_id+ FROM fact_qualifiers q+ JOIN facts f ON f.id = q.fact_id+ LEFT JOIN relation_types r ON r.id = q.qualifier_type_id+ WHERE f.kb_id = $1+ UNION ALL+ SELECT 'qualifier.entity', 'cross_kb', e.kb_id IS DISTINCT FROM f.kb_id+ FROM fact_qualifiers q+ JOIN facts f ON f.id = q.fact_id+ LEFT JOIN entities e ON e.id = q.entity_id+ WHERE f.kb_id = $1 AND q.entity_id IS NOT NULL+ UNION ALL+ SELECT 'qualifier.entity(merged)', 'unexported', TRUE+ FROM fact_qualifiers q+ JOIN facts f ON f.id = q.fact_id+ JOIN entities e ON e.id = q.entity_id AND e.merged_into IS NOT NULL+ WHERE f.kb_id = $1+ UNION ALL+ -- 事实本体:主语铸 entity IRI,谓词进词汇表,supersedes 铸 fact IRI+ SELECT 'fact.subject', 'cross_kb', s.kb_id IS DISTINCT FROM f.kb_id+ FROM facts f LEFT JOIN entities s ON s.id = f.subject_id+ WHERE f.kb_id = $1+ UNION ALL+ SELECT 'fact.subject(merged)', 'unexported', TRUE+ FROM facts f JOIN entities s ON s.id = f.subject_id AND s.merged_into IS NOT NULL+ WHERE f.kb_id = $1+ UNION ALL+ SELECT 'fact.object', 'cross_kb', o.kb_id IS DISTINCT FROM f.kb_id+ FROM facts f LEFT JOIN entities o ON o.id = f.object_id+ WHERE f.kb_id = $1 AND f.object_id IS NOT NULL+ UNION ALL+ SELECT 'fact.object(merged)', 'unexported', TRUE+ FROM facts f JOIN entities o ON o.id = f.object_id AND o.merged_into IS NOT NULL+ WHERE f.kb_id = $1+ UNION ALL+ SELECT 'fact.predicate', 'cross_kb', r.kb_id IS DISTINCT FROM f.kb_id+ FROM facts f LEFT JOIN relation_types r ON r.id = f.predicate_id+ WHERE f.kb_id = $1 AND f.predicate_id IS NOT NULL+ UNION ALL+ SELECT 'fact.supersedes', 'cross_kb', s.kb_id IS DISTINCT FROM f.kb_id+ FROM facts f LEFT JOIN facts s ON s.id = f.supersedes+ WHERE f.kb_id = $1 AND f.supersedes IS NOT NULL+ UNION ALL+ -- 派生本体:规则 id 铸成 wasGeneratedBy 的 Activity IRI+ SELECT 'derived.subject', 'cross_kb', s.kb_id IS DISTINCT FROM d.kb_id+ FROM derived_facts d LEFT JOIN entities s ON s.id = d.subject_id+ WHERE d.kb_id = $1+ UNION ALL+ SELECT 'derived.subject(merged)', 'unexported', TRUE+ FROM derived_facts d JOIN entities s ON s.id = d.subject_id AND s.merged_into IS NOT NULL+ WHERE d.kb_id = $1+ UNION ALL+ SELECT 'derived.object', 'cross_kb', o.kb_id IS DISTINCT FROM d.kb_id+ FROM derived_facts d LEFT JOIN entities o ON o.id = d.object_id+ WHERE d.kb_id = $1 AND d.object_id IS NOT NULL+ UNION ALL+ SELECT 'derived.object(merged)', 'unexported', TRUE+ FROM derived_facts d JOIN entities o ON o.id = d.object_id AND o.merged_into IS NOT NULL+ WHERE d.kb_id = $1+ UNION ALL+ SELECT 'derived.predicate', 'cross_kb', r.kb_id IS DISTINCT FROM d.kb_id+ FROM derived_facts d LEFT JOIN relation_types r ON r.id = d.predicate_id+ WHERE d.kb_id = $1+ UNION ALL+ SELECT 'derived.rule', 'cross_kb', r.kb_id IS DISTINCT FROM d.kb_id+ FROM derived_facts d LEFT JOIN rules r ON r.id = d.rule_id+ WHERE d.kb_id = $1 AND d.rule_id IS NOT NULL+ UNION ALL+ SELECT 'derived.attribute_rule', 'cross_kb', r.kb_id IS DISTINCT FROM d.kb_id+ FROM derived_facts d LEFT JOIN attribute_rules r ON r.id = d.attribute_rule_id+ WHERE d.kb_id = $1 AND d.attribute_rule_id IS NOT NULL+ UNION ALL+ -- 实体的类进词汇表按 id 查+ SELECT 'entity.type', 'cross_kb', t.kb_id IS DISTINCT FROM e.kb_id+ FROM entities e LEFT JOIN entity_types t ON t.id = e.type_id+ WHERE e.kb_id = $1 AND e.type_id IS NOT NULL+ UNION ALL+ -- 类层级与互斥都进词汇表按 id 查+ SELECT 'class.parent', 'cross_kb', p.kb_id IS DISTINCT FROM c.kb_id+ FROM entity_type_parents x+ JOIN entity_types c ON c.id = x.child_id+ LEFT JOIN entity_types p ON p.id = x.parent_id+ WHERE c.kb_id = $1+ UNION ALL+ SELECT 'class.disjoint', 'cross_kb', a.kb_id IS DISTINCT FROM dd.kb_id+ FROM entity_type_disjoint dd+ LEFT JOIN entity_types a ON a.id = dd.a_id+ WHERE dd.kb_id = $1+ UNION ALL+ SELECT 'class.disjoint', 'cross_kb', b.kb_id IS DISTINCT FROM dd.kb_id+ FROM entity_type_disjoint dd+ LEFT JOIN entity_types b ON b.id = dd.b_id+ WHERE dd.kb_id = $1+ UNION ALL+ -- domain/range 进词汇表按 id 查;inverse/sub_property 铸关系 IRI+ SELECT 'relation.domain', 'cross_kb', t.kb_id IS DISTINCT FROM r.kb_id+ FROM relation_type_domains x+ JOIN relation_types r ON r.id = x.relation_type_id+ LEFT JOIN entity_types t ON t.id = x.entity_type_id+ WHERE r.kb_id = $1+ UNION ALL+ SELECT 'relation.range', 'cross_kb', t.kb_id IS DISTINCT FROM r.kb_id+ FROM relation_type_ranges x+ JOIN relation_types r ON r.id = x.relation_type_id+ LEFT JOIN entity_types t ON t.id = x.entity_type_id+ WHERE r.kb_id = $1+ UNION ALL+ SELECT 'relation.inverse', 'cross_kb', t.kb_id IS DISTINCT FROM r.kb_id+ FROM relation_types r LEFT JOIN relation_types t ON t.id = r.inverse_of+ WHERE r.kb_id = $1 AND r.inverse_of IS NOT NULL+ UNION ALL+ SELECT 'relation.sub_property', 'cross_kb', t.kb_id IS DISTINCT FROM r.kb_id+ FROM relation_types r LEFT JOIN relation_types t ON t.id = r.sub_property_of+ WHERE r.kb_id = $1 AND r.sub_property_of IS NOT NULL+ ) refs WHERE bad GROUP BY edge, kind",+ )+ .bind(kb_id)+ .fetch_all(&mut **tx)+ .await?;+ let cross_kb: Vec<CrossKbViolation> = violations+ .iter()+ .filter(|v| v.kind == "cross_kb")+ .map(|v| CrossKbViolation {+ edge: v.edge.clone(),+ rows: v.rows,+ })+ .collect();+ let unexported: Vec<CrossKbViolation> = violations+ .iter()+ .filter(|v| v.kind == "unexported")+ .map(|v| CrossKbViolation {+ edge: v.edge.clone(),+ rows: v.rows,+ })+ .collect();+ if !cross_kb.is_empty() {+ return Err(cross_kb_error(&cross_kb));+ }+ if !unexported.is_empty() {+ return Err(unexported_error(&unexported));+ }+ Ok(())+}+#[derive(Debug, Clone, sqlx::FromRow)]pub struct ExportClass {pub id: Uuid,@@ -46,6 +316,8 @@ pub struct ExportRelation {pub is_symmetric: bool,pub is_asymmetric: bool,pub is_irreflexive: bool,+ /// 同表自指:导出 owl:inverseOf / rdfs:subPropertyOf。存量的合法性在+ /// 迁移的递延约束里管,这里只负责把集合带上(越库/悬空 → 拒导)pub inverse_of: Option<Uuid>,pub sub_property_of: Option<Uuid>,pub domains: Vec<Uuid>,@@ -57,6 +329,9 @@ pub struct ExportEntity {pub id: Uuid,pub canonical_name: String,pub type_id: Option<Uuid>,+ /// type_id 指着的类的 kb(LEFT JOIN 一并选出)。别库/悬空 → 拒导:+ /// 序列化按 id 进本库词汇表查类,查不着就是静默丢类型+ pub type_kb: Option<Uuid>,}#[derive(Debug, Clone, sqlx::FromRow)]@@ -87,6 +362,20 @@ pub struct ExportFact {pub quotes: Vec<String>,/// 证据文字的来源(0040),去重:一条陈述的引文里有没有扫描、转写、看图描述来的pub quote_origins: Vec<String>,+ /// 以下各列是被引行的 kb,与行本体原子地一并选出。+ /// 别库或悬空(NULL)的引用不许被铸成本库 IRI,也不许静默跳过+ pub subject_kb: Option<Uuid>,+ pub object_kb: Option<Uuid>,+ pub predicate_kb: Option<Uuid>,+ pub supersedes_kb: Option<Uuid>,+ /// documents[] 里是否有别库或悬空的文档指针+ pub foreign_document: bool,+ /// 引文 JOIN 的段落里是否有别库或悬空的(quote_origins 的来源会静默消失)+ pub foreign_chunk: bool,+ /// 主语/宾语指着**已合并**的实体:同库但不在导出集(merged_into IS NOT NULL+ /// 的行 entities_page 不导)。与行本体原子地一并选出+ pub subject_merged: bool,+ pub object_merged: bool,}#[derive(Debug, Clone, sqlx::FromRow)]@@ -116,6 +405,20 @@ pub struct ExportDerived {/// 前提里是**另一条派生**的那些(0030)。与上面那列分开,是因为读回来的人/// 要知道该去哪张表接着往下走;合成一列的话,一条链在导出里就断了pub premises_derived: Vec<Uuid>,+ /// 被引行的 kb,与行本体原子地一并选出+ pub subject_kb: Option<Uuid>,+ pub object_kb: Option<Uuid>,+ pub predicate_kb: Option<Uuid>,+ /// rule_id / attribute_rule_id 指着的规则行的 kb——它铸成 wasGeneratedBy+ /// 的 Activity IRI+ pub rule_kb: Option<Uuid>,+ pub attribute_rule_kb: Option<Uuid>,+ /// premises[] / premises_derived[] 里是否有别库或悬空的前提(两种前提分开报边)+ pub foreign_fact_premise: bool,+ pub foreign_derived_premise: bool,+ /// 主语/宾语指着已合并的实体:同库但不在导出集+ pub subject_merged: bool,+ pub object_merged: bool,}#[derive(Debug, Clone, sqlx::FromRow)]@@ -129,8 +432,11 @@ pub struct ExportDocument {pub deleted_at: Option<DateTime<Utc>>,}-pub async fn classes(pool: &PgPool, kb_id: Uuid) -> AppResult<Vec<ExportClass>> {- Ok(sqlx::query_as(+pub async fn classes(+ tx: &mut Transaction<'_, Postgres>,+ kb_id: Uuid,+) -> AppResult<Vec<ExportClass>> {+ let classes: Vec<ExportClass> = sqlx::query_as("SELECT t.id, t.key, t.label, t.description, t.iri,COALESCE(ARRAY(SELECT p.parent_id FROM entity_type_parents pWHERE p.child_id = t.id ORDER BY p.parent_id), '{}') AS parents,@@ -141,12 +447,29 @@ pub async fn classes(pool: &PgPool, kb_id: Uuid) -> AppResult<Vec<ExportClass>>FROM entity_types t WHERE t.kb_id = $1 ORDER BY t.key",).bind(kb_id)- .fetch_all(pool)- .await?)+ .fetch_all(&mut **tx)+ .await?;+ // 父类与互斥类稍后要进本库词汇表按 id 查——查不着就是被静默丢掉。+ // 能解析的就地解析:词汇表全集就在手里,不在集合里的引用就是越库/悬空+ let own: std::collections::HashSet<Uuid> = classes.iter().map(|c| c.id).collect();+ let mut violations = Vec::new();+ for c in &classes {+ let bad_parents = c.parents.iter().filter(|p| !own.contains(p)).count() as i64;+ let bad_disjoint = c.disjoint.iter().filter(|p| !own.contains(p)).count() as i64;+ tally(&mut violations, "class.parent", bad_parents);+ tally(&mut violations, "class.disjoint", bad_disjoint);+ }+ if !violations.is_empty() {+ return Err(cross_kb_error(&violations));+ }+ Ok(classes)}-pub async fn relations(pool: &PgPool, kb_id: Uuid) -> AppResult<Vec<ExportRelation>> {- Ok(sqlx::query_as(+pub async fn relations(+ tx: &mut Transaction<'_, Postgres>,+ kb_id: Uuid,+) -> AppResult<Vec<ExportRelation>> {+ let relations: Vec<ExportRelation> = sqlx::query_as("SELECT r.id, r.key, r.label, r.description, r.iri, r.kind, r.datatype, r.unit,r.temporal, r.functional, r.inverse_functional,r.is_transitive, r.is_symmetric, r.is_asymmetric, r.is_irreflexive,@@ -158,32 +481,80 @@ pub async fn relations(pool: &PgPool, kb_id: Uuid) -> AppResult<Vec<ExportRelatiFROM relation_types r WHERE r.kb_id = $1 ORDER BY r.key",).bind(kb_id)- .fetch_all(pool)- .await?)+ .fetch_all(&mut **tx)+ .await?;+ // domain/range 的类 id 与 inverse/sub_property 的关系 id 都要进本库词汇表+ // 查——查不着就静默丢公理。**两行全集都在手里**,不在集合里的引用就是+ // 越库/悬空+ let own_types: Vec<Uuid> = sqlx::query_scalar(+ "SELECT COALESCE(ARRAY(SELECT id FROM entity_types WHERE kb_id = $1), '{}')",+ )+ .bind(kb_id)+ .fetch_one(&mut **tx)+ .await?;+ let own: std::collections::HashSet<Uuid> = own_types.into_iter().collect();+ let own_rel: std::collections::HashSet<Uuid> = relations.iter().map(|r| r.id).collect();+ let mut violations = Vec::new();+ for r in &relations {+ let bad_domains = r.domains.iter().filter(|t| !own.contains(t)).count() as i64;+ let bad_ranges = r.ranges.iter().filter(|t| !own.contains(t)).count() as i64;+ tally(&mut violations, "relation.domain", bad_domains);+ tally(&mut violations, "relation.range", bad_ranges);+ if let Some(t) = r.inverse_of {+ tally(+ &mut violations,+ "relation.inverse",+ (!own_rel.contains(&t)) as i64,+ );+ }+ if let Some(t) = r.sub_property_of {+ tally(+ &mut violations,+ "relation.sub_property",+ (!own_rel.contains(&t)) as i64,+ );+ }+ }+ if !violations.is_empty() {+ return Err(cross_kb_error(&violations));+ }+ Ok(relations)}/// 合并掉的实体不导出:它已经不是一个东西了,它的事实早已搬到留下的那个身上。pub async fn entities_page(- pool: &PgPool,+ tx: &mut Transaction<'_, Postgres>,kb_id: Uuid,after: Option<Uuid>,) -> AppResult<Vec<ExportEntity>> {- Ok(sqlx::query_as(- "SELECT id, canonical_name, type_id FROM entities- WHERE kb_id = $1 AND merged_into IS NULL AND id > COALESCE($2, '00000000-0000-0000-0000-000000000000'::uuid)- ORDER BY id LIMIT $3",+ let page: Vec<ExportEntity> = sqlx::query_as(+ "SELECT e.id, e.canonical_name, e.type_id, t.kb_id AS type_kb+ FROM entities e LEFT JOIN entity_types t ON t.id = e.type_id+ WHERE e.kb_id = $1 AND e.merged_into IS NULL+ AND ($2 IS NULL OR e.id > $2)+ ORDER BY e.id LIMIT $3",).bind(kb_id).bind(after).bind(PAGE)- .fetch_all(pool)- .await?)+ .fetch_all(&mut **tx)+ .await?;+ let mut violations = Vec::new();+ for e in &page {+ if e.type_id.is_some() && foreign(e.type_kb, kb_id) {+ tally(&mut violations, "entity.type", 1);+ }+ }+ if !violations.is_empty() {+ return Err(cross_kb_error(&violations));+ }+ Ok(page)}/// **不过滤 `invalidated_at`。** 撤回的、被修正顶掉的、区间早已闭合的,全在里面/// ——它们各自带着两根轴上的时刻,读的人自己判断当时成立不成立(0019、0020)。pub async fn facts_page(- pool: &PgPool,+ tx: &mut Transaction<'_, Postgres>,kb_id: Uuid,after: Option<Uuid>,) -> AppResult<Vec<ExportFact>> {@@ -202,10 +573,26 @@ pub async fn facts_page(ORDER BY e.chunk_id), '{{}}') AS quotes,COALESCE(ARRAY(SELECT DISTINCT c.origin FROM fact_evidence eJOIN chunks c ON c.id = e.chunk_id- WHERE e.fact_id = f.id- ORDER BY c.origin), '{{}}') AS quote_origins+ WHERE e.fact_id = f.id ORDER BY c.origin), '{{}}')+ AS quote_origins,+ s.kb_id AS subject_kb, o.kb_id AS object_kb,+ p.kb_id AS predicate_kb, sp.kb_id AS supersedes_kb,+ EXISTS(SELECT 1 FROM fact_evidence e+ LEFT JOIN documents ed ON ed.id = e.document_id+ WHERE e.fact_id = f.id AND e.document_id IS NOT NULL+ AND ed.kb_id IS DISTINCT FROM f.kb_id) AS foreign_document,+ EXISTS(SELECT 1 FROM fact_evidence e+ LEFT JOIN chunks ec ON ec.id = e.chunk_id+ WHERE e.fact_id = f.id+ AND ec.kb_id IS DISTINCT FROM f.kb_id) AS foreign_chunk,+ (s.merged_into IS NOT NULL) AS subject_merged,+ (o.merged_into IS NOT NULL) AS object_mergedFROM facts f- WHERE f.kb_id = $1 AND f.id > COALESCE($2, '00000000-0000-0000-0000-000000000000'::uuid)+ LEFT JOIN entities s ON s.id = f.subject_id+ LEFT JOIN entities o ON o.id = f.object_id+ LEFT JOIN relation_types p ON p.id = f.predicate_id+ LEFT JOIN facts sp ON sp.id = f.supersedes+ WHERE f.kb_id = $1 AND ($2 IS NULL OR f.id > $2)ORDER BY f.id LIMIT $3",holds_from = crate::world_axis::facts_holds_from("f"),holds_to = crate::world_axis::facts_holds_to("f"),@@ -213,12 +600,68 @@ pub async fn facts_page(.bind(kb_id).bind(after).bind(PAGE)- .fetch_all(pool)+ .fetch_all(&mut **tx).await?;- // 边上的属性另一张表(0037),按事实 id 一次取回补上+ // 留下的行逐个过:被铸成本库 IRI 的引用不许越库,进词汇表的引用不许查空。+ // 检查用的是随行原子选出的 ref_kb——不是再去库里问一次的另一个时刻+ let mut violations = Vec::new();+ let mut unexported = Vec::new();+ for f in &facts {+ tally(+ &mut violations,+ "fact.subject",+ foreign(f.subject_kb, kb_id) as i64,+ );+ tally(+ &mut unexported,+ "fact.subject(merged)",+ f.subject_merged as i64,+ );+ if f.object_id.is_some() {+ tally(+ &mut violations,+ "fact.object",+ foreign(f.object_kb, kb_id) as i64,+ );+ tally(+ &mut unexported,+ "fact.object(merged)",+ f.object_merged as i64,+ );+ }+ if f.predicate_id.is_some() {+ tally(+ &mut violations,+ "fact.predicate",+ foreign(f.predicate_kb, kb_id) as i64,+ );+ }+ if f.supersedes.is_some() {+ tally(+ &mut violations,+ "fact.supersedes",+ foreign(f.supersedes_kb, kb_id) as i64,+ );+ }+ tally(+ &mut violations,+ "evidence.document",+ f.foreign_document as i64,+ );+ tally(&mut violations, "evidence.chunk", f.foreign_chunk as i64);+ }+ if !violations.is_empty() {+ return Err(cross_kb_error(&violations));+ }+ if !unexported.is_empty() {+ return Err(unexported_error(&unexported));+ }+ // 边上的属性另一张表(0037),按事实 id 一次取回补上——把属性类型的 kb 与+ // 实体值的 kb 一并选出:别库类型会被词汇表静默跳过,别库实体会被铸进本库+ // IRI,两种行都得在序列化之前拦下来{let ids: Vec<Uuid> = facts.iter().map(|f| f.id).collect();- let mut by_fact = crate::graph::fact_qualifiers_for(pool, &ids).await?;+ let mut by_fact = qualifiers_for_export(tx, &ids, kb_id).await?;for f in facts.iter_mut() {if let Some(q) = by_fact.remove(&f.id) {f.qualifiers = q;@@ -228,12 +671,97 @@ pub async fn facts_page(Ok(facts)}+#[derive(sqlx::FromRow)]+struct ExportQualifierRow {+ fact_id: Uuid,+ qualifier_type_id: Uuid,+ key: Option<String>,+ label: Option<String>,+ value: Option<serde_json::Value>,+ entity_id: Option<Uuid>,+ entity_name: Option<String>,+ type_kb: Option<Uuid>,+ entity_kb: Option<Uuid>,+ entity_merged: bool,+}++/// 导出专用的属性取数:与 graph::fact_qualifiers_for 同一形状,多选两列 kb。+/// 那边用 INNER JOIN——被引类型不在时整行属性**静默消失**;导出不能这么吞。+/// 别库的属性类型会被词汇表查空而静默跳过,别库的实体值会被铸进本库+/// entity IRI——两种都按坏行拒+async fn qualifiers_for_export(+ tx: &mut Transaction<'_, Postgres>,+ fact_ids: &[Uuid],+ kb_id: Uuid,+) -> AppResult<std::collections::HashMap<Uuid, Vec<utopia_core::models::FactQualifier>>> {+ let mut out: std::collections::HashMap<Uuid, Vec<utopia_core::models::FactQualifier>> =+ std::collections::HashMap::new();+ if fact_ids.is_empty() {+ return Ok(out);+ }+ let rows: Vec<ExportQualifierRow> = sqlx::query_as(+ "SELECT q.fact_id, q.qualifier_type_id, r.key, r.label, q.value, q.entity_id,+ e.canonical_name AS entity_name,+ r.kb_id AS type_kb, e.kb_id AS entity_kb,+ (e.merged_into IS NOT NULL) AS entity_merged+ FROM fact_qualifiers q+ LEFT JOIN relation_types r ON r.id = q.qualifier_type_id+ LEFT JOIN entities e ON e.id = q.entity_id+ WHERE q.fact_id = ANY($1)+ ORDER BY q.fact_id, r.key",+ )+ .bind(fact_ids)+ .fetch_all(&mut **tx)+ .await?;+ let mut violations = Vec::new();+ let mut unexported = Vec::new();+ for r in &rows {+ tally(+ &mut violations,+ "qualifier.type",+ foreign(r.type_kb, kb_id) as i64,+ );+ if r.entity_id.is_some() {+ tally(+ &mut violations,+ "qualifier.entity",+ foreign(r.entity_kb, kb_id) as i64,+ );+ tally(+ &mut unexported,+ "qualifier.entity(merged)",+ r.entity_merged as i64,+ );+ }+ }+ if !violations.is_empty() {+ return Err(cross_kb_error(&violations));+ }+ if !unexported.is_empty() {+ return Err(unexported_error(&unexported));+ }+ for r in rows {+ out.entry(r.fact_id)+ .or_default()+ .push(utopia_core::models::FactQualifier {+ qualifier_type_id: r.qualifier_type_id,+ // 过了校验 r 必然在:key/label 不会取不到+ key: r.key.unwrap_or_default(),+ label: r.label.unwrap_or_default(),+ value: r.value,+ entity_id: r.entity_id,+ entity_name: r.entity_name,+ });+ }+ Ok(out)+}+pub async fn derived_page(- pool: &PgPool,+ tx: &mut Transaction<'_, Postgres>,kb_id: Uuid,after: Option<Uuid>,) -> AppResult<Vec<ExportDerived>> {- Ok(sqlx::query_as(+ let page: Vec<ExportDerived> = sqlx::query_as(// **两个 LEFT JOIN。** 表拓宽之后(0021)派生可能没有实体宾语、// 也可能来自业务规则而不是公理——内连接会把这类结论整条挡在导出之外,// 而 0020 承诺的正是「审计员不靠我们也能读全」@@ -249,34 +777,112 @@ pub async fn derived_page(COALESCE(ARRAY(SELECT fd.premise_derived_id FROM fact_derivations fdWHERE fd.derived_fact_id = d.idAND fd.premise_derived_id IS NOT NULL- ORDER BY fd.seq), '{}') AS premises_derived+ ORDER BY fd.seq), '{}') AS premises_derived,+ s.kb_id AS subject_kb, o.kb_id AS object_kb, p.kb_id AS predicate_kb,+ ru.kb_id AS rule_kb, ar.kb_id AS attribute_rule_kb,+ EXISTS(SELECT 1 FROM fact_derivations fd+ LEFT JOIN facts pf ON pf.id = fd.premise_fact_id+ WHERE fd.derived_fact_id = d.id AND fd.premise_fact_id IS NOT NULL+ AND pf.kb_id IS DISTINCT FROM d.kb_id) AS foreign_fact_premise,+ EXISTS(SELECT 1 FROM fact_derivations fd+ LEFT JOIN derived_facts pd ON pd.id = fd.premise_derived_id+ WHERE fd.derived_fact_id = d.id AND fd.premise_derived_id IS NOT NULL+ AND pd.kb_id IS DISTINCT FROM d.kb_id) AS foreign_derived_premise,+ (s.merged_into IS NOT NULL) AS subject_merged,+ (o.merged_into IS NOT NULL) AS object_mergedFROM derived_facts dLEFT JOIN rules ru ON ru.id = d.rule_idLEFT JOIN attribute_rules ar ON ar.id = d.attribute_rule_id- WHERE d.kb_id = $1 AND d.id > COALESCE($2, '00000000-0000-0000-0000-000000000000'::uuid)+ LEFT JOIN entities s ON s.id = d.subject_id+ LEFT JOIN entities o ON o.id = d.object_id+ LEFT JOIN relation_types p ON p.id = d.predicate_id+ WHERE d.kb_id = $1 AND ($2 IS NULL OR d.id > $2)ORDER BY d.id LIMIT $3",).bind(kb_id).bind(after).bind(PAGE)- .fetch_all(pool)- .await?)+ .fetch_all(&mut **tx)+ .await?;+ let mut violations = Vec::new();+ let mut unexported = Vec::new();+ for d in &page {+ tally(+ &mut violations,+ "derived.subject",+ foreign(d.subject_kb, kb_id) as i64,+ );+ tally(+ &mut unexported,+ "derived.subject(merged)",+ d.subject_merged as i64,+ );+ if d.object_id.is_some() {+ tally(+ &mut violations,+ "derived.object",+ foreign(d.object_kb, kb_id) as i64,+ );+ tally(+ &mut unexported,+ "derived.object(merged)",+ d.object_merged as i64,+ );+ }+ // 派生的谓词非空(CHECK 保证),NULL 的 ref_kb 一样是越界/悬空+ tally(+ &mut violations,+ "derived.predicate",+ foreign(d.predicate_kb, kb_id) as i64,+ );+ if d.rule_id.is_some() {+ tally(+ &mut violations,+ "derived.rule",+ foreign(d.rule_kb, kb_id) as i64,+ );+ }+ if d.attribute_rule_id.is_some() {+ tally(+ &mut violations,+ "derived.attribute_rule",+ foreign(d.attribute_rule_kb, kb_id) as i64,+ );+ }+ tally(+ &mut violations,+ "derivation.premise_fact",+ d.foreign_fact_premise as i64,+ );+ tally(+ &mut violations,+ "derivation.premise_derived",+ d.foreign_derived_premise as i64,+ );+ }+ if !violations.is_empty() {+ return Err(cross_kb_error(&violations));+ }+ if !unexported.is_empty() {+ return Err(unexported_error(&unexported));+ }+ Ok(page)}pub async fn documents_page(- pool: &PgPool,+ tx: &mut Transaction<'_, Postgres>,kb_id: Uuid,after: Option<Uuid>,) -> AppResult<Vec<ExportDocument>> {Ok(sqlx::query_as("SELECT id, filename, external_key, doc_time, created_at, deleted_atFROM documents- WHERE kb_id = $1 AND id > COALESCE($2, '00000000-0000-0000-0000-000000000000'::uuid)+ WHERE kb_id = $1 AND ($2 IS NULL OR id > $2)ORDER BY id LIMIT $3",).bind(kb_id).bind(after).bind(PAGE)- .fetch_all(pool)+ .fetch_all(&mut **tx).await?)}diff --git a/crates/utopia-store/tests/a_merged_target_stays_out_of_the_export.rs b/crates/utopia-store/tests/a_merged_target_stays_out_of_the_export.rsnew file mode 100644index 00000000..18a1f53f--- /dev/null+++ b/crates/utopia-store/tests/a_merged_target_stays_out_of_the_export.rs@@ -0,0 +1,288 @@+//! 同库不等于在导出集里:`entities_page` 滤掉 `merged_into`+//! 非空的行,但 merge 只改写 fact 的主语/宾语——属性里的实体值、派生的+//! 主语/宾语仍可能指着已合并的行。序列化照铸它的 IRI 就是一条悬空边。+//!+//! 判法:**同库但不在导出集**也是越界——与越库同一处置,整份拒导。不+//! 重写指向留下的实体(那是另一个语义动作),也不静默省略。++use sqlx::PgPool;+use uuid::Uuid;++struct Fixture {+ org: Uuid,+ kb: Uuid,+ survivor: Uuid,+ merged: Uuid,+ rel: Uuid,+ attr: Uuid,+ rule: Uuid,+ fact: Uuid,+}++/// 一个库、留着的实体与已合并的实体、一条事实、一条指向已合并实体的+/// 派生——merged 是合法状态(没有触发器拦它),要拦的是导出侧+async fn seed(pool: &PgPool) -> anyhow::Result<Fixture> {+ let (org, ws, kb) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());+ sqlx::query("INSERT INTO organizations (id, name) VALUES ($1, 'merged-test')")+ .bind(org)+ .execute(pool)+ .await?;+ sqlx::query("INSERT INTO workspaces (id, org_id, name) VALUES ($1, $2, 'merged-test')")+ .bind(ws)+ .bind(org)+ .execute(pool)+ .await?;+ sqlx::query(+ "INSERT INTO knowledge_bases (id, workspace_id, name) VALUES ($1, $2, 'merged-test')",+ )+ .bind(kb)+ .bind(ws)+ .execute(pool)+ .await?;++ let (survivor, merged) = (Uuid::now_v7(), Uuid::now_v7());+ sqlx::query("INSERT INTO entities (id, kb_id, canonical_name) VALUES ($1, $2, 'survivor')")+ .bind(survivor)+ .bind(kb)+ .execute(pool)+ .await?;+ sqlx::query(+ "INSERT INTO entities (id, kb_id, canonical_name, merged_into) VALUES ($1, $2, 'gone', $3)",+ )+ .bind(merged)+ .bind(kb)+ .bind(survivor)+ .execute(pool)+ .await?;++ let (rel, attr) = (Uuid::now_v7(), Uuid::now_v7());+ sqlx::query(+ "INSERT INTO relation_types (id, kb_id, key, label) VALUES ($1, $2, 'knows', 'knows')",+ )+ .bind(rel)+ .bind(kb)+ .execute(pool)+ .await?;+ sqlx::query(+ "INSERT INTO relation_types (id, kb_id, key, label, kind) VALUES ($1, $2, 'since', 'since', 'attribute')",+ )+ .bind(attr)+ .bind(kb)+ .execute(pool)+ .await?;++ let fact = Uuid::now_v7();+ sqlx::query(+ "INSERT INTO facts (id, kb_id, subject_id, predicate_id, object_id, confidence)+ VALUES ($1, $2, $3, $4, $3, 0.9)",+ )+ .bind(fact)+ .bind(kb)+ .bind(survivor)+ .bind(rel)+ .execute(pool)+ .await?;++ let rule = Uuid::now_v7();+ sqlx::query(+ "INSERT INTO rules (id, kb_id, predicate_id, kind) VALUES ($1, $2, $3, 'transitive')",+ )+ .bind(rule)+ .bind(kb)+ .bind(rel)+ .execute(pool)+ .await?;++ Ok(Fixture {+ org,+ kb,+ survivor,+ merged,+ rel,+ attr,+ rule,+ fact,+ })+}++async fn cleanup(pool: &PgPool, f: &Fixture) -> anyhow::Result<()> {+ sqlx::query("DELETE FROM knowledge_bases WHERE id = $1")+ .bind(f.kb)+ .execute(pool)+ .await?;+ sqlx::query("DELETE FROM organizations WHERE id = $1")+ .bind(f.org)+ .execute(pool)+ .await?;+ Ok(())+}++async fn insert_derived(+ pool: &PgPool,+ f: &Fixture,+ subject: Uuid,+ object: Uuid,+) -> anyhow::Result<Uuid> {+ let id = Uuid::now_v7();+ sqlx::query(+ "INSERT INTO derived_facts (id, kb_id, subject_id, predicate_id, object_id, rule_id)+ VALUES ($1, $2, $3, $4, $5, $6)",+ )+ .bind(id)+ .bind(f.kb)+ .bind(subject)+ .bind(f.rel)+ .bind(object)+ .bind(f.rule)+ .execute(pool)+ .await?;+ Ok(id)+}++/// 已合并的实体不进导出集——它不在 entities 页里出现+#[tokio::test]+async fn a_merged_entity_is_not_emitted() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ utopia_store::db::migrate(&pool).await?;+ let f = seed(&pool).await?;++ let page = utopia_store::export::entities_page(&mut pool.begin().await?, f.kb, None).await?;+ assert!(page.iter().any(|e| e.id == f.survivor));+ assert!(+ !page.iter().any(|e| e.id == f.merged),+ "merged 实体必须不在导出集里"+ );++ cleanup(&pool, &f).await+}++/// 指着已合并实体的属性值:同库但缺席——体检与事实页都要拦+#[tokio::test]+async fn a_qualifier_on_a_merged_entity_fails_closed() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ utopia_store::db::migrate(&pool).await?;+ let f = seed(&pool).await?;++ sqlx::query(+ "INSERT INTO fact_qualifiers (fact_id, qualifier_type_id, entity_id)+ VALUES ($1, $2, $3)",+ )+ .bind(f.fact)+ .bind(f.attr)+ .bind(f.merged)+ .execute(&pool)+ .await?;++ let err = utopia_store::export::provenance_integrity(&mut pool.begin().await?, f.kb).await;+ let msg = format!("{err:?}");+ assert!(err.is_err(), "qualifier→merged 的体检必须拒导");+ assert!(+ msg.contains("qualifier.entity(merged)"),+ "要报 qualifier.entity(merged): {msg}"+ );+ assert!(+ utopia_store::export::facts_page(&mut pool.begin().await?, f.kb, None)+ .await+ .is_err(),+ "事实页也要拦下同一条边"+ );++ sqlx::query("DELETE FROM fact_qualifiers WHERE fact_id = $1")+ .bind(f.fact)+ .execute(&pool)+ .await?;+ cleanup(&pool, &f).await+}++/// 派生的主语/宾语指着已合并的实体:同库但缺席+#[tokio::test]+async fn a_derived_on_a_merged_entity_fails_closed() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ utopia_store::db::migrate(&pool).await?;+ let f = seed(&pool).await?;++ let d_subj = insert_derived(&pool, &f, f.merged, f.survivor).await?;+ let err = utopia_store::export::provenance_integrity(&mut pool.begin().await?, f.kb).await;+ let msg = format!("{err:?}");+ assert!(err.is_err(), "derived.subject→merged 的体检必须拒导");+ assert!(+ msg.contains("derived.subject(merged)"),+ "要报 derived.subject(merged): {msg}"+ );+ sqlx::query("DELETE FROM derived_facts WHERE id = $1")+ .bind(d_subj)+ .execute(&pool)+ .await?;++ let d_obj = insert_derived(&pool, &f, f.survivor, f.merged).await?;+ let err = utopia_store::export::provenance_integrity(&mut pool.begin().await?, f.kb).await;+ let msg = format!("{err:?}");+ assert!(err.is_err(), "derived.object→merged 的体检必须拒导");+ assert!(+ msg.contains("derived.object(merged)"),+ "要报 derived.object(merged): {msg}"+ );+ sqlx::query("DELETE FROM derived_facts WHERE id = $1")+ .bind(d_obj)+ .execute(&pool)+ .await?;++ // 干净之后就放行——拒的是缺席的引用,不是库本身+ utopia_store::export::provenance_integrity(&mut pool.begin().await?, f.kb).await?;+ cleanup(&pool, &f).await+}++/// 事实的主语/宾语指着已合并的实体(merge 没走到的旧写或绕过 store 的写):+/// 事实页与体检都要拦+#[tokio::test]+async fn a_fact_on_a_merged_entity_fails_closed() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ utopia_store::db::migrate(&pool).await?;+ let f = seed(&pool).await?;++ let bad_fact = Uuid::now_v7();+ sqlx::query(+ "INSERT INTO facts (id, kb_id, subject_id, predicate_id, object_id, confidence)+ VALUES ($1, $2, $3, $4, $5, 0.9)",+ )+ .bind(bad_fact)+ .bind(f.kb)+ .bind(f.survivor)+ .bind(f.rel)+ .bind(f.merged)+ .execute(&pool)+ .await?;++ let err = utopia_store::export::provenance_integrity(&mut pool.begin().await?, f.kb).await;+ let msg = format!("{err:?}");+ assert!(err.is_err(), "fact.object→merged 的体检必须拒导");+ assert!(+ msg.contains("fact.object(merged)"),+ "要报 fact.object(merged): {msg}"+ );+ assert!(+ utopia_store::export::facts_page(&mut pool.begin().await?, f.kb, None)+ .await+ .is_err(),+ "事实页也要拦下同一条边"+ );++ sqlx::query("DELETE FROM facts WHERE id = $1")+ .bind(bad_fact)+ .execute(&pool)+ .await?;+ utopia_store::export::provenance_integrity(&mut pool.begin().await?, f.kb).await?;+ cleanup(&pool, &f).await+}diff --git a/crates/utopia-store/tests/an_export_carries_the_whole_ledger.rs b/crates/utopia-store/tests/an_export_carries_the_whole_ledger.rsindex 908b3e8e..821f2de8 100644--- a/crates/utopia-store/tests/an_export_carries_the_whole_ledger.rs+++ b/crates/utopia-store/tests/an_export_carries_the_whole_ledger.rs@@ -222,7 +222,7 @@ async fn an_export_reads_the_whole_ledger_not_the_current_view() -> anyhow::Resulet f = seed(&pool).await?;// 1. 事实:撤回的那条**在**。界面把它藏起来是对的,导出把它藏起来就是骗人- let facts = utopia_store::export::facts_page(&pool, f.kb, None).await?;+ let facts = utopia_store::export::facts_page(&mut pool.begin().await?, f.kb, None).await?;let ids: Vec<Uuid> = facts.iter().map(|x| x.id).collect();assert!(ids.contains(&f.live));assert!(@@ -244,7 +244,8 @@ async fn an_export_reads_the_whole_ledger_not_the_current_view() -> anyhow::Resuassert_eq!(bare.surface_predicate.as_deref(), Some("advises"));// 4. 实体:合并掉的那个是唯一该消失的东西- let entities = utopia_store::export::entities_page(&pool, f.kb, None).await?;+ let entities =+ utopia_store::export::entities_page(&mut pool.begin().await?, f.kb, None).await?;let ids: Vec<Uuid> = entities.iter().map(|e| e.id).collect();assert!(ids.contains(&f.kept));assert!(@@ -253,21 +254,21 @@ async fn an_export_reads_the_whole_ledger_not_the_current_view() -> anyhow::Resu);// 5. 文档:删掉的留着墓碑(#268)。抹掉出处等于抹掉证据链- let docs = utopia_store::export::documents_page(&pool, f.kb, None).await?;+ let docs = utopia_store::export::documents_page(&mut pool.begin().await?, f.kb, None).await?;let deleted = docs.iter().find(|d| d.id == f.deleted_doc).unwrap();assert!(deleted.deleted_at.is_some());// 6. 派生:带着规则和前提,审计顺着它走得到断言- let derived = utopia_store::export::derived_page(&pool, f.kb, None).await?;+ let derived = utopia_store::export::derived_page(&mut pool.begin().await?, f.kb, None).await?;let d = derived.iter().find(|d| d.id == f.derived).unwrap();assert_eq!(d.rule, "transitive");assert_eq!(d.premises, vec![f.live]);// 7. 词汇表:导入来的类留着原 IRI,公理位照抄- let classes = utopia_store::export::classes(&pool, f.kb).await?;+ let classes = utopia_store::export::classes(&mut pool.begin().await?, f.kb).await?;let person = classes.iter().find(|c| c.key == "person").unwrap();assert_eq!(person.iri.as_deref(), Some("https://schema.org/Person"));- let relations = utopia_store::export::relations(&pool, f.kb).await?;+ let relations = utopia_store::export::relations(&mut pool.begin().await?, f.kb).await?;assert!(relations.iter().any(|r| r.key == "works_for" && r.functional));diff --git a/crates/utopia-store/tests/an_open_statement_keeps_the_documents_words.rs b/crates/utopia-store/tests/an_open_statement_keeps_the_documents_words.rsindex a7c59e09..c24c985e 100644--- a/crates/utopia-store/tests/an_open_statement_keeps_the_documents_words.rs+++ b/crates/utopia-store/tests/an_open_statement_keeps_the_documents_words.rs@@ -226,7 +226,8 @@ async fn an_open_statement_shows_under_its_phrase_and_reuses_its_row() -> anyhow.expect("a path walks the open statement");assert_eq!(direct.edges[0].predicate.as_deref(), Some("acquired"));- let exported = utopia_store::export::facts_page(&pool, f.kb, None).await?;+ let exported =+ utopia_store::export::facts_page(&mut pool.begin().await?, f.kb, None).await?;let x = exported.iter().find(|x| x.id == fact)diff --git a/crates/utopia-store/tests/cross_kb_provenance_fails_closed.rs b/crates/utopia-store/tests/cross_kb_provenance_fails_closed.rsnew file mode 100644index 00000000..1e595b7c--- /dev/null+++ b/crates/utopia-store/tests/cross_kb_provenance_fails_closed.rs@@ -0,0 +1,295 @@+//! 出处链不许跨库(0070):新行被触发器挡下,存量坏行让导出整份拒绝。+//!+//! `fact_evidence`/`chunks` 的外键只认 id 不认库——原生写入路径碰巧全是同库+//! 构造,但 schema 什么也不拦。两层防:+//! 1. 触发器(0070)挡在一切写入路径下游,包括绕过 store 层的 SQL;+//! 2. 导出侧体检 + 逐页校验——存量坏行与绕过触发器进来的行,宁可整份拒导,+//! 也不能把别库对象的 id 铸进本库 IRI。+//!+//! 坏行在测试里靠 `SET LOCAL session_replication_role='replica'` 制造:只关+//! 本事务的触发器,不碰 catalog——`DISABLE TRIGGER` 是全局的,并行测试会把+//! 对方断言的拒绝窗口撞没。行指着的东西都真实存在,只是不在同一个库——+//! 正是线上会遇到的形态(比如从 0070 之前的备份恢复进来的旧行)。++use sqlx::{Acquire, PgPool};+use uuid::Uuid;++struct TwoKbs {+ org: Uuid,+ a: Uuid,+ b: Uuid,+ doc_a: Uuid,+ doc_b: Uuid,+ chunk_a: Uuid,+ chunk_b: Uuid,+ fact_a: Uuid,+ fact_b: Uuid,+}++/// 两个库、每库一份文档一段一实体一事实——跨库引用需要的合法零件+async fn seed(pool: &PgPool) -> anyhow::Result<TwoKbs> {+ let (org, ws, a, b) = (+ Uuid::now_v7(),+ Uuid::now_v7(),+ Uuid::now_v7(),+ Uuid::now_v7(),+ );+ let (doc_a, doc_b) = (Uuid::now_v7(), Uuid::now_v7());+ let (chunk_a, chunk_b) = (Uuid::now_v7(), Uuid::now_v7());+ let (ent_a, ent_b) = (Uuid::now_v7(), Uuid::now_v7());+ let (fact_a, fact_b) = (Uuid::now_v7(), Uuid::now_v7());++ sqlx::query("INSERT INTO organizations (id, name) VALUES ($1, 'crosskb-test')")+ .bind(org)+ .execute(pool)+ .await?;+ sqlx::query("INSERT INTO workspaces (id, org_id, name) VALUES ($1, $2, 'crosskb-test')")+ .bind(ws)+ .bind(org)+ .execute(pool)+ .await?;+ for kb in [a, b] {+ sqlx::query(+ "INSERT INTO knowledge_bases (id, workspace_id, name) VALUES ($1, $2, 'crosskb-test')",+ )+ .bind(kb)+ .bind(ws)+ .execute(pool)+ .await?;+ }+ for (id, kb, name) in [(doc_a, a, "a.md"), (doc_b, b, "b.md")] {+ sqlx::query(+ "INSERT INTO documents (id, kb_id, filename, sha256, status, external_key)+ VALUES ($1, $2, $3, $4, 'ready', $5)",+ )+ .bind(id)+ .bind(kb)+ .bind(name)+ .bind(format!("sha-{id}"))+ .bind(format!("file:///{name}"))+ .execute(pool)+ .await?;+ }+ for (id, kb, doc) in [(chunk_a, a, doc_a), (chunk_b, b, doc_b)] {+ sqlx::query(+ "INSERT INTO chunks (id, kb_id, document_id, seq, text) VALUES ($1, $2, $3, 0, 'x')",+ )+ .bind(id)+ .bind(kb)+ .bind(doc)+ .execute(pool)+ .await?;+ }+ for (id, kb) in [(ent_a, a), (ent_b, b)] {+ sqlx::query("INSERT INTO entities (id, kb_id, canonical_name) VALUES ($1, $2, 'e')")+ .bind(id)+ .bind(kb)+ .execute(pool)+ .await?;+ }+ for (id, kb, subject, object) in [(fact_a, a, ent_a, ent_a), (fact_b, b, ent_b, ent_b)] {+ sqlx::query("INSERT INTO facts (id, kb_id, subject_id, object_id, confidence) VALUES ($1, $2, $3, $4, 0.9)")+ .bind(id)+ .bind(kb)+ .bind(subject)+ .bind(object)+ .execute(pool)+ .await?;+ }+ Ok(TwoKbs {+ org,+ a,+ b,+ doc_a,+ doc_b,+ chunk_a,+ chunk_b,+ fact_a,+ fact_b,+ })+}++async fn cleanup(pool: &PgPool, f: &TwoKbs) -> anyhow::Result<()> {+ for kb in [f.a, f.b] {+ sqlx::query("DELETE FROM knowledge_bases WHERE id = $1")+ .bind(kb)+ .execute(pool)+ .await?;+ }+ sqlx::query("DELETE FROM organizations WHERE id = $1")+ .bind(f.org)+ .execute(pool)+ .await?;+ Ok(())+}++#[tokio::test]+async fn new_cross_kb_writes_are_rejected() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ // 触发器是 0070 带来的:测试库可能还没迁移,这里先保证约束在场+ utopia_store::db::migrate(&pool).await?;+ let f = seed(&pool).await?;++ // 事实引用别库段落:原生路径碰巧不会这么写,但 schema 从前不拦——现在拦+ let err = sqlx::query(+ "INSERT INTO fact_evidence (fact_id, chunk_id, quote, document_id, doc_version)+ VALUES ($1, $2, 'x', $3, 1)",+ )+ .bind(f.fact_a)+ .bind(f.chunk_b)+ .bind(f.doc_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "fact→foreign chunk 必须被拒");++ // 只坏冗余文档指针那一头:段落同库、文档别库+ let err = sqlx::query(+ "INSERT INTO fact_evidence (fact_id, chunk_id, quote, document_id, doc_version)+ VALUES ($1, $2, 'x', $3, 1)",+ )+ .bind(f.fact_a)+ .bind(f.chunk_a)+ .bind(f.doc_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "evidence.document→foreign 必须被拒");++ // 段落挂在别库文档下+ let err = sqlx::query(+ "INSERT INTO chunks (id, kb_id, document_id, seq, text)+ VALUES ($1, $2, $3, 0, 'x')",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.doc_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "chunk→foreign document 必须被拒");++ // 权威写入路径同一条约束:add_evidence 走 store API 也一样被拒+ let err = utopia_store::graph::add_evidence(&pool, f.fact_a, f.chunk_b, Some("x"), None).await;+ assert!(err.is_err(), "add_evidence 的跨库配对必须被拒");++ // 过户:把文档挪到别的库,等于把指着它的行一次全变坏行+ let err = sqlx::query("UPDATE documents SET kb_id = $2 WHERE id = $1")+ .bind(f.doc_a)+ .bind(f.b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "documents.kb_id 过户必须被拒");+ let err = sqlx::query("UPDATE facts SET kb_id = $2 WHERE id = $1")+ .bind(f.fact_a)+ .bind(f.b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "facts.kb_id 过户必须被拒");++ // 同库的正常写入不受影响(防误伤)+ sqlx::query(+ "INSERT INTO fact_evidence (fact_id, chunk_id, quote, document_id, doc_version)+ VALUES ($1, $2, 'ok', $3, 1)",+ )+ .bind(f.fact_a)+ .bind(f.chunk_a)+ .bind(f.doc_a)+ .execute(&pool)+ .await?;+ utopia_store::graph::add_evidence(&pool, f.fact_b, f.chunk_b, Some("ok"), None).await?;++ cleanup(&pool, &f).await+}++#[tokio::test]+async fn malformed_existing_rows_fail_the_export_closed() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ utopia_store::db::migrate(&pool).await?;+ let f = seed(&pool).await?;++ // 存量坏行:触发器只拦落在它之后的写,这种行只能绕过它造——导出侧要接住。+ // SET LOCAL 只在本事务内关触发器,提交即恢复,不会撞掉并行测试的断言窗口+ let mut conn = pool.acquire().await?;+ let mut tx = conn.begin().await?;+ sqlx::query("SET LOCAL session_replication_role = 'replica'")+ .execute(&mut *tx)+ .await?;++ // 只坏段落那一头:fact_a → chunk_b(文档指针留 NULL,隔离变量)+ sqlx::query("INSERT INTO fact_evidence (fact_id, chunk_id) VALUES ($1, $2)")+ .bind(f.fact_a)+ .bind(f.chunk_b)+ .execute(&mut *tx)+ .await?;+ // 只坏冗余文档指针:fact_b → chunk_b 本身同库,指针却指 a 的文档+ sqlx::query("INSERT INTO fact_evidence (fact_id, chunk_id, document_id) VALUES ($1, $2, $3)")+ .bind(f.fact_b)+ .bind(f.chunk_b)+ .bind(f.doc_a)+ .execute(&mut *tx)+ .await?;+ // 段落挂在别库文档下+ let stray_chunk = Uuid::now_v7();+ sqlx::query(+ "INSERT INTO chunks (id, kb_id, document_id, seq, text) VALUES ($1, $2, $3, 9, 'stray')",+ )+ .bind(stray_chunk)+ .bind(f.b)+ .bind(f.doc_a)+ .execute(&mut *tx)+ .await?;+ tx.commit().await?;+ drop(conn);++ // 体检:库 A 坏在 evidence.chunk,库 B 坏在 evidence.document 与 chunk.document+ let err_a = utopia_store::export::provenance_integrity(&mut pool.begin().await?, f.a).await;+ let msg_a = format!("{err_a:?}");+ assert!(err_a.is_err(), "库 A 的体检必须拒导");+ assert!(+ msg_a.contains("evidence.chunk"),+ "库 A 该报 evidence.chunk: {msg_a}"+ );++ let err_b = utopia_store::export::provenance_integrity(&mut pool.begin().await?, f.b).await;+ let msg_b = format!("{err_b:?}");+ assert!(err_b.is_err(), "库 B 的体检必须拒导");+ assert!(+ msg_b.contains("evidence.document"),+ "库 B 该报 evidence.document: {msg_b}"+ );++ // 逐页校验同样fail-closed:体检之后的 TOCTOU 坏行也不能漏出伪造 IRI。+ // 坏段落指针会顺着 facts_page 的 quote_origins 出去,坏文档指针顺着+ // documents[] 出去——两路都在事实页上拦+ assert!(+ utopia_store::export::facts_page(&mut pool.begin().await?, f.a, None)+ .await+ .is_err(),+ "fact_a 的 evidence.chunk 别库:事实页要拦"+ );+ assert!(+ utopia_store::export::facts_page(&mut pool.begin().await?, f.b, None)+ .await+ .is_err(),+ "fact_b 的 evidence.document 别库:事实页要拦"+ );++ // 清掉坏行,导出立刻恢复——拒的是坏行,不是库本身+ sqlx::query("DELETE FROM fact_evidence WHERE fact_id IN ($1, $2)")+ .bind(f.fact_a)+ .bind(f.fact_b)+ .execute(&pool)+ .await?;+ sqlx::query("DELETE FROM chunks WHERE id = $1")+ .bind(stray_chunk)+ .execute(&pool)+ .await?;+ utopia_store::export::provenance_integrity(&mut pool.begin().await?, f.a).await?;+ utopia_store::export::provenance_integrity(&mut pool.begin().await?, f.b).await?;++ cleanup(&pool, &f).await+}diff --git a/crates/utopia-store/tests/export_surfaces.rs b/crates/utopia-store/tests/export_surfaces.rsnew file mode 100644index 00000000..49b66dee--- /dev/null+++ b/crates/utopia-store/tests/export_surfaces.rs@@ -0,0 +1,401 @@+//! 导出取数面:单事务快照与游标边界。+//!+//! 判定在导出取数层:`provenance_integrity` 与各 page 函数吃调用方的事务——+//! 同一条连接里种行、读页、断言。除「中途提交」那条探针外(它要两条连接),+//! 所有种子与坏行都在一个**回滚的事务**里造:快照库上跑这组测试不会留下+//! 任何一行。+//!+//! 坏行靠 `SET LOCAL session_replication_role='replica'` 造:只关本事务的+//! 触发器(0070 装上的那些也一并关),回滚即恢复——要模拟的正是绕过触发器+//! 进来的存量坏行。++use sqlx::{Acquire, PgPool, Postgres, Transaction};+use utopia_store::export;+use uuid::Uuid;++struct Fixture {+ a: Uuid,+ b: Uuid,+ doc_a: Uuid,+ attr_a: Uuid,+}++/// 两个库;A 库一份文档一段一实体一事实一条证据一属性,B 库空着备查。+/// 全部在调用方的事务里落——回滚即清场,一个 DELETE 都不用+async fn seed_tx(tx: &mut Transaction<'_, Postgres>) -> anyhow::Result<Fixture> {+ let (org, ws, a, b) = (+ Uuid::now_v7(),+ Uuid::now_v7(),+ Uuid::now_v7(),+ Uuid::now_v7(),+ );+ let (doc_a, doc_b) = (Uuid::now_v7(), Uuid::now_v7());+ let (chunk_a, ent_a, ent_b, fact_a, attr_a) = (+ Uuid::now_v7(),+ Uuid::now_v7(),+ Uuid::now_v7(),+ Uuid::now_v7(),+ Uuid::now_v7(),+ );++ sqlx::query("INSERT INTO organizations (id, name) VALUES ($1, 'export-test')")+ .bind(org)+ .execute(&mut **tx)+ .await?;+ sqlx::query("INSERT INTO workspaces (id, org_id, name) VALUES ($1, $2, 'export-test')")+ .bind(ws)+ .bind(org)+ .execute(&mut **tx)+ .await?;+ for kb in [a, b] {+ sqlx::query(+ "INSERT INTO knowledge_bases (id, workspace_id, name) VALUES ($1, $2, 'export-test')",+ )+ .bind(kb)+ .bind(ws)+ .execute(&mut **tx)+ .await?;+ }+ for (id, kb, name) in [(doc_a, a, "a.md"), (doc_b, b, "b.md")] {+ sqlx::query(+ "INSERT INTO documents (id, kb_id, filename, sha256, status, external_key)+ VALUES ($1, $2, $3, $4, 'ready', $5)",+ )+ .bind(id)+ .bind(kb)+ .bind(name)+ .bind(format!("sha-{id}"))+ .bind(format!("file:///{name}"))+ .execute(&mut **tx)+ .await?;+ }+ sqlx::query(+ "INSERT INTO chunks (id, kb_id, document_id, seq, text, doc_version)+ VALUES ($1, $2, $3, 0, 'x', 1)",+ )+ .bind(chunk_a)+ .bind(a)+ .bind(doc_a)+ .execute(&mut **tx)+ .await?;+ for (id, kb) in [(ent_a, a), (ent_b, b)] {+ sqlx::query("INSERT INTO entities (id, kb_id, canonical_name) VALUES ($1, $2, 'e')")+ .bind(id)+ .bind(kb)+ .execute(&mut **tx)+ .await?;+ }+ sqlx::query(+ "INSERT INTO facts (id, kb_id, subject_id, object_id, confidence)+ VALUES ($1, $2, $3, $4, 0.9)",+ )+ .bind(fact_a)+ .bind(a)+ .bind(ent_a)+ .bind(ent_a)+ .execute(&mut **tx)+ .await?;+ sqlx::query(+ "INSERT INTO fact_evidence (fact_id, chunk_id, document_id, doc_version)+ VALUES ($1, $2, $3, 1)",+ )+ .bind(fact_a)+ .bind(chunk_a)+ .bind(doc_a)+ .execute(&mut **tx)+ .await?;+ sqlx::query(+ "INSERT INTO relation_types (id, kb_id, key, label, kind, datatype)+ VALUES ($1, $2, 'headcount', 'headcount', 'attribute', 'number')",+ )+ .bind(attr_a)+ .bind(a)+ .execute(&mut **tx)+ .await?;+ Ok(Fixture {+ a,+ b,+ doc_a,+ attr_a,+ })+}++/// 文档过户的极端形态(replica):文档挪到 B 之后,A 的证据行还指着它——+/// A 的导出宁拒也不能把别库文档铸进本库 IRI;B 没指着它,照常放行+#[tokio::test]+async fn a_reassigned_document_breaks_the_edges_that_point_at_it() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ utopia_store::db::migrate(&pool).await?;++ let mut tx = pool.begin().await?;+ let f = seed_tx(&mut tx).await?;+ sqlx::query("SET LOCAL session_replication_role = 'replica'")+ .execute(&mut *tx)+ .await?;+ sqlx::query("UPDATE documents SET kb_id = $2 WHERE id = $1")+ .bind(f.doc_a)+ .bind(f.b)+ .execute(&mut *tx)+ .await?;++ // A 的导出整体拒:evidence.document 还指着那份已经不属于本库的文档+ let err = export::provenance_integrity(&mut tx, f.a).await;+ let msg = format!("{err:?}");+ assert!(err.is_err(), "文档过户后 A 的出处链必须拒导");+ assert!(+ msg.contains("evidence.document"),+ "该报 evidence.document: {msg}"+ );+ assert!(export::facts_page(&mut tx, f.a, None).await.is_err());++ // B 收下了文档,但它没有任何指着 A 的行:它的体检照样过+ export::provenance_integrity(&mut tx, f.b).await?;+ tx.rollback().await?;+ Ok(())+}++/// 导出中途落下的写进不了这一份。tx 起 REPEATABLE READ 快照后,+/// 另一条连接提交一条新谓词+引用它的派生——本事务的词汇表页与派生页+/// 都看不见它:没有半个进来的引用,也没有悬空的 wasGeneratedBy。+/// 这条要两条连接,种子必须提交——清场照常走+#[tokio::test]+async fn a_mid_stream_commit_stays_outside_the_snapshot() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ utopia_store::db::migrate(&pool).await?;++ let (org, ws, a) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());+ let ent_a = Uuid::now_v7();+ sqlx::query("INSERT INTO organizations (id, name) VALUES ($1, 'export-race')")+ .bind(org)+ .execute(&pool)+ .await?;+ sqlx::query("INSERT INTO workspaces (id, org_id, name) VALUES ($1, $2, 'export-race')")+ .bind(ws)+ .bind(org)+ .execute(&pool)+ .await?;+ sqlx::query(+ "INSERT INTO knowledge_bases (id, workspace_id, name) VALUES ($1, $2, 'export-race')",+ )+ .bind(a)+ .bind(ws)+ .execute(&pool)+ .await?;+ sqlx::query("INSERT INTO entities (id, kb_id, canonical_name) VALUES ($1, $2, 'e')")+ .bind(ent_a)+ .bind(a)+ .execute(&pool)+ .await?;++ // 先埋一条谓词和一条引用它的派生,作为「快照内」基线+ let (rule0, pred0) = (Uuid::now_v7(), Uuid::now_v7());+ sqlx::query(+ "INSERT INTO relation_types (id, kb_id, key, label, kind)+ VALUES ($1, $2, 'p0', 'p0', 'relation')",+ )+ .bind(pred0)+ .bind(a)+ .execute(&pool)+ .await?;+ sqlx::query(+ "INSERT INTO rules (id, kb_id, predicate_id, kind) VALUES ($1, $2, $3, 'transitive')",+ )+ .bind(rule0)+ .bind(a)+ .bind(pred0)+ .execute(&pool)+ .await?;+ sqlx::query(+ "INSERT INTO derived_facts (id, kb_id, subject_id, predicate_id, object_id, rule_id)+ VALUES ($1, $2, $3, $4, $5, $6)",+ )+ .bind(Uuid::now_v7())+ .bind(a)+ .bind(ent_a)+ .bind(pred0)+ .bind(ent_a)+ .bind(rule0)+ .execute(&pool)+ .await?;++ // 导出事务:只读 REPEATABLE READ,快照从第一条语句起钉死+ let mut conn = pool.acquire().await?;+ let mut tx = conn.begin().await?;+ sqlx::query("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY")+ .execute(&mut *tx)+ .await?;+ export::provenance_integrity(&mut tx, a).await?;+ let _ = export::entities_page(&mut tx, a, None).await?;++ // 中途:另一条连接提交一条新谓词+引用它的派生事实+ let (rule_late, pred_late, derived_late) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());+ sqlx::query(+ "INSERT INTO relation_types (id, kb_id, key, label, kind)+ VALUES ($1, $2, 'p_late', 'p_late', 'relation')",+ )+ .bind(pred_late)+ .bind(a)+ .execute(&pool)+ .await?;+ sqlx::query(+ "INSERT INTO rules (id, kb_id, predicate_id, kind) VALUES ($1, $2, $3, 'transitive')",+ )+ .bind(rule_late)+ .bind(a)+ .bind(pred_late)+ .execute(&pool)+ .await?;+ sqlx::query(+ "INSERT INTO derived_facts (id, kb_id, subject_id, predicate_id, object_id, rule_id)+ VALUES ($1, $2, $3, $4, $5, $6)",+ )+ .bind(derived_late)+ .bind(a)+ .bind(ent_a)+ .bind(pred_late)+ .bind(ent_a)+ .bind(rule_late)+ .execute(&pool)+ .await?;++ // 快照里:词汇表页、派生页都不该有中途进来的行——一致性是整份的+ let relations = export::relations(&mut tx, a).await?;+ assert!(+ !relations.iter().any(|r| r.id == pred_late),+ "中途提交的谓词不许进这份导出"+ );+ let derived = export::derived_page(&mut tx, a, None).await?;+ assert!(+ !derived.iter().any(|d| d.id == derived_late),+ "中途提交的派生不许进这份导出——也就不会有悬空的 wasGeneratedBy"+ );+ assert_eq!(derived.len(), 1, "快照内的那条还在");+ tx.rollback().await?;+ drop(conn);++ // 新事务是新的快照:两条都该在+ let mut tx2 = pool.begin().await?;+ let relations = export::relations(&mut tx2, a).await?;+ assert!(relations.iter().any(|r| r.id == pred_late));+ let derived = export::derived_page(&mut tx2, a, None).await?;+ assert_eq!(derived.len(), 2);+ tx2.rollback().await?;++ sqlx::query("DELETE FROM knowledge_bases WHERE id = $1")+ .bind(a)+ .execute(&pool)+ .await?;+ sqlx::query("DELETE FROM organizations WHERE id = $1")+ .bind(org)+ .execute(&pool)+ .await?;+ Ok(())+}++/// NIL 是合法 uuid——schema 不拦它当主键。按序它排在最前;首页谓词若是+/// `id > 哨兵`,这一行就永远进不了任何一页。而指向它的引用照样解析过去:+/// 节点缺席、边在场,导出里就悬一条没有本体的引用。所有按 id 翻页的+/// 取数口——实体、事实、派生、文档——第一页都得把它翻出来+#[tokio::test]+async fn a_nil_id_row_still_reaches_the_first_page() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ utopia_store::db::migrate(&pool).await?;++ let mut tx = pool.begin().await?;+ let f = seed_tx(&mut tx).await?;+ let nil = Uuid::nil();++ // 每张走 id 游标的表各埋一行 NIL 主键;引用一律指回这些 NIL 行自己,+ // 外键不因 NIL 失效——它们跟其他行一样合法+ sqlx::query("INSERT INTO entities (id, kb_id, canonical_name) VALUES ($1, $2, 'nil-e')")+ .bind(nil)+ .bind(f.a)+ .execute(&mut *tx)+ .await?;+ sqlx::query(+ "INSERT INTO documents (id, kb_id, filename, sha256, status, external_key)+ VALUES ($1, $2, 'nil.md', 'nil-sha', 'ready', 'file:///nil.md')",+ )+ .bind(nil)+ .bind(f.a)+ .execute(&mut *tx)+ .await?;+ sqlx::query(+ "INSERT INTO facts (id, kb_id, subject_id, predicate_id, object_id, confidence)+ VALUES ($1, $2, $3, $4, $3, 0.9)",+ )+ .bind(nil)+ .bind(f.a)+ .bind(nil)+ .bind(f.attr_a)+ .execute(&mut *tx)+ .await?;+ let (pred_r, rule_r) = (Uuid::now_v7(), Uuid::now_v7());+ sqlx::query(+ "INSERT INTO relation_types (id, kb_id, key, label, kind)+ VALUES ($1, $2, 'rel_p', 'rel_p', 'relation')",+ )+ .bind(pred_r)+ .bind(f.a)+ .execute(&mut *tx)+ .await?;+ sqlx::query(+ "INSERT INTO rules (id, kb_id, predicate_id, kind) VALUES ($1, $2, $3, 'transitive')",+ )+ .bind(rule_r)+ .bind(f.a)+ .bind(pred_r)+ .execute(&mut *tx)+ .await?;+ sqlx::query(+ "INSERT INTO derived_facts (id, kb_id, subject_id, predicate_id, object_id, rule_id)+ VALUES ($1, $2, $3, $4, $3, $5)",+ )+ .bind(nil)+ .bind(f.a)+ .bind(nil)+ .bind(pred_r)+ .bind(rule_r)+ .execute(&mut *tx)+ .await?;++ assert!(+ export::entities_page(&mut tx, f.a, None)+ .await?+ .iter()+ .any(|e| e.id == nil),+ "entities 首页漏掉 NIL 行"+ );+ assert!(+ export::documents_page(&mut tx, f.a, None)+ .await?+ .iter()+ .any(|d| d.id == nil),+ "documents 首页漏掉 NIL 行"+ );+ assert!(+ export::facts_page(&mut tx, f.a, None)+ .await?+ .iter()+ .any(|x| x.id == nil),+ "facts 首页漏掉 NIL 行"+ );+ assert!(+ export::derived_page(&mut tx, f.a, None)+ .await?+ .iter()+ .any(|d| d.id == nil),+ "derived 首页漏掉 NIL 行"+ );+ tx.rollback().await?;+ Ok(())+}diff --git a/crates/utopia-store/tests/exported_references_never_cross_a_kb.rs b/crates/utopia-store/tests/exported_references_never_cross_a_kb.rsnew file mode 100644index 00000000..15f36bc3--- /dev/null+++ b/crates/utopia-store/tests/exported_references_never_cross_a_kb.rs@@ -0,0 +1,843 @@+//! 写入侧:导出会触碰的每条边都被 0070 的外键/触发器挡住;导出侧只复查+//! 这份导出真正解析的那些引用——别库/悬空的行宁可整份拒导,也不许+//! 伪造 IRI 或静默丢语义。落到别库的下场分两种:+//! - 铸成本库 IRI 的引用(实体、事实、派生、文档、段落、规则)→ 伪造身份;+//! - 进本库词汇表按 id 查的引用(谓词、属性类型、实体类型、父类)→ 静默消失。+//!+//! 两种都是坏行,触发器与导出侧一律拒。+//!+//! 坏行靠 `SET LOCAL session_replication_role='replica'` 造——只关本事务的+//! 触发器(含 FK 强制),提交即恢复;这同时允许造出「指着的行已不在」的+//! 悬空引用,正是从 0070 之前的备份恢复进来的形态。++use sqlx::{Acquire, PgPool};+use uuid::Uuid;++struct Fixture {+ org: Uuid,+ a: Uuid,+ b: Uuid,+ doc_a: Uuid,+ chunk_a: Uuid,+ chunk_b: Uuid,+ ent_a: Uuid,+ ent_b: Uuid,+ fact_a: Uuid,+ fact_b: Uuid,+ rel_a: Uuid,+ rel_b: Uuid,+ cls_a: Uuid,+ cls_b: Uuid,+ rule_a: Uuid,+ rule_b: Uuid,+ arule_a: Uuid,+ arule_b: Uuid,+ der_a: Uuid,+ der_b: Uuid,+}++/// 两库,每库一套能被引用的零件:文档/段落/实体/事实/谓词/类/公理规则/业务规则/派生+async fn seed(pool: &PgPool) -> anyhow::Result<Fixture> {+ let (org, ws, a, b) = (+ Uuid::now_v7(),+ Uuid::now_v7(),+ Uuid::now_v7(),+ Uuid::now_v7(),+ );+ let (doc_a, doc_b) = (Uuid::now_v7(), Uuid::now_v7());+ let (chunk_a, chunk_b) = (Uuid::now_v7(), Uuid::now_v7());+ let (ent_a, ent_b) = (Uuid::now_v7(), Uuid::now_v7());+ let (fact_a, fact_b) = (Uuid::now_v7(), Uuid::now_v7());+ let (rel_a, rel_b) = (Uuid::now_v7(), Uuid::now_v7());+ let (cls_a, cls_b) = (Uuid::now_v7(), Uuid::now_v7());+ let (rule_a, rule_b) = (Uuid::now_v7(), Uuid::now_v7());+ let (arule_a, arule_b) = (Uuid::now_v7(), Uuid::now_v7());+ let (der_a, der_b) = (Uuid::now_v7(), Uuid::now_v7());++ sqlx::query("INSERT INTO organizations (id, name) VALUES ($1, 'xkb-ref-test')")+ .bind(org)+ .execute(pool)+ .await?;+ sqlx::query("INSERT INTO workspaces (id, org_id, name) VALUES ($1, $2, 'xkb-ref-test')")+ .bind(ws)+ .bind(org)+ .execute(pool)+ .await?;+ for kb in [a, b] {+ sqlx::query(+ "INSERT INTO knowledge_bases (id, workspace_id, name) VALUES ($1, $2, 'xkb-ref-test')",+ )+ .bind(kb)+ .bind(ws)+ .execute(pool)+ .await?;+ }+ sqlx::query(+ "INSERT INTO documents (id, kb_id, filename, sha256, status, external_key)+ VALUES ($1, $2, 'a.md', 'sha-a', 'ready', 'file:///a.md')",+ )+ .bind(doc_a)+ .bind(a)+ .execute(pool)+ .await?;+ sqlx::query(+ "INSERT INTO documents (id, kb_id, filename, sha256, status, external_key)+ VALUES ($1, $2, 'b.md', 'sha-b', 'ready', 'file:///b.md')",+ )+ .bind(doc_b)+ .bind(b)+ .execute(pool)+ .await?;+ sqlx::query(+ "INSERT INTO chunks (id, kb_id, document_id, seq, text) VALUES ($1, $2, $3, 0, 'x')",+ )+ .bind(chunk_a)+ .bind(a)+ .bind(doc_a)+ .execute(pool)+ .await?;+ sqlx::query(+ "INSERT INTO chunks (id, kb_id, document_id, seq, text) VALUES ($1, $2, $3, 0, 'x')",+ )+ .bind(chunk_b)+ .bind(b)+ .bind(doc_b)+ .execute(pool)+ .await?;+ for (id, kb) in [(ent_a, a), (ent_b, b)] {+ sqlx::query("INSERT INTO entities (id, kb_id, canonical_name) VALUES ($1, $2, 'e')")+ .bind(id)+ .bind(kb)+ .execute(pool)+ .await?;+ }+ for (id, kb, s, o) in [(fact_a, a, ent_a, ent_a), (fact_b, b, ent_b, ent_b)] {+ sqlx::query(+ "INSERT INTO facts (id, kb_id, subject_id, object_id, confidence)+ VALUES ($1, $2, $3, $4, 0.9)",+ )+ .bind(id)+ .bind(kb)+ .bind(s)+ .bind(o)+ .execute(pool)+ .await?;+ }+ for (id, kb) in [(rel_a, a), (rel_b, b)] {+ sqlx::query("INSERT INTO relation_types (id, kb_id, key, label) VALUES ($1, $2, $3, 'r')")+ .bind(id)+ .bind(kb)+ .bind(format!("r-{id}"))+ .execute(pool)+ .await?;+ }+ for (id, kb) in [(cls_a, a), (cls_b, b)] {+ sqlx::query("INSERT INTO entity_types (id, kb_id, key, label) VALUES ($1, $2, $3, 'c')")+ .bind(id)+ .bind(kb)+ .bind(format!("c-{id}"))+ .execute(pool)+ .await?;+ }+ for (id, kb, pred) in [(rule_a, a, rel_a), (rule_b, b, rel_b)] {+ sqlx::query(+ "INSERT INTO rules (id, kb_id, predicate_id, kind) VALUES ($1, $2, $3, 'transitive')",+ )+ .bind(id)+ .bind(kb)+ .bind(pred)+ .execute(pool)+ .await?;+ }+ for (id, kb, ty, pred) in [(arule_a, a, cls_a, rel_a), (arule_b, b, cls_b, rel_b)] {+ sqlx::query(+ "INSERT INTO attribute_rules (id, kb_id, name, subject_type_id, conclusion,+ conclude_predicate_id, conclude_value)+ VALUES ($1, $2, $3, $4, 'attribute', $5, '42'::jsonb)",+ )+ .bind(id)+ .bind(kb)+ .bind(format!("ar-{id}"))+ .bind(ty)+ .bind(pred)+ .execute(pool)+ .await?;+ }+ for (id, kb, s, p, o, r) in [+ (der_a, a, ent_a, rel_a, ent_a, rule_a),+ (der_b, b, ent_b, rel_b, ent_b, rule_b),+ ] {+ sqlx::query(+ "INSERT INTO derived_facts (id, kb_id, subject_id, predicate_id, object_id, rule_id)+ VALUES ($1, $2, $3, $4, $5, $6)",+ )+ .bind(id)+ .bind(kb)+ .bind(s)+ .bind(p)+ .bind(o)+ .bind(r)+ .execute(pool)+ .await?;+ }+ Ok(Fixture {+ org,+ a,+ b,+ doc_a,+ chunk_a,+ chunk_b,+ ent_a,+ ent_b,+ fact_a,+ fact_b,+ rel_a,+ rel_b,+ cls_a,+ cls_b,+ rule_a,+ rule_b,+ arule_a,+ arule_b,+ der_a,+ der_b,+ })+}++async fn cleanup(pool: &PgPool, f: &Fixture) -> anyhow::Result<()> {+ for kb in [f.a, f.b] {+ sqlx::query("DELETE FROM knowledge_bases WHERE id = $1")+ .bind(kb)+ .execute(pool)+ .await?;+ }+ sqlx::query("DELETE FROM organizations WHERE id = $1")+ .bind(f.org)+ .execute(pool)+ .await?;+ Ok(())+}++/// 新的跨库写:每条边都被它自己的触发器当场挡下+#[tokio::test]+async fn new_cross_kb_writes_are_rejected_on_every_exported_edge() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ utopia_store::db::migrate(&pool).await?;+ let f = seed(&pool).await?;++ // —— 派生的前提:两种前提,两种越库形态+ for (premise_fact, premise_derived, what) in [+ (Some(f.fact_b), None, "foreign fact premise"),+ (None, Some(f.der_b), "foreign derived premise"),+ ] {+ let err = sqlx::query(+ "INSERT INTO fact_derivations (derived_fact_id, premise_fact_id, premise_derived_id, seq)+ VALUES ($1, $2, $3, 0)",+ )+ .bind(f.der_a)+ .bind(premise_fact)+ .bind(premise_derived)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "derivation premise: {what} 必须被拒");+ }++ // —— 边上的属性:别库类型会被词汇表静默跳过,别库实体会被铸进本库 IRI+ let err = sqlx::query(+ "INSERT INTO fact_qualifiers (fact_id, qualifier_type_id, value)+ VALUES ($1, $2, '\"lit\"'::jsonb)",+ )+ .bind(f.fact_a)+ .bind(f.rel_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "qualifier.type→foreign 必须被拒");+ let err = sqlx::query(+ "INSERT INTO fact_qualifiers (fact_id, qualifier_type_id, entity_id)+ VALUES ($1, $2, $3)",+ )+ .bind(f.fact_a)+ .bind(f.rel_a)+ .bind(f.ent_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "qualifier.entity→foreign 必须被拒");++ // —— 事实本体的五个引用列(from_statement_id 是同表自指:immediate 端在+ // BEFORE 触发器上,目标早已在场时当场拒)+ for (col, foreign_id, what) in [+ ("subject_id", f.ent_b, "fact.subject"),+ ("object_id", f.ent_b, "fact.object"),+ ("predicate_id", f.rel_b, "fact.predicate"),+ ("supersedes", f.fact_b, "fact.supersedes"),+ ("from_statement_id", f.fact_b, "fact.from_statement"),+ ] {+ let err = sqlx::query(&format!(+ "INSERT INTO facts (id, kb_id, subject_id, {col}) VALUES ($1, $2, $3, $4)"+ ))+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(if col == "subject_id" {+ f.ent_b+ } else {+ f.ent_a+ })+ .bind(foreign_id)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "{what}→foreign 必须被拒");+ }++ // —— 陈述来源(typed_fact_sources,0068):行自己没有 kb 列,归属按所属+ // fact 的库判——A 的事实吃 B 的陈述,序列化会铸出指着别库陈述的边+ let err = sqlx::query("INSERT INTO typed_fact_sources (fact_id, statement_id) VALUES ($1, $2)")+ .bind(f.fact_a)+ .bind(f.fact_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "factsource.statement→foreign 必须被拒");++ // —— 开放陈述的属性(statement_qualifiers,0061):行没有 kb 列,归属按+ // 所属 fact 的库判;别库的实体值会被铸进本库 IRI+ let err = sqlx::query(+ "INSERT INTO statement_qualifiers (fact_id, role, entity_id)+ VALUES ($1, 'as', $2)",+ )+ .bind(f.fact_a)+ .bind(f.ent_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "squalifier.entity→foreign 必须被拒");++ // —— 时间提及(0061/0064):提及自己的 kb 必须与它指的事实、段落同属一库+ let err = sqlx::query(+ "INSERT INTO time_mentions (id, kb_id, fact_id, chunk_id, text, char_start)+ VALUES ($1, $2, $3, $4, '去年', 0)",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.fact_b) // 事实在别库+ .bind(f.chunk_a)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "timemention.fact→foreign 必须被拒");+ let err = sqlx::query(+ "INSERT INTO time_mentions (id, kb_id, fact_id, chunk_id, text, char_start)+ VALUES ($1, $2, $3, $4, '去年', 0)",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.fact_a)+ .bind(f.chunk_b) // 段落在别库+ .execute(&pool)+ .await;+ assert!(err.is_err(), "timemention.chunk→foreign 必须被拒");++ // —— 类型与短语绑定(0065/0066):绑定的类/属性以绑定行自己的库为准+ let err = sqlx::query(+ "INSERT INTO type_bindings (id, kb_id, kind_word, status, type_id)+ VALUES ($1, $2, 'corp', 'bound', $3)",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.cls_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "binding.type→foreign 必须被拒");+ let err = sqlx::query(+ "INSERT INTO phrase_bindings (id, kb_id, phrase, subject_type_id, status)+ VALUES ($1, $2, 'runs', $3, 'none')",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.cls_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "pbinding.subject_type→foreign 必须被拒");+ let err = sqlx::query(+ "INSERT INTO phrase_bindings (id, kb_id, phrase, relation_type_id,+ direction, status)+ VALUES ($1, $2, 'runs', $3, 'forward', 'bound')",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.rel_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "pbinding.relation→foreign 必须被拒");++ // —— 派生事实本体的五个引用列+ for (col, foreign_id, what) in [+ ("subject_id", f.ent_b, "derived.subject"),+ ("object_id", f.ent_b, "derived.object"),+ ("predicate_id", f.rel_b, "derived.predicate"),+ ("rule_id", f.rule_b, "derived.rule"),+ ("attribute_rule_id", f.arule_b, "derived.attribute_rule"),+ ] {+ // attribute_rule 与 rule 互斥:测 attribute_rule 那行不带 rule_id+ let err = if col == "attribute_rule_id" {+ sqlx::query(+ "INSERT INTO derived_facts (id, kb_id, subject_id, predicate_id, attribute_rule_id)+ VALUES ($1, $2, $3, $4, $5)",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.ent_a)+ .bind(f.rel_a)+ .bind(foreign_id)+ .execute(&pool)+ .await+ } else {+ sqlx::query(&format!(+ "INSERT INTO derived_facts (id, kb_id, subject_id, predicate_id, rule_id, {col})+ VALUES ($1, $2, $3, $4, $5, $6)"+ ))+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(if col == "subject_id" {+ f.ent_b+ } else {+ f.ent_a+ })+ .bind(if col == "predicate_id" {+ f.rel_b+ } else {+ f.rel_a+ })+ .bind(if col == "rule_id" { f.rule_b } else { f.rule_a })+ .bind(foreign_id)+ .execute(&pool)+ .await+ };+ assert!(err.is_err(), "{what}→foreign 必须被拒");+ }++ // —— 实体的类、类层级、互斥、domain/range+ let err = sqlx::query(+ "INSERT INTO entities (id, kb_id, canonical_name, type_id) VALUES ($1, $2, 'e', $3)",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.cls_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "entity.type→foreign 必须被拒");++ let err = sqlx::query("INSERT INTO entity_type_parents (child_id, parent_id) VALUES ($1, $2)")+ .bind(f.cls_a)+ .bind(f.cls_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "class.parent→foreign 必须被拒");++ let err =+ sqlx::query("INSERT INTO entity_type_disjoint (kb_id, a_id, b_id) VALUES ($1, $2, $3)")+ .bind(f.a)+ .bind(f.cls_a)+ .bind(f.cls_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "class.disjoint→foreign 必须被拒");++ for (table, what) in [+ ("relation_type_domains", "relation.domain"),+ ("relation_type_ranges", "relation.range"),+ ] {+ let err = sqlx::query(&format!(+ "INSERT INTO {table} (relation_type_id, entity_type_id) VALUES ($1, $2)"+ ))+ .bind(f.rel_a)+ .bind(f.cls_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "{what}→foreign 必须被拒");+ }++ // —— 关系的同表自指与边属性声明:owl:inverseOf /+ // rdfs:subPropertyOf 与 qualifier 列表都是语义,别库的不许进来+ let err = sqlx::query(+ "INSERT INTO relation_types (id, kb_id, key, label, inverse_of) VALUES ($1, $2, 'inv', 'inv', $3)",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.rel_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "relation.inverse→foreign 必须被拒");+ let err = sqlx::query(+ "INSERT INTO relation_types (id, kb_id, key, label, sub_property_of) VALUES ($1, $2, 'sub', 'sub', $3)",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.rel_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "relation.sub_property→foreign 必须被拒");+ let err = sqlx::query(+ "INSERT INTO relation_type_qualifiers (relation_type_id, qualifier_type_id) VALUES ($1, $2)",+ )+ .bind(f.rel_a)+ .bind(f.rel_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "relation.qualifier→foreign 必须被拒");++ // —— 规则本体:公理编在哪个谓词上、业务规则看什么类得什么结论,+ // 现在都在导出里——它们的引用同样不许跨库+ let err = sqlx::query(+ "INSERT INTO rules (id, kb_id, predicate_id, kind) VALUES ($1, $2, $3, 'transitive')",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.rel_b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "rule.predicate→foreign 必须被拒");+ // 每条结论形状自己的必填列(CHECK 钉死了 typing/attribute/computed 的列组),+ // 一个引用列一种合法形状+ let err = sqlx::query(+ "INSERT INTO attribute_rules (id, kb_id, name, subject_type_id, conclusion,+ conclude_predicate_id, conclude_value)+ VALUES ($1, $2, 'ar', $3, 'attribute', $4, '42'::jsonb)",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.cls_b) // subject_type 别库+ .bind(f.rel_a)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "arule.subject_type→foreign 必须被拒");+ let err = sqlx::query(+ "INSERT INTO attribute_rules (id, kb_id, name, subject_type_id, conclusion,+ conclude_type_id)+ VALUES ($1, $2, 'ar', $3, 'typing', $4)",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.cls_a)+ .bind(f.cls_b) // conclude_type 别库+ .execute(&pool)+ .await;+ assert!(err.is_err(), "arule.conclude_type→foreign 必须被拒");+ let err = sqlx::query(+ "INSERT INTO attribute_rules (id, kb_id, name, subject_type_id, conclusion,+ conclude_predicate_id, conclude_value)+ VALUES ($1, $2, 'ar', $3, 'attribute', $4, '42'::jsonb)",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.cls_a)+ .bind(f.rel_b) // conclude_predicate 别库+ .execute(&pool)+ .await;+ assert!(err.is_err(), "arule.conclude_predicate→foreign 必须被拒");++ // —— kb 过户:把已被引用的行挪到别的库,等于把指着它的行一次全变坏行+ for (table, id, what) in [+ ("entities", f.ent_a, "entities.kb_id"),+ ("entity_types", f.cls_a, "entity_types.kb_id"),+ ("relation_types", f.rel_a, "relation_types.kb_id"),+ ("derived_facts", f.der_a, "derived_facts.kb_id"),+ ("rules", f.rule_a, "rules.kb_id"),+ ("attribute_rules", f.arule_a, "attribute_rules.kb_id"),+ ] {+ let err = sqlx::query(&format!("UPDATE {table} SET kb_id = $2 WHERE id = $1"))+ .bind(id)+ .bind(f.b)+ .execute(&pool)+ .await;+ assert!(err.is_err(), "{what} 过户必须被拒");+ }++ // —— 防误伤:同库的合法写入照常+ sqlx::query(+ "INSERT INTO fact_derivations (derived_fact_id, premise_fact_id, seq)+ VALUES ($1, $2, 0)",+ )+ .bind(f.der_a)+ .bind(f.fact_a)+ .execute(&pool)+ .await?;+ sqlx::query(+ "INSERT INTO fact_qualifiers (fact_id, qualifier_type_id, entity_id)+ VALUES ($1, $2, $3)",+ )+ .bind(f.fact_a)+ .bind(f.rel_a)+ .bind(f.ent_a)+ .execute(&pool)+ .await?;++ cleanup(&pool, &f).await+}++/// 存量坏行:体检报出正确的边,对应的页读取同样拒+#[tokio::test]+async fn malformed_rows_fail_every_exported_edge_closed() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ utopia_store::db::migrate(&pool).await?;+ let f = seed(&pool).await?;++ let mut conn = pool.acquire().await?;+ let mut tx = conn.begin().await?;+ sqlx::query("SET LOCAL session_replication_role = 'replica'")+ .execute(&mut *tx)+ .await?;++ // 每条边造一行坏行——全部落在库 A 身上+ sqlx::query(+ "INSERT INTO fact_derivations (derived_fact_id, premise_fact_id, seq)+ VALUES ($1, $2, 0)",+ )+ .bind(f.der_a)+ .bind(f.fact_b)+ .execute(&mut *tx)+ .await?;+ sqlx::query(+ "INSERT INTO fact_derivations (derived_fact_id, premise_derived_id, seq)+ VALUES ($1, $2, 1)",+ )+ .bind(f.der_a)+ .bind(f.der_b)+ .execute(&mut *tx)+ .await?;+ sqlx::query(+ "INSERT INTO fact_qualifiers (fact_id, qualifier_type_id, value)+ VALUES ($1, $2, '\"lit\"'::jsonb)",+ )+ .bind(f.fact_a)+ .bind(f.rel_b)+ .execute(&mut *tx)+ .await?;+ sqlx::query(+ "INSERT INTO fact_qualifiers (fact_id, qualifier_type_id, entity_id)+ VALUES ($1, $2, $3)",+ )+ .bind(f.fact_a)+ .bind(f.rel_a)+ .bind(f.ent_b)+ .execute(&mut *tx)+ .await?;+ // 事实的 supersedes 指向别库事实+ sqlx::query("UPDATE facts SET supersedes = $2 WHERE id = $1")+ .bind(f.fact_a)+ .bind(f.fact_b)+ .execute(&mut *tx)+ .await?;+ // 陈述来源指着别库陈述(typed_fact_sources 与 from_statement_id 两条路)+ sqlx::query("INSERT INTO typed_fact_sources (fact_id, statement_id) VALUES ($1, $2)")+ .bind(f.fact_a)+ .bind(f.fact_b)+ .execute(&mut *tx)+ .await?;+ sqlx::query("UPDATE facts SET from_statement_id = $2 WHERE id = $1")+ .bind(f.fact_a)+ .bind(f.fact_b)+ .execute(&mut *tx)+ .await?;+ // 开放陈述的属性值指着别库实体+ sqlx::query(+ "INSERT INTO statement_qualifiers (fact_id, role, entity_id)+ VALUES ($1, 'as', $2)",+ )+ .bind(f.fact_a)+ .bind(f.ent_b)+ .execute(&mut *tx)+ .await?;+ // 时间提及两种坏法:归属在 A 却指着 B 的段落(体检扫得见——行按自己的+ // kb 计数);归属在 B 却挂在 A 的事实上(按事实取回时,页校验拦它)+ sqlx::query(+ "INSERT INTO time_mentions (id, kb_id, fact_id, chunk_id, text, char_start)+ VALUES ($1, $2, $3, $4, '去年', 0)",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.fact_a)+ .bind(f.chunk_b)+ .execute(&mut *tx)+ .await?;+ sqlx::query(+ "INSERT INTO time_mentions (id, kb_id, fact_id, chunk_id, text, char_start)+ VALUES ($1, $2, $3, $4, '前年', 2)",+ )+ .bind(Uuid::now_v7())+ .bind(f.b)+ .bind(f.fact_a)+ .bind(f.chunk_a)+ .execute(&mut *tx)+ .await?;+ // 类型绑定指着别库的类+ sqlx::query(+ "INSERT INTO type_bindings (id, kb_id, kind_word, status, type_id)+ VALUES ($1, $2, 'corp', 'bound', $3)",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.cls_b)+ .execute(&mut *tx)+ .await?;+ // 短语绑定指着别库的属性+ sqlx::query(+ "INSERT INTO phrase_bindings (id, kb_id, phrase, relation_type_id,+ direction, status)+ VALUES ($1, $2, 'runs', $3, 'forward', 'bound')",+ )+ .bind(Uuid::now_v7())+ .bind(f.a)+ .bind(f.rel_b)+ .execute(&mut *tx)+ .await?;+ // 派生的公理规则换库+ sqlx::query("UPDATE derived_facts SET rule_id = $2 WHERE id = $1")+ .bind(f.der_a)+ .bind(f.rule_b)+ .execute(&mut *tx)+ .await?;+ // 实体的类换库+ sqlx::query("UPDATE entities SET type_id = $2 WHERE id = $1")+ .bind(f.ent_a)+ .bind(f.cls_b)+ .execute(&mut *tx)+ .await?;+ // 类层级与 domain/range+ sqlx::query("INSERT INTO entity_type_parents (child_id, parent_id) VALUES ($1, $2)")+ .bind(f.cls_a)+ .bind(f.cls_b)+ .execute(&mut *tx)+ .await?;+ sqlx::query(+ "INSERT INTO relation_type_domains (relation_type_id, entity_type_id) VALUES ($1, $2)",+ )+ .bind(f.rel_a)+ .bind(f.cls_b)+ .execute(&mut *tx)+ .await?;+ tx.commit().await?;+ drop(conn);++ let err = utopia_store::export::provenance_integrity(&mut pool.begin().await?, f.a).await;+ let msg = format!("{err:?}");+ assert!(err.is_err(), "库 A 的体检必须拒导");+ // 体检只报这份导出真正解析的边:陈述来源、开放陈述属性、时间提及、+ // 类型/短语绑定这些行上面同样埋了坏行,但导出现在不读它们——它们随+ // 各自的导出面一起带上自己的校验+ for edge in [+ "derivation.premise_fact",+ "derivation.premise_derived",+ "qualifier.type",+ "qualifier.entity",+ "fact.supersedes",+ "derived.rule",+ "entity.type",+ "class.parent",+ "relation.domain",+ ] {+ assert!(msg.contains(edge), "体检该报 {edge}: {msg}");+ }++ // 逐页校验:坏行落在哪页,哪页就拒——不能漏出伪造 IRI+ assert!(+ utopia_store::export::facts_page(&mut pool.begin().await?, f.a, None)+ .await+ .is_err()+ );+ assert!(+ utopia_store::export::derived_page(&mut pool.begin().await?, f.a, None)+ .await+ .is_err()+ );+ assert!(+ utopia_store::export::entities_page(&mut pool.begin().await?, f.a, None)+ .await+ .is_err()+ );+ assert!(utopia_store::export::classes(&mut pool.begin().await?, f.a)+ .await+ .is_err());+ assert!(+ utopia_store::export::relations(&mut pool.begin().await?, f.a)+ .await+ .is_err()+ );++ cleanup(&pool, &f).await+}++/// 留下的行才参与校验:被引的行在两次读之间消失,判违规的是+/// **随页原子选出的归属**,不是事后另一个时刻的 JOIN——悬空引用照样拒+#[tokio::test]+async fn retained_row_validation_survives_dangling_and_late_state() -> anyhow::Result<()> {+ let Some(url) = utopia_store::test_db::url() else {+ return Ok(());+ };+ let pool = PgPool::connect(&url).await?;+ utopia_store::db::migrate(&pool).await?;+ let f = seed(&pool).await?;++ // 合法证据先行+ sqlx::query("INSERT INTO fact_evidence (fact_id, chunk_id, document_id) VALUES ($1, $2, $3)")+ .bind(f.fact_a)+ .bind(f.chunk_a)+ .bind(f.doc_a)+ .execute(&pool)+ .await?;+ utopia_store::export::facts_page(&mut pool.begin().await?, f.a, None).await?;++ // 绕过触发器把文档删掉:evidence 行还指着它——悬空不是「不存在所以跳过」+ let mut conn = pool.acquire().await?;+ let mut tx = conn.begin().await?;+ sqlx::query("SET LOCAL session_replication_role = 'replica'")+ .execute(&mut *tx)+ .await?;+ sqlx::query("DELETE FROM documents WHERE id = $1")+ .bind(f.doc_a)+ .execute(&mut *tx)+ .await?;+ tx.commit().await?;+ drop(conn);++ let err = utopia_store::export::facts_page(&mut pool.begin().await?, f.a, None).await;+ let msg = format!("{err:?}");+ assert!(err.is_err(), "悬空 document 指针必须拒");+ assert!(+ msg.contains("evidence.document"),+ "该报 evidence.document: {msg}"+ );++ // 同理:前提行被删,derived 的前提数组仍留着死指针——逐页校验要拦+ sqlx::query(+ "INSERT INTO fact_derivations (derived_fact_id, premise_fact_id, seq)+ VALUES ($1, $2, 0)",+ )+ .bind(f.der_a)+ .bind(f.fact_a)+ .execute(&pool)+ .await?;+ let mut conn = pool.acquire().await?;+ let mut tx = conn.begin().await?;+ sqlx::query("SET LOCAL session_replication_role = 'replica'")+ .execute(&mut *tx)+ .await?;+ sqlx::query("DELETE FROM facts WHERE id = $1")+ .bind(f.fact_a)+ .execute(&mut *tx)+ .await?;+ tx.commit().await?;+ drop(conn);++ let err = utopia_store::export::derived_page(&mut pool.begin().await?, f.a, None).await;+ let msg = format!("{err:?}");+ assert!(err.is_err(), "悬空前提必须拒");+ assert!(+ msg.contains("derivation.premise_fact"),+ "该报 derivation.premise_fact: {msg}"+ );++ cleanup(&pool, &f).await+}