Skip to content

World's first open-source enterprise world model.

An amount outlives adoption (#602)

WaylandYang367e95c4846f
diff --git a/crates/utopia-extract/src/lib.rs b/crates/utopia-extract/src/lib.rs
index f596f7de..337666ad 100644
--- a/crates/utopia-extract/src/lib.rs
+++ b/crates/utopia-extract/src/lib.rs
@@ -309,7 +309,7 @@ pub fn build_messages(
units and all. **A stated figure left out is the loss that costs most**: the reader \
came for those numbers, and no later step can recover one that was never written \
down.\n\
- 8c. A listed relation followed by {{…}} can carry those **qualifiers on the edge**: when the same sentence gives both the other entity and a figure for it — an amount, a stake, a price, a share count — write the relation with its \"object\" and put the figure in \"qualifiers\" keyed exactly as listed, **as written in the text, currency and all** (\"€30 million\", \"15亿元人民币\", never a bare number): {{\"subject\":\"Vega Capital\",\"predicate\":\"invested_in\",\"object\":\"Northwind\", \"qualifiers\":{{\"amount\":\"$5 billion\"}},…}}. Never invent a key that is not listed for that relation, and never drop the figure to keep the edge — a relation without its amount is half the sentence.
+ 8c. A listed relation followed by {{…}} can carry those **qualifiers on the edge**: when the same sentence gives both the other entity and a figure for it — an amount, a stake, a price, a share count — write the relation with its \"object\" and put the figure in \"qualifiers\" keyed exactly as listed, **as written in the text, currency and all** (\"€30 million\", \"15亿元人民币\", never a bare number): {{\"subject\":\"Vega Capital\",\"predicate\":\"invested_in\",\"object\":\"Northwind\", \"qualifiers\":{{\"amount\":\"$5 billion\"}},…}}. Never invent a key that is not listed for that relation, and never drop the figure to keep the edge — a relation without its amount is half the sentence. A relation you name after the text (rule 8) carries its figure the same way — keyed by the listed attribute that fits it, or by the plainest word for it (\"amount\", \"stake\", \"price\") when none does.
8b. A **listed** relation also takes \"value\" when what the text gives is a \
string rather than another entity — a job title, a designation, a ticker, a \
model number. Never invent an entity for a string. And when the text introduces \
diff --git a/crates/utopia-server/src/extraction.rs b/crates/utopia-server/src/extraction.rs
index d6bcba60..2244e177 100644
--- a/crates/utopia-server/src/extraction.rs
+++ b/crates/utopia-server/src/extraction.rs
@@ -1492,8 +1492,10 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:
continue;
};
let mut object_value = serde_json::json!({ "value": normalized });
- if let Some(u) = attr.unit.as_deref().filter(|u| !u.is_empty()) {
- // 单位随事实落笔:类型上的单位以后改了,旧值仍按记录时的单位读
+ // 单位随事实落笔:类型上的单位以后改了,旧值仍按记录时的单位读。
+ // 记哪个单位照 `unit_for`——从前这里无条件盖上声明的单位,实测
+ //「提供 500 兆瓦的风电」被模型记成金额,再盖上 ¥ 就成了 500 块钱
+ if let Some(u) = unit_for(&raw, datatype, None, attr.unit.as_deref()) {
object_value["unit"] = serde_json::json!(u);
}
if await_nod {
@@ -2304,10 +2306,16 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:
同一条边再听到一次带了金额的,是同一条边补上金额。
值照 datatype 换算,单位另记一格(与 object_value 同形);
key 不在声明里、换不动、与已记的不一致——三种都进丢弃表,不静默 */
- if let (Some(pid), Some(quals)) = (predicate_id, f.qualifiers.as_ref()) {
+ /* 谓词未知(0010,说法在证据上)时属性照写:值落在事实上,声明等
+ 关系被采纳时在 `adopt` 里补。不写的话,`invested_in` 在 schema.org
+ 库里是未知说法,一句话里的 $1.5 billion 就没有地方放——召回台上
+ `oh-invest` 那一条正是这么丢的 */
+ if let Some(quals) = f.qualifiers.as_ref() {
+ let pid = predicate_id;
// 克隆出这一组引用:下面撞上已有属性时要往 qualifier_defs 里追加声明
- let defs: Vec<&utopia_core::models::RelationType> =
- qualifier_defs.get(&pid).cloned().unwrap_or_default();
+ let defs: Vec<&utopia_core::models::RelationType> = pid
+ .and_then(|p| qualifier_defs.get(&p).cloned())
+ .unwrap_or_default();
/* 模型常把币种单独写成一个键(`"amount": "1500000000", "currency": "CNY"`),
而不是写进数额里。那不是一个属性,是数额的单位——先把它拿出来,
数值属性解不出单位时用它,别让它作为未知 key 进丢弃表 */
@@ -2343,9 +2351,16 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:
所以跟自动扩本体走同一个开关 */
let adopted = match declared {
Some(d) => Some(d),
+ /* 谓词还未知(0010,说法在证据上):没有关系可声明,值绑到库里
+ 已有的属性定义、先落在事实上,采纳时 `adopt` 再补声明。这一步
+ 不动本体,所以不看自动扩本体的开关 */
+ None if pid.is_none() => {
+ attr_by_key.get(&key.trim().to_lowercase()).copied()
+ }
None if kb.auto_extend_ontology => {
match attr_by_key.get(&key.trim().to_lowercase()).copied() {
Some(attr) => {
+ let pid = pid.expect("checked above");
match utopia_store::ontology::add_relation_qualifier(
&state.pool,
doc.kb_id,
@@ -2377,15 +2392,50 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:
}
};
let Some(def) = adopted else {
- drop_signal(
- state,
+ /* **绑不上属性定义的数也不丢。** 库里没有这个属性(schema.org 里
+ `amount` 是关系不是属性)、或本体冻着不让扩——从前这里进丢弃表,
+ 数就只剩丢弃表里的一个样例。现在照 8a 的样子落成主语上的一条
+ 字面值事实:值按原文、单位另记一格、原词 `关系.键` 进证据的
+ proposed_predicate,缺的定义记进 ontology_misses(0010 的样子),
+ 采纳时人来决定它归哪儿。图里有它、有证据、能查到 */
+ let wording = format!("{}.{}", f.predicate.trim(), key.trim());
+ let unit = raw
+ .as_str()
+ .and_then(utopia_extract::parse_leading_quantity)
+ .and_then(|(_, u)| u)
+ .or_else(|| sibling_currency.map(str::to_string));
+ let mut literal = serde_json::json!({ "value": raw });
+ if let Some(u) = unit {
+ literal["unit"] = serde_json::Value::String(u);
+ }
+ let _ = utopia_store::ontology::record_miss(
+ &state.pool,
doc.kb_id,
- document_id,
- utopia_store::extraction_drops::reason::QUALIFIER_UNKNOWN,
- &format!("{}.{}", f.predicate, key),
- Some(&raw.to_string()),
+ "attribute_type",
+ &wording,
+ Some(&format!("{} → {raw}", f.subject.trim())),
)
.await;
+ let (literal_id, _) = utopia_store::graph::insert_value_fact(
+ &state.pool,
+ doc.kb_id,
+ subject_id,
+ None,
+ &literal,
+ validity,
+ confidence,
+ )
+ .await?;
+ touched_facts.push(literal_id);
+ utopia_store::graph::add_evidence(
+ &state.pool,
+ literal_id,
+ chunk.id,
+ f.quote.as_deref(),
+ Some(wording.as_str()),
+ )
+ .await?;
+ tracing::debug!(kb_id = %doc.kb_id, wording = %wording, "边上的属性绑不上定义,落成主语上的字面值");
continue;
};
let dt = def.datatype.as_deref().unwrap_or("text");
@@ -2402,28 +2452,7 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:
continue;
};
let mut value = serde_json::json!({ "value": normalized });
- /* 单位:原文里认得出的用原文的(€、¥、%),原文里**没有任何单位记号**
- 才落回属性声明的缺省。原文带着一个认不出的单位("francs")时
- **不能**拿缺省顶上——实测 `EUR 30 million` 被存成了 `$`,
- `15亿元人民币` 也是;币种写错比不写更糟 */
- let parsed = raw
- .as_str()
- .and_then(utopia_extract::parse_leading_quantity);
- let raw_has_unit_token = raw.as_str().is_some_and(|t| {
- t.chars().any(|c| {
- c.is_alphabetic()
- || matches!(c, '$' | '€' | '£' | '¥' | '₩' | '₹' | '%')
- })
- });
- let unit = match parsed.and_then(|(_, u)| u) {
- Some(u) => Some(u),
- None => match sibling_currency {
- Some(c) if dt == "number" => Some(c.to_string()),
- _ if raw_has_unit_token => None,
- _ => def.unit.clone().filter(|u| !u.is_empty()),
- },
- };
- if let Some(u) = unit {
+ if let Some(u) = unit_for(raw, dt, sibling_currency, def.unit.as_deref()) {
value["unit"] = serde_json::Value::String(u);
}
let write = utopia_store::graph::upsert_fact_qualifier(
@@ -2938,6 +2967,129 @@ async fn chunk_lists(
)))
}
+/// 一条值该记什么单位(#600「单位是读出来的,不是猜的」,实体上的属性与边上的属性同一条规矩)。
+///
+/// 原文里认得出的用原文的(€、¥、%、"EUR 30 million" 的 €);模型把币种单独写成
+/// 一个键时用那个;原文里写着声明的那个单位("4300 人" 对 "人")也算读出来的。
+/// 原文带着一个认不出的单位记号("500 兆瓦"、"francs")时**不能**拿声明的缺省顶上——
+/// 实测 `EUR 30 million` 被存成了 `$`,`500 兆瓦` 被存成了 500 块钱;单位写错比不写更糟。
+/// 只有原文完全没有单位记号(一个光秃秃的数)才落回声明的缺省。
+fn unit_for(
+ raw: &serde_json::Value,
+ datatype: &str,
+ sibling_currency: Option<&str>,
+ declared: Option<&str>,
+) -> Option<String> {
+ let declared = declared.map(str::trim).filter(|u| !u.is_empty());
+ let text = raw.as_str();
+ if let Some(u) = text
+ .and_then(utopia_extract::parse_leading_quantity)
+ .and_then(|(_, u)| u)
+ {
+ return Some(u);
+ }
+ if let (Some(c), "number") = (sibling_currency, datatype) {
+ return Some(c.to_string());
+ }
+ if let (Some(t), Some(d)) = (text, declared) {
+ if t.contains(d) {
+ return Some(d.to_string());
+ }
+ }
+ let has_unit_token = text.is_some_and(|t| {
+ t.chars()
+ .any(|c| c.is_alphabetic() || matches!(c, '$' | '€' | '£' | '¥' | '₩' | '₹' | '%'))
+ });
+ if has_unit_token {
+ None
+ } else {
+ declared.map(str::to_string)
+ }
+}
+
+#[cfg(test)]
+mod unit_for_tests {
+ use super::unit_for;
+ use serde_json::{json, Value};
+
+ fn s(t: &str) -> Value {
+ Value::String(t.to_string())
+ }
+
+ #[test]
+ fn a_unit_is_read_from_the_text_before_anything_else() {
+ assert_eq!(
+ unit_for(&s("EUR 30 million"), "number", None, Some("$")).as_deref(),
+ Some("€")
+ );
+ assert_eq!(
+ unit_for(&s("8.6亿元"), "number", None, Some("$")).as_deref(),
+ Some("¥")
+ );
+ assert_eq!(
+ unit_for(&s("12%"), "number", None, Some("¥")).as_deref(),
+ Some("%")
+ );
+ assert_eq!(
+ unit_for(&s("$5 billion"), "number", None, None).as_deref(),
+ Some("$")
+ );
+ }
+
+ #[test]
+ fn a_sibling_currency_is_the_unit_of_a_bare_number() {
+ assert_eq!(
+ unit_for(&s("1500000000"), "number", Some("CNY"), Some("$")).as_deref(),
+ Some("CNY")
+ );
+ // 文本型属性没有币种可言
+ assert_eq!(unit_for(&s("B 轮"), "text", Some("CNY"), None), None);
+ }
+
+ #[test]
+ fn the_declared_unit_written_in_the_text_counts_as_read() {
+ assert_eq!(
+ unit_for(&s("4300 人"), "number", None, Some("人")).as_deref(),
+ Some("人")
+ );
+ assert_eq!(
+ unit_for(&s("三年"), "text", None, Some("年")).as_deref(),
+ Some("年")
+ );
+ }
+
+ #[test]
+ fn an_unknown_unit_token_is_never_overwritten_by_the_default() {
+ // 宽松扫描把尾巴上的记号当单位读出来:记的是原文的单位,不是声明的 ¥
+ assert_eq!(
+ unit_for(&s("500 兆瓦"), "number", None, Some("¥")).as_deref(),
+ Some("兆瓦")
+ );
+ assert_eq!(
+ unit_for(&s("30 million francs"), "number", None, Some("$")).as_deref(),
+ Some("francs")
+ );
+ // 扫描读不出、原文却明明带着字:也不拿缺省顶上
+ assert_eq!(
+ unit_for(&s("about five hundred"), "number", None, Some("$")),
+ None
+ );
+ }
+
+ #[test]
+ fn a_bare_figure_takes_the_declared_default() {
+ assert_eq!(
+ unit_for(&s("4300"), "number", None, Some("人")).as_deref(),
+ Some("人")
+ );
+ assert_eq!(
+ unit_for(&json!(4300), "number", None, Some("人")).as_deref(),
+ Some("人")
+ );
+ assert_eq!(unit_for(&s("4300"), "number", None, Some("")), None);
+ }
+}
+
#[cfg(test)]
mod name_tests {
use super::{clause_suspect, is_entity_name};
diff --git a/crates/utopia-store/src/graph.rs b/crates/utopia-store/src/graph.rs
index 266f381a..3561cc76 100644
--- a/crates/utopia-store/src/graph.rs
+++ b/crates/utopia-store/src/graph.rs
@@ -1994,6 +1994,32 @@ async fn adopt(
.bind(old_id)
.execute(&mut *tx)
.await?;
+ /* **边上的属性跟着搬**(0037)。谓词还没被采纳时金额就已经落在旧行上——
+ 一句「NVIDIA invested $1.5 billion in SB Energy」在 schema.org 库里
+ `invested_in` 是未知说法,钱不能等到采纳那天才有地方放。旧行作废、
+ 新行接上,属性照证据的样子整体复制;顺手在关系上补声明——
+ 这些属性定义本来就在库里,缺的只是关系上的一条声明 */
+ sqlx::query(
+ "INSERT INTO fact_qualifiers (fact_id, qualifier_type_id, value, entity_id)
+ SELECT $1, qualifier_type_id, value, entity_id
+ FROM fact_qualifiers WHERE fact_id = $2
+ ON CONFLICT DO NOTHING",
+ )
+ .bind(new_id)
+ .bind(old_id)
+ .execute(&mut *tx)
+ .await?;
+ sqlx::query(
+ "INSERT INTO relation_type_qualifiers (relation_type_id, qualifier_type_id)
+ SELECT $1, q.qualifier_type_id
+ FROM fact_qualifiers q JOIN relation_types r ON r.id = q.qualifier_type_id
+ WHERE q.fact_id = $2 AND r.kind = 'attribute' AND r.id <> $1
+ ON CONFLICT DO NOTHING",
+ )
+ .bind(predicate_id)
+ .bind(new_id)
+ .execute(&mut *tx)
+ .await?;
sqlx::query("UPDATE facts SET invalidated_at = now() WHERE id = $1")
.bind(old_id)
.execute(&mut *tx)
diff --git a/crates/utopia-store/tests/an_amount_outlives_adoption.rs b/crates/utopia-store/tests/an_amount_outlives_adoption.rs
new file mode 100644
index 00000000..4a2f976d
--- /dev/null
+++ b/crates/utopia-store/tests/an_amount_outlives_adoption.rs
@@ -0,0 +1,166 @@
+//! 谓词还没被采纳时,金额已经落在事实上;采纳把属性搬到新行、并在关系上补声明(0037)。
+//!
+//! 一句「NVIDIA invested $1.5 billion in SB Energy」在 schema.org 库里 `invested_in`
+//! 是未知说法,钱不能等到采纳那天才有地方放。
+
+use sqlx::PgPool;
+use uuid::Uuid;
+
+#[tokio::test]
+async fn a_qualifier_written_before_adoption_survives_it() -> anyhow::Result<()> {
+ let Some(url) = utopia_store::test_db::url() else {
+ return Ok(());
+ };
+ let pool = PgPool::connect(&url).await?;
+ let tag = Uuid::now_v7();
+ let (org, ws, kb) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());
+ sqlx::query("INSERT INTO organizations (id, name) VALUES ($1, $2)")
+ .bind(org)
+ .bind(format!("outlive-{tag}"))
+ .execute(&pool)
+ .await?;
+ sqlx::query("INSERT INTO workspaces (id, org_id, name) VALUES ($1, $2, $3)")
+ .bind(ws)
+ .bind(org)
+ .bind(format!("outlive-{tag}"))
+ .execute(&pool)
+ .await?;
+ sqlx::query("INSERT INTO knowledge_bases (id, workspace_id, name) VALUES ($1, $2, $3)")
+ .bind(kb)
+ .bind(ws)
+ .bind(format!("outlive-{tag}"))
+ .execute(&pool)
+ .await?;
+ let class = Uuid::now_v7();
+ sqlx::query("INSERT INTO entity_types (id, kb_id, key, label) VALUES ($1, $2, 'org', 'Org')")
+ .bind(class)
+ .bind(kb)
+ .execute(&pool)
+ .await?;
+ let amount = utopia_store::ontology::create_relation_type(
+ &pool,
+ kb,
+ "amount",
+ "amount",
+ "state",
+ Default::default(),
+ "",
+ "attribute",
+ &[class],
+ &[],
+ Some("number"),
+ Some("$"),
+ )
+ .await?;
+ // 关系此刻还不存在于本体里——先建好但不声明任何属性,模拟"采纳"那一刻
+ let invested = utopia_store::ontology::create_relation_type(
+ &pool,
+ kb,
+ "invested_in",
+ "invested in",
+ "event",
+ Default::default(),
+ "",
+ "relation",
+ &[],
+ &[],
+ None,
+ None,
+ )
+ .await?;
+ let (a, b) = (Uuid::now_v7(), Uuid::now_v7());
+ for (id, name) in [(a, "NVIDIA"), (b, "SB Energy")] {
+ sqlx::query(
+ "INSERT INTO entities (id, kb_id, type_id, canonical_name) VALUES ($1, $2, $3, $4)",
+ )
+ .bind(id)
+ .bind(kb)
+ .bind(class)
+ .bind(format!("{name}-{tag}"))
+ .execute(&pool)
+ .await?;
+ }
+ let (doc, chunk, fact) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());
+ sqlx::query("INSERT INTO documents (id, kb_id, filename, sha256) VALUES ($1, $2, $3, $4)")
+ .bind(doc)
+ .bind(kb)
+ .bind(format!("{tag}.txt"))
+ .bind(tag.to_string())
+ .execute(&pool)
+ .await?;
+ sqlx::query(
+ "INSERT INTO chunks (id, kb_id, document_id, seq, text) VALUES ($1, $2, $3, 0, 'x')",
+ )
+ .bind(chunk)
+ .bind(kb)
+ .bind(doc)
+ .execute(&pool)
+ .await?;
+ // 谓词为空的事实 + 说法在证据上 + 金额已经在边上
+ sqlx::query(
+ "INSERT INTO facts (id, kb_id, subject_id, predicate_id, object_id, confidence)
+ VALUES ($1, $2, $3, NULL, $4, 0.9)",
+ )
+ .bind(fact)
+ .bind(kb)
+ .bind(a)
+ .bind(b)
+ .execute(&pool)
+ .await?;
+ sqlx::query(
+ "INSERT INTO fact_evidence (fact_id, chunk_id, document_id, proposed_predicate)
+ VALUES ($1, $2, $3, 'invested_in')",
+ )
+ .bind(fact)
+ .bind(chunk)
+ .bind(doc)
+ .execute(&pool)
+ .await?;
+ let value = serde_json::json!({ "value": 1500000000.0, "unit": "$" });
+ utopia_store::graph::upsert_fact_qualifier(&pool, fact, amount, &value).await?;
+
+ // 采纳:旧行作废、新行接上谓词
+ let adopted = utopia_store::graph::adopt_proposed_predicates(
+ &pool,
+ kb,
+ invested,
+ &["invested_in".to_string()],
+ false,
+ )
+ .await?;
+ assert_eq!(adopted.moved, 1);
+
+ // 活着的那一行带着金额
+ let live: Vec<(Uuid,)> = sqlx::query_as(
+ "SELECT id FROM facts WHERE kb_id = $1 AND predicate_id = $2 AND invalidated_at IS NULL",
+ )
+ .bind(kb)
+ .bind(invested)
+ .fetch_all(&pool)
+ .await?;
+ assert_eq!(live.len(), 1, "采纳后正好一条活着的边");
+ let quals = utopia_store::graph::fact_qualifiers_for(&pool, &[live[0].0]).await?;
+ let q = &quals[&live[0].0];
+ assert_eq!(q.len(), 1);
+ assert_eq!(q[0].key, "amount");
+ assert_eq!(q[0].value, Some(value), "金额跟着搬到了新行");
+
+ // 关系上补了声明
+ let declared = utopia_store::graph::relation_types(&pool, kb)
+ .await?
+ .into_iter()
+ .find(|r| r.id == invested)
+ .map(|r| r.qualifiers)
+ .unwrap_or_default();
+ assert_eq!(declared, vec![amount], "采纳时按边上已有的属性补了声明");
+
+ sqlx::query("DELETE FROM knowledge_bases WHERE id = $1")
+ .bind(kb)
+ .execute(&pool)
+ .await?;
+ sqlx::query("DELETE FROM organizations WHERE id = $1")
+ .bind(org)
+ .execute(&pool)
+ .await?;
+ Ok(())
+}
diff --git a/docs/decisions/0037-a-relation-carries-its-own-attributes.md b/docs/decisions/0037-a-relation-carries-its-own-attributes.md
index 90232ed6..a27bf89b 100644
--- a/docs/decisions/0037-a-relation-carries-its-own-attributes.md
+++ b/docs/decisions/0037-a-relation-carries-its-own-attributes.md
@@ -114,7 +114,9 @@ rules corpus declared and undeclared, a Chinese corpus declared and undeclared):
writes the currency as a sibling key (`"currency": "CNY"`). The prompt now asks for the
figure as written, the scanner reads ISO codes, currency words and CJK magnitudes (万, 亿),
a sibling `currency` key becomes the unit, and the attribute's default unit is used only
- when the text carries no unit token at all — a wrong currency is worse than none.
+ when the text carries no unit token at all — a wrong currency is worse than none. The same
+ rule (`unit_for`) now governs an attribute written on an entity, which used to stamp the
+ declared unit unconditionally: `500 兆瓦` filed under 金额 came out as ¥500.
- **Two mentions of one edge in parallel can both insert.** The dedup in `insert_fact_inner`
is a read-then-write with no unique index behind it; two documents describing the same
`(subject, predicate, object, moment)` extracted at the same time produced two rows with
@@ -126,10 +128,13 @@ rules corpus declared and undeclared, a Chinese corpus declared and undeclared):
## Open questions
-- Where does the amount go when the relation is not adopted yet (`predicate_id` is null,
- wording on the evidence)? This cut drops it with a reason. Keeping it keyed by wording
- until adoption would preserve the figure; the bootstrap would then have to propose the
- qualifier along with the relation.
+- ~~Where does the amount go when the relation is not adopted yet?~~ Answered: a qualifier
+ on a fact whose predicate is unknown binds to an attribute the base already defines (no
+ ontology change, so no switch), and adoption (`adopt`) carries the qualifiers onto the new
+ row and declares them on the relation. A qualifier that binds to nothing — the base has no
+ such attribute, or the ontology is frozen — is written as a literal fact on the subject,
+ worded `relation.key` on its evidence and recorded in `ontology_misses`, the shape rule 8a
+ gives an unlisted figure. Nothing about an edge is dropped for want of a definition.
- The canvas. An edge label with the amount is a rendering change and belongs with the
parallel-edge work; the timeline reading an event as a point is
[0031](0031-an-event-holds-at-the-moment-it-names.md)'s UI cut.
diff --git a/scripts/bench/recall.mjs b/scripts/bench/recall.mjs
index c7c32817..7cffe2a8 100644
--- a/scripts/bench/recall.mjs
+++ b/scripts/bench/recall.mjs
@@ -86,7 +86,10 @@ function score() {
coalesce(s.canonical_name,''),
coalesce(rt.key, coalesce(fe.proposed_predicate,'')),
coalesce(o.canonical_name, f.object_value #>> '{}', f.object_value::text, ''),
- coalesce(to_char(f.valid_from,'YYYY-MM-DD'),''))
+ coalesce(to_char(f.valid_from,'YYYY-MM-DD'),''),
+ coalesce((SELECT string_agg(q.key || '=' || coalesce(fq.value #>> '{value}', '') || ' ' || coalesce(fq.value #>> '{unit}', ''), ' ')
+ FROM fact_qualifiers fq JOIN relation_types q ON q.id = fq.qualifier_type_id
+ WHERE fq.fact_id = f.id), ''))
FROM facts f
JOIN fact_evidence fe ON fe.fact_id = f.id
JOIN documents d ON d.id = fe.document_id
@@ -97,8 +100,9 @@ function score() {
.split("\n")
.filter(Boolean)
.map((l) => {
- const [file, subj, pred, obj, from] = l.split("");
- return { file, subj, pred, obj, from };
+ // 边上的属性(0037)也在这一行里:金额挂在边上时,值不在 object 那一格
+ const [file, subj, pred, obj, from, quals] = l.split("");
+ return { file, subj, pred, obj, from, quals };
});
const byDoc = new Map();
@@ -122,7 +126,7 @@ function score() {
let ok = false;
if (t.kind === "value") {
ok = facts.some((f) => {
- const raw = `${f.subj} | ${f.pred} | ${f.obj} | ${f.from}`;
+ const raw = `${f.subj} | ${f.pred} | ${f.obj} | ${f.from} | ${f.quals}`;
return t.value_any.some((v) => norm(raw).includes(norm(v)) || squash(raw).includes(squash(v)));
});
} else if (t.kind === "edge") {