World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
One typed fact for many statements (#753)
WaylandYangea5b0f6381b2
diff --git a/crates/utopia-server/src/phrase_alignment.rs b/crates/utopia-server/src/phrase_alignment.rsindex 514786a7..dc520939 100644--- a/crates/utopia-server/src/phrase_alignment.rs+++ b/crates/utopia-server/src/phrase_alignment.rs@@ -307,8 +307,8 @@ async fn align_phrases_locked(tracing::info!(%kb_id, bound, none, undecided, skipped, failed, "短语对齐完成");// 绑定定了,视图跟着算:绑上的签名下的陈述成类型化行,绑定变了的行作废(0067)let typed = utopia_store::materialize::materialize(pool, kb_id).await?;- tracing::info!(%kb_id, added = typed.added, retired = typed.retired, "类型化事实按绑定算完");- if typed.added > 0 || typed.retired > 0 {+ tracing::info!(%kb_id, added = typed.added, merged = typed.merged, retired = typed.retired, "类型化事实按绑定算完");+ if typed.added > 0 || typed.merged > 0 || typed.retired > 0 {state.emit_graph(kb_id);}// 这一轮跑着的时候世界没停:新文档带来新签名,改了的属性让刚判的绑定过期,本轮没排上diff --git a/crates/utopia-store/src/materialize.rs b/crates/utopia-store/src/materialize.rsindex cde67cd5..51c8bcf0 100644--- a/crates/utopia-store/src/materialize.rs+++ b/crates/utopia-store/src/materialize.rs@@ -1,20 +1,26 @@-//! 绑上的签名下的开放陈述算成类型化事实(0044 决定 3 的第三片,见 0067)。+//! 绑上的签名下的开放陈述算成类型化事实(0044 决定 3 的第三、四片,见 0067、0068)。//!-//! 类型化图谱是视图:一条类型化行 = 一条开放陈述 × 它签名的绑定。谓词是绑定给的属性,-//! 主宾按绑定的方向(reverse 就是陈述的宾语当主语),字面值、世界轴时间、来源时间、-//! 置信度照抄,证据与限定各复制一份,`from_statement_id` 指回那条陈述。带 mood 限定的-//! 陈述不算。+//! 类型化图谱是视图:一条类型化行 = 一个三元组,来自一条或几条开放陈述与它们签名的绑定。+//! 谓词是绑定给的属性,主宾按绑定的方向(reverse 就是陈述的宾语当主语),字面值、世界轴+//! 时间、来源时间、置信度从陈述来;证据与限定各复制一份;来源记在 `typed_fact_sources`,+//! `from_statement_id` 是第一条。带 mood 限定的陈述不算。//!-//! 重算是集合运算,跑多少遍结果一样:先作废「源头不成立」的类型化行(陈述作废了、签名-//! 不再绑着、绑到了别的属性或反了方向),再给「该有而没有」的陈述补一行。绑定不变的行-//! 不动——它们的 id、证据和记录时间都留着。没有模型调用。+//! 写行走类型化图谱本来的门([`crate::graph::insert_fact`] / [`insert_value_fact`]):同断言+//! 同起点复用那一行,裸行被带时间的观察取代并链上,「结束了」关上开着的行——两份文档说+//! 同一件事,时间线上是一条边。+//!+//! 重算是集合运算,跑多少遍结果一样:先删「不再成立」的来源(陈述作废了、签名不再绑着、+//! 绑到了别的属性或反了方向、行本身作废了),再作废来源全空的类型化行,最后给「该有而+//! 没有」的(陈述, 绑定)对补上——有同断言的行就并进去,没有才新建。没有模型调用。use sqlx::PgPool;use utopia_core::AppResult;use uuid::Uuid;+use crate::graph::{insert_fact, insert_value_fact, Validity};+/// 陈述与绑定对得上的条件:短语归一后相等,两端的类相同(空也相同),宾语是不是字面值相同。-/// 两处 SQL 共用;`s` 是开放陈述(facts),`se`/`oe` 是它两端的实体,`b` 是 phrase_bindings+/// `s` 是开放陈述(facts),`se`/`oe` 是它两端的实体,`b` 是 phrase_bindingsconst MATCH: &str = "b.kb_id = s.kb_idAND b.phrase = lower(btrim(regexp_replace(s.phrase, '\\s+', ' ', 'g')))AND b.subject_type_id IS NOT DISTINCT FROM se.type_id@@ -24,30 +30,47 @@ const MATCH: &str = "b.kb_id = s.kb_id/// 一轮重算写了什么。#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]pub struct Outcome {- /// 作废的类型化行+ /// 作废的类型化行(来源全空了)pub retired: u64,- /// 新算出来的类型化行+ /// 新建的类型化行pub added: u64,+ /// 并进已有行的陈述数+ pub merged: u64,+}++/// 一条该物化的(陈述, 绑定)对,连陈述上要抄的东西。+#[derive(sqlx::FromRow)]+struct Due {+ statement: Uuid,+ property: Uuid,+ direction: String,+ subject_id: Uuid,+ object_id: Option<Uuid>,+ object_value: Option<serde_json::Value>,+ valid_from: Option<chrono::DateTime<chrono::Utc>>,+ valid_from_precision: Option<String>,+ valid_to: Option<chrono::DateTime<chrono::Utc>>,+ valid_to_precision: Option<String>,+ attested_from: Option<chrono::DateTime<chrono::Utc>>,+ confidence: f32,}/// 对一个库重算一遍。pub async fn materialize(pool: &PgPool, kb_id: Uuid) -> AppResult<Outcome> {- let mut tx = pool.begin().await?;-- // 1. 作废源头不成立的:陈述死了、签名没绑着、属性或方向变了、陈述带了 mood- let retired = sqlx::query(&format!(- "UPDATE facts t- SET invalidated_at = now()- WHERE t.kb_id = $1 AND t.layer = 'typed' AND t.invalidated_at IS NULL- AND t.from_statement_id IS NOT NULL+ // 1. 删不再成立的来源:陈述死了、行死了、签名没绑着、属性或方向变了、陈述带了 mood+ sqlx::query(&format!(+ "DELETE FROM typed_fact_sources src+ USING facts t+ WHERE src.fact_id = t.id AND t.kb_id = $1AND NOT EXISTS (SELECT 1FROM facts sJOIN entities se ON se.id = s.subject_idLEFT JOIN entities oe ON oe.id = s.object_idJOIN phrase_bindings b ON {MATCH}- WHERE s.id = t.from_statement_id+ WHERE s.id = src.statement_idAND s.invalidated_at IS NULL+ AND t.invalidated_at IS NULLAND b.status = 'bound'AND b.relation_type_id = t.predicate_idAND ((b.direction = 'forward' AND t.subject_id = s.subject_id)@@ -56,14 +79,29 @@ pub async fn materialize(pool: &PgPool, kb_id: Uuid) -> AppResult<Outcome> {WHERE q.fact_id = s.id AND q.role = 'mood'))")).bind(kb_id)- .execute(&mut *tx)+ .execute(pool)+ .await?;++ // 2. 作废来源全空的类型化行:只动算出来的行(带 from_statement_id 的),人写的不碰+ let retired = sqlx::query(+ "UPDATE facts t+ SET invalidated_at = now()+ WHERE t.kb_id = $1 AND t.layer = 'typed' AND t.invalidated_at IS NULL+ AND t.from_statement_id IS NOT NULL+ AND NOT EXISTS (SELECT 1 FROM typed_fact_sources src WHERE src.fact_id = t.id)",+ )+ .bind(kb_id)+ .execute(pool).await?.rows_affected();- // 2. 补该有而没有的:先选出(陈述, 绑定)对,再逐条落行——id 是 v7,库里没有生成- // 它的函数。reverse 只对两样东西之间的关系有意义(字面值当不了主语)- let due: Vec<(Uuid, Uuid, String)> = sqlx::query_as(&format!(- "SELECT s.id, b.relation_type_id, b.direction+ // 3. 该有而没有的(陈述, 绑定)对:陈述活着、签名绑着、没 mood、还没有活着的行以它为来源+ // 且谓词相同。reverse 只对两样东西之间的关系有意义(字面值当不了主语)+ let due: Vec<Due> = sqlx::query_as(&format!(+ "SELECT s.id AS statement, b.relation_type_id AS property, b.direction,+ s.subject_id, s.object_id, s.object_value,+ s.valid_from, s.valid_from_precision, s.valid_to, s.valid_to_precision,+ s.attested_from, s.confidenceFROM facts sJOIN entities se ON se.id = s.subject_idLEFT JOIN entities oe ON oe.id = s.object_id@@ -73,72 +111,129 @@ pub async fn materialize(pool: &PgPool, kb_id: Uuid) -> AppResult<Outcome> {AND (b.direction = 'forward' OR s.object_id IS NOT NULL)AND NOT EXISTS (SELECT 1 FROM statement_qualifiers qWHERE q.fact_id = s.id AND q.role = 'mood')- AND NOT EXISTS (SELECT 1 FROM facts t- WHERE t.from_statement_id = s.id AND t.invalidated_at IS NULL+ AND NOT EXISTS (SELECT 1 FROM typed_fact_sources src JOIN facts t ON t.id = src.fact_id+ WHERE src.statement_id = s.id AND t.invalidated_at IS NULLAND t.predicate_id = b.relation_type_id)ORDER BY s.id")).bind(kb_id)- .fetch_all(&mut *tx)+ .fetch_all(pool).await?;- let mut added: Vec<(Uuid, Uuid)> = Vec::with_capacity(due.len());- for (statement, property, direction) in &due {- let id = Uuid::now_v7();- let reverse = direction == "reverse";++ let (mut added, mut merged) = (0u64, 0u64);+ for d in &due {+ let reverse = d.direction == "reverse";+ let validity = Validity {+ from: d.valid_from,+ from_precision: d.valid_from_precision.as_deref(),+ to: d.valid_to,+ to_precision: d.valid_to_precision.as_deref(),+ attested_at: d.attested_from,+ };+ let (fact, new) = match (reverse, d.object_id, &d.object_value) {+ (true, Some(object), _) => {+ insert_fact(+ pool,+ kb_id,+ object,+ Some(d.property),+ d.subject_id,+ validity,+ d.confidence,+ )+ .await?+ }+ (false, Some(object), _) => {+ insert_fact(+ pool,+ kb_id,+ d.subject_id,+ Some(d.property),+ object,+ validity,+ d.confidence,+ )+ .await?+ }+ (false, None, Some(value)) => {+ insert_value_fact(+ pool,+ kb_id,+ d.subject_id,+ Some(d.property),+ value,+ validity,+ d.confidence,+ )+ .await?+ }+ _ => continue,+ };+ if new {+ added += 1;+ sqlx::query("UPDATE facts SET from_statement_id = $2 WHERE id = $1 AND from_statement_id IS NULL")+ .bind(fact)+ .bind(d.statement)+ .execute(pool)+ .await?;+ // 新行取代了一条裸行(时间精化,supersedes 链上):被取代那行的来源跟着搬过来,+ // 这一轮就收敛,不等下一轮把旧来源当「不成立」删掉再补+ sqlx::query(+ "INSERT INTO typed_fact_sources (fact_id, statement_id)+ SELECT $1, src.statement_id+ FROM facts n JOIN typed_fact_sources src ON src.fact_id = n.supersedes+ WHERE n.id = $1+ ON CONFLICT DO NOTHING",+ )+ .bind(fact)+ .execute(pool)+ .await?;+ sqlx::query(+ "DELETE FROM typed_fact_sources src+ USING facts n+ WHERE n.id = $1 AND src.fact_id = n.supersedes",+ )+ .bind(fact)+ .execute(pool)+ .await?;+ } else {+ merged += 1;+ }sqlx::query(- "INSERT INTO facts (id, kb_id, subject_id, predicate_id, object_id, object_value,- valid_from, valid_from_precision, valid_to, valid_to_precision,- attested_from, attested_to, confidence, layer, from_statement_id)- SELECT $1, s.kb_id,- CASE WHEN $4 THEN s.object_id ELSE s.subject_id END,- $3,- CASE WHEN $4 THEN s.subject_id ELSE s.object_id END,- CASE WHEN $4 THEN NULL ELSE s.object_value END,- s.valid_from, s.valid_from_precision, s.valid_to, s.valid_to_precision,- s.attested_from, s.attested_to, s.confidence, 'typed', s.id- FROM facts s WHERE s.id = $2",+ "INSERT INTO typed_fact_sources (fact_id, statement_id) VALUES ($1, $2)+ ON CONFLICT DO NOTHING",)- .bind(id)- .bind(statement)- .bind(property)- .bind(reverse)- .execute(&mut *tx)+ .bind(fact)+ .bind(d.statement)+ .execute(pool).await?;- added.push((id, *statement));- }-- // 3. 新行抄证据与限定:证据是同一段原文的同一处引文;限定照角色词原样带过去- if !added.is_empty() {- let ids: Vec<Uuid> = added.iter().map(|(id, _)| *id).collect();+ // 证据与限定各抄一份:证据是同一段原文的同一处引文;限定照角色词原样带过去sqlx::query("INSERT INTO fact_evidence (fact_id, chunk_id, quote, document_id, doc_version,proposed_predicate, quote_start, quote_end)- SELECT t.id, e.chunk_id, e.quote, e.document_id, e.doc_version,- e.proposed_predicate, e.quote_start, e.quote_end- FROM facts t- JOIN fact_evidence e ON e.fact_id = t.from_statement_id- WHERE t.id = ANY($1)+ SELECT $1, chunk_id, quote, document_id, doc_version, proposed_predicate,+ quote_start, quote_end+ FROM fact_evidence WHERE fact_id = $2ON CONFLICT DO NOTHING",)- .bind(&ids)- .execute(&mut *tx)+ .bind(fact)+ .bind(d.statement)+ .execute(pool).await?;sqlx::query("INSERT INTO statement_qualifiers (fact_id, role, value, entity_id)- SELECT t.id, q.role, q.value, q.entity_id- FROM facts t- JOIN statement_qualifiers q ON q.fact_id = t.from_statement_id- WHERE t.id = ANY($1)+ SELECT $1, role, value, entity_id FROM statement_qualifiers WHERE fact_id = $2ON CONFLICT DO NOTHING",)- .bind(&ids)- .execute(&mut *tx)+ .bind(fact)+ .bind(d.statement)+ .execute(pool).await?;}- tx.commit().await?;Ok(Outcome {retired,- added: added.len() as u64,+ added,+ merged,})}diff --git a/crates/utopia-store/tests/a_bound_statement_becomes_a_typed_fact.rs b/crates/utopia-store/tests/a_bound_statement_becomes_a_typed_fact.rsindex b3be5794..112ece97 100644--- a/crates/utopia-store/tests/a_bound_statement_becomes_a_typed_fact.rs+++ b/crates/utopia-store/tests/a_bound_statement_becomes_a_typed_fact.rs@@ -1,10 +1,11 @@-//! 类型化图谱是视图(0044 决定 3,0067):绑上的签名下的开放陈述算成类型化行,绑定变了-//! 行跟着变,跑多少遍结果一样。+//! 类型化图谱是视图(0044 决定 3,0067、0068):绑上的签名下的开放陈述算成类型化行,+//! 几条陈述说同一件事就是一行,绑定变了行跟着变,跑多少遍结果一样。//!//! 一条陈述「Harbor Bakery —is based in→ Port Ellen」,签名 (is based in, organization,//! place) 绑到 headquartered_in:算出一条类型化行,谓词是它,证据与限定抄过来,-//! `from_statement_id` 指回陈述;再跑一遍什么都不动;带 mood 的陈述不算;绑定翻成-//! reverse,旧行作废、新行主宾对调;绑定改成 none,行作废、不再补。+//! `from_statement_id` 指回陈述;再跑一遍什么都不动;带 mood 的陈述不算;另一份文档+//! 的同一句并进同一行(两条来源、两条证据);作废其中一条陈述,行还在、来源少一条;+//! 绑定翻成 reverse,旧行作废、新行主宾对调;绑定改成 none,行作废、不再补。//!//! 没有 `UTOPIA_DATABASE_URL` 时跳过而不是失败。自建自拆,绝不碰已有的库。@@ -63,7 +64,7 @@ async fn a_bound_statement_becomes_a_typed_fact() -> anyhow::Result<()> {.execute(&pool).await?;- // 两样东西,两条陈述:一条平常的,一条带 mood 的+ // 两样东西;三条陈述:一条平常的,一条带 mood 的,一条另一份文档说的同一件事let (bakery, port) = (Uuid::now_v7(), Uuid::now_v7());for (id, type_id, name) in [(bakery, organization, "Harbor Bakery"), (port, place, "Port Ellen")] {sqlx::query(@@ -76,8 +77,21 @@ async fn a_bound_statement_becomes_a_typed_fact() -> anyhow::Result<()> {.execute(&pool).await?;}- let (stated, planned) = (Uuid::now_v7(), Uuid::now_v7());- for (id, phrase) in [(stated, "is based in"), (planned, "will move to")] {+ // 先来一条没时间的裸陈述,再来两条带时间的:裸行会被带时间的行取代(supersedes),+ // 来源要跟着搬到新行上+ let bare = Uuid::now_v7();+ sqlx::query(+ "INSERT INTO facts (id, kb_id, subject_id, object_id, layer, phrase, confidence)+ VALUES ($1, $2, $3, $4, 'open', 'operates from', 0.9)",+ )+ .bind(bare)+ .bind(kb)+ .bind(bakery)+ .bind(port)+ .execute(&pool)+ .await?;+ let (stated, planned, again) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());+ for (id, phrase) in [(stated, "is based in"), (planned, "will move to"), (again, "is based in")] {sqlx::query("INSERT INTO facts (id, kb_id, subject_id, object_id, layer, phrase, confidence,valid_from, valid_from_precision)@@ -91,33 +105,39 @@ async fn a_bound_statement_becomes_a_typed_fact() -> anyhow::Result<()> {.execute(&pool).await?;}- let (doc, chunk) = (Uuid::now_v7(), Uuid::now_v7());- sqlx::query(- "INSERT INTO documents (id, kb_id, filename, sha256)- VALUES ($1, $2, 'bakery.txt', 'materialize-test')",- )- .bind(doc)- .bind(kb)- .execute(&pool)- .await?;- sqlx::query(- "INSERT INTO chunks (id, kb_id, document_id, seq, text)- VALUES ($1, $2, $3, 0, 'Harbor Bakery is based in Port Ellen.')",- )- .bind(chunk)- .bind(kb)- .bind(doc)- .execute(&pool)- .await?;- sqlx::query(- "INSERT INTO fact_evidence (fact_id, chunk_id, quote, document_id, quote_start, quote_end)- VALUES ($1, $2, 'Harbor Bakery is based in Port Ellen.', $3, 0, 37)",- )- .bind(stated)- .bind(chunk)- .bind(doc)- .execute(&pool)- .await?;+ let evidence_of = |statement: Uuid, name: &'static str| {+ let pool = pool.clone();+ async move {+ let (doc, chunk) = (Uuid::now_v7(), Uuid::now_v7());+ sqlx::query("INSERT INTO documents (id, kb_id, filename, sha256) VALUES ($1, $2, $3, $3)")+ .bind(doc)+ .bind(kb)+ .bind(name)+ .execute(&pool)+ .await?;+ sqlx::query(+ "INSERT INTO chunks (id, kb_id, document_id, seq, text)+ VALUES ($1, $2, $3, 0, 'Harbor Bakery is based in Port Ellen.')",+ )+ .bind(chunk)+ .bind(kb)+ .bind(doc)+ .execute(&pool)+ .await?;+ sqlx::query(+ "INSERT INTO fact_evidence (fact_id, chunk_id, quote, document_id, quote_start, quote_end)+ VALUES ($1, $2, 'Harbor Bakery is based in Port Ellen.', $3, 0, 37)",+ )+ .bind(statement)+ .bind(chunk)+ .bind(doc)+ .execute(&pool)+ .await?;+ anyhow::Ok(())+ }+ };+ evidence_of(stated, "bakery.txt").await?;+ evidence_of(again, "bakery-2.txt").await?;sqlx::query("INSERT INTO statement_qualifiers (fact_id, role, value) VALUES ($1, 'since', '\"2019\"'::jsonb)",)@@ -153,25 +173,32 @@ async fn a_bound_statement_becomes_a_typed_fact() -> anyhow::Result<()> {};binding("is based in").await?;binding("will move to").await?;+ binding("operates from").await?;+ // 三条平常的陈述说的是同一件事:裸的那条先成一行,带时间的取代它(added 2,旧行作废、+ // 来源搬过来),第三条并进去(merged 1)——最后一行,三条来源,两条证据;带 mood 的+ // 那条不算let first = materialize(&pool, kb).await?;- assert_eq!(first, Outcome { retired: 0, added: 1 }, "带 mood 的那条不算");- let (subject, object, predicate, from, vf): (Uuid, Uuid, Uuid, Uuid, Option<chrono::DateTime<chrono::Utc>>) =- sqlx::query_as(- "SELECT subject_id, object_id, predicate_id, from_statement_id, valid_from+ assert_eq!(first, Outcome { retired: 0, added: 2, merged: 1 });+ let live = |pool: PgPool| async move {+ sqlx::query_as::<_, (Uuid, Uuid, Uuid, Uuid, Uuid, Option<chrono::DateTime<chrono::Utc>>)>(+ "SELECT id, subject_id, object_id, predicate_id, from_statement_id, valid_fromFROM facts WHERE kb_id = $1 AND layer = 'typed' AND invalidated_at IS NULL",).bind(kb)- .fetch_one(&pool)- .await?;+ .fetch_all(&pool)+ .await+ };+ let rows = live(pool.clone()).await?;+ assert_eq!(rows.len(), 1, "同一个三元组只有一行");+ let (typed_id, subject, object, predicate, from, vf) = rows[0];assert_eq!((subject, object, predicate, from), (bakery, port, hq, stated));assert!(vf.is_some(), "世界轴时间抄过来");- let typed_id: Uuid = sqlx::query_scalar(- "SELECT id FROM facts WHERE from_statement_id = $1 AND invalidated_at IS NULL",- )- .bind(stated)- .fetch_one(&pool)- .await?;+ let sources: i64 =+ sqlx::query_scalar("SELECT count(*) FROM typed_fact_sources WHERE fact_id = $1")+ .bind(typed_id)+ .fetch_one(&pool)+ .await?;let evidence: i64 =sqlx::query_scalar("SELECT count(*) FROM fact_evidence WHERE fact_id = $1").bind(typed_id)@@ -183,25 +210,35 @@ async fn a_bound_statement_becomes_a_typed_fact() -> anyhow::Result<()> {.bind(typed_id).fetch_all(&pool).await?;- assert_eq!((evidence, qualifiers), (1, vec!["since".to_string()]), "证据与限定各一份");+ assert_eq!((sources, evidence, qualifiers), (3, 2, vec!["since".to_string()]));// 再跑一遍:什么都不动assert_eq!(materialize(&pool, kb).await?, Outcome::default());+ // 一份文档撤了它那句:行还在,来源少一条+ sqlx::query("UPDATE facts SET invalidated_at = now() WHERE id = $1")+ .bind(again)+ .execute(&pool)+ .await?;+ assert_eq!(materialize(&pool, kb).await?, Outcome::default());+ let sources: i64 =+ sqlx::query_scalar("SELECT count(*) FROM typed_fact_sources WHERE fact_id = $1")+ .bind(typed_id)+ .fetch_one(&pool)+ .await?;+ assert_eq!(sources, 2);+ assert_eq!(live(pool.clone()).await?.len(), 1, "还有来源,行留着");+// 绑定翻成 reverse:旧行作废,新行主宾对调- sqlx::query("UPDATE phrase_bindings SET direction = 'reverse' WHERE kb_id = $1 AND phrase = 'is based in'")+ sqlx::query("UPDATE phrase_bindings SET direction = 'reverse' WHERE kb_id = $1 AND phrase IN ('is based in', 'operates from')").bind(kb).execute(&pool).await?;- assert_eq!(materialize(&pool, kb).await?, Outcome { retired: 1, added: 1 });- let (subject, object): (Uuid, Uuid) = sqlx::query_as(- "SELECT subject_id, object_id FROM facts- WHERE from_statement_id = $1 AND invalidated_at IS NULL",- )- .bind(stated)- .fetch_one(&pool)- .await?;- assert_eq!((subject, object), (port, bakery), "方向反了主宾对调");+ // 旧行的来源全不成立了:作废 1;反向重算时裸的那条先成行、带时间的再取代它:新建 2+ assert_eq!(materialize(&pool, kb).await?, Outcome { retired: 1, added: 2, merged: 0 });+ let rows = live(pool.clone()).await?;+ assert_eq!(rows.len(), 1);+ assert_eq!((rows[0].1, rows[0].2), (port, bakery), "方向反了主宾对调");let retired: i64 = sqlx::query_scalar("SELECT count(*) FROM facts WHERE from_statement_id = $1 AND invalidated_at IS NOT NULL",)@@ -213,12 +250,12 @@ async fn a_bound_statement_becomes_a_typed_fact() -> anyhow::Result<()> {// 绑定改成 none:行作废,不再补sqlx::query("UPDATE phrase_bindings SET status = 'none', relation_type_id = NULL, direction = NULL- WHERE kb_id = $1 AND phrase = 'is based in'",+ WHERE kb_id = $1 AND phrase IN ('is based in', 'operates from')",).bind(kb).execute(&pool).await?;- assert_eq!(materialize(&pool, kb).await?, Outcome { retired: 1, added: 0 });+ assert_eq!(materialize(&pool, kb).await?, Outcome { retired: 1, added: 0, merged: 0 });assert_eq!(utopia_store::materialize::count(&pool, kb).await?, 0);anyhow::Ok(())}diff --git a/docs/design/ontology.md b/docs/design/ontology.mdindex d4a9f1bb..65042aaf 100644--- a/docs/design/ontology.md+++ b/docs/design/ontology.md@@ -82,9 +82,10 @@ from the statement; its evidence rows and role-word qualifiers are copied too, amaterialised. The computation is a set operation and idempotent: rows whose source no longer holds(the statement invalidated, the signature no longer bound, the property or direction changed) areinvalidated, rows that are due and missing are added, rows whose binding is unchanged keep their-id, evidence and recorded time. Typed rows that several statements produce for the same triple are-separate rows, one per statement. On the 25-document batch the 36 bound signatures give 184-typed rows.+id, evidence and recorded time. Several statements that produce the same triple give one row: the row is written through+the typed graph's own gate (the dedup, time refinement and closing rules of `insert_fact`), and+`typed_fact_sources` lists every statement behind it, so a row is retired only when none of its+sources holds [#753]. On the 25-document batch the 36 bound signatures give 184 typed rows.**Argument order is enforced, participation is guided.** A declared domain or range shapescandidates and never discards a fact; argument order is the key's encoding convention, so a factdiff --git a/migrations/0068_one_typed_fact_for_many_statements.sql b/migrations/0068_one_typed_fact_for_many_statements.sqlnew file mode 100644index 00000000..7b0e6735--- /dev/null+++ b/migrations/0068_one_typed_fact_for_many_statements.sql@@ -0,0 +1,22 @@+-- 同一个三元组由几条陈述算出来时,类型化图谱里只有一行(0044 决定 3 的第四片)。+--+-- 0067 让每条绑上的陈述各成一行类型化事实,于是两份文档都说「Harbor Bakery 在 Port Ellen」+-- 时间线上就有两条一模一样的边。现在物化走类型化图谱本来的门(`insert_fact` /+-- `insert_value_fact`):同断言同起点的复用那一行、只是又被提到一次;没时间的裸行被带+-- 时间的观察取代并链上(supersedes);「结束了」关上开着的行。一行于是可能来自几条陈述,+-- 来源记在 `typed_fact_sources` 里,一条陈述一行;`facts.from_statement_id` 留作第一条+-- 来源。作废的规则跟着变:一行来源全都不成立了才作废;某条来源的绑定变了,只删它那条+-- 来源记录。++CREATE TABLE typed_fact_sources (+ fact_id UUID NOT NULL REFERENCES facts(id) ON DELETE CASCADE,+ statement_id UUID NOT NULL REFERENCES facts(id) ON DELETE CASCADE,+ PRIMARY KEY (fact_id, statement_id)+);+CREATE INDEX typed_fact_sources_statement_idx ON typed_fact_sources (statement_id);++-- 0067 已经算出来的行:它的那一条陈述就是它的来源+INSERT INTO typed_fact_sources (fact_id, statement_id)+SELECT id, from_statement_id FROM facts+ WHERE from_statement_id IS NOT NULL+ON CONFLICT DO NOTHING;