World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
//! 导出取数面:单事务快照与游标边界。
//!
//! 判定在导出取数层:`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(())
}