use super::*;
#[cfg(test)]
pub(crate) fn persist_ann_v2(
rt: &KhiveRuntime,
ns: &str,
model: &str,
bridge: &AnnBridge,
) -> Result<(), String> {
match ann_segment_dir(rt, ns, model) {
Some(dir) => bridge.save_atomic(&dir),
None => Ok(()), }
}
pub(super) fn persist_ann_v2_locked(
rt: &KhiveRuntime,
ns: &str,
model: &str,
bridge: &AnnBridge,
) -> Result<(), String> {
match ann_segment_dir(rt, ns, model) {
Some(dir) => bridge.save_atomic_locked(&dir),
None => Ok(()),
}
}
pub(super) const ANN_CONSUMER: &str = "knowledge:knowledge.atom";
#[cfg(test)]
pub(super) async fn register_consumer(
rt: &KhiveRuntime,
ns: &str,
model: &str,
) -> Result<(), String> {
let sql = rt.sql();
ann_registry::register_pending_dispatch(
sql.as_ref(),
"knowledge_",
ANN_CONSUMER,
ns,
model,
ann_segment_dir(rt, ns, model).is_none(),
)
.await
.map_err(|e| e.to_string())
}
pub(super) async fn write_force_rebuild_sentinel_row(
rt: &KhiveRuntime,
key: &AnnKey,
) -> Result<(), String> {
let sql = rt.sql();
if ann_segment_dir(rt, &key.namespace, &key.model).is_none() {
let mut writer = sql.writer().await.map_err(|error| error.to_string())?;
writer
.execute(ann_registry::pathless_mark_recovering(
"knowledge_",
ANN_CONSUMER,
&key.namespace,
&key.model,
))
.await
.map_err(|error| error.to_string())?;
return Ok(());
}
ann_registry::mark_recovering(sql.as_ref(), ANN_CONSUMER, &key.namespace, &key.model)
.await
.map_err(|error| error.to_string())
}
pub(super) async fn write_force_rebuild_sentinel(
rt: &KhiveRuntime,
key: &AnnKey,
) -> Result<(), String> {
let _publication_lock = match ann_segment_dir(rt, &key.namespace, &key.model) {
Some(dir) => Some(
khive_retrieval::ann::acquire_checkpoint_lock_async(dir, BRIDGE_LOCK_MESSAGE_PREFIX)
.await?,
),
None => None,
};
if matches!(
read_own_watermark(rt, &key.namespace, &key.model).await?,
Some(watermark) if watermark >= 0
) {
return Ok(());
}
write_force_rebuild_sentinel_row(rt, key).await
}
pub(super) async fn prepare_authoritative_rebuild(
rt: &KhiveRuntime,
ann: &SharedAnn,
key: &AnnKey,
) -> Result<(), String> {
mark_force_rebuild(ann, key);
let local_publication_lock = checkpoint_lock(ann, key);
let _local_publication_guard = local_publication_lock.lock().await;
write_force_rebuild_sentinel(rt, key).await
}
pub(super) async fn read_own_watermark(
rt: &KhiveRuntime,
ns: &str,
model: &str,
) -> Result<Option<i64>, String> {
let sql = rt.sql();
ann_registry::read_watermark(sql.as_ref(), "", ANN_CONSUMER, ns, model)
.await
.map_err(|e| e.to_string())
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum CheckpointAuthority {
Incremental,
FullRegistered,
FullSentinel,
}
pub(crate) async fn prepare_full_corpus_scan(
rt: &KhiveRuntime,
ann: &SharedAnn,
key: &AnnKey,
) -> Result<CheckpointAuthority, String> {
match read_own_watermark(rt, &key.namespace, &key.model).await? {
Some(watermark) if watermark >= 0 => Ok(CheckpointAuthority::FullRegistered),
Some(watermark) if watermark == ann_registry::RECOVERING_WATERMARK => {
mark_force_rebuild(ann, key);
Ok(CheckpointAuthority::FullSentinel)
}
Some(_) | None => {
prepare_authoritative_rebuild(rt, ann, key).await?;
Ok(CheckpointAuthority::FullSentinel)
}
}
}
pub(super) async fn raise_watermark(
rt: &KhiveRuntime,
ns: &str,
model: &str,
s: u64,
authority: CheckpointAuthority,
) -> Result<(), String> {
let shared_authority = match authority {
CheckpointAuthority::FullSentinel => WatermarkAuthority::Recovering,
CheckpointAuthority::Incremental => WatermarkAuthority::Active,
CheckpointAuthority::FullRegistered => WatermarkAuthority::PendingOrActive,
};
let sql = rt.sql();
let pathless = ann_segment_dir(rt, ns, model).is_none();
if pathless {
i64::try_from(s)
.map_err(|_| format!("knowledge ANN watermark {s} exceeds SQLite INTEGER range"))?;
}
let raised = ann_registry::raise_watermark_dispatch(
sql.as_ref(),
"knowledge_",
ANN_CONSUMER,
ns,
model,
s,
shared_authority,
pathless,
)
.await
.map_err(|e| e.to_string())?;
if !raised {
return Err(format!(
"ANN watermark publication fence rejected {authority:?}: affected 0 rows"
));
}
Ok(())
}
pub(super) fn knowledge_corpus(ns: &str) -> CorpusScope<'_> {
CorpusScope {
namespace: Some(ns),
record_kind: None,
field: "knowledge.atom",
live_join: None,
watermark_capture: WatermarkCapture::LogHighWater,
}
}
pub(super) async fn compact_log(rt: &KhiveRuntime, ns: &str, model: &str) -> Result<(), String> {
let sql = rt.sql();
ann_registry::compact_dispatch(
sql.as_ref(),
"knowledge_",
knowledge_corpus(ns).compaction_scope(),
model,
ann_segment_dir(rt, ns, model).is_none(),
)
.await
.map_err(|e| e.to_string())
}
pub(super) async fn tail_exists(
rt: &KhiveRuntime,
ns: &str,
model: &str,
s: u64,
) -> Result<bool, String> {
let sql = rt.sql();
let mut reader = sql.reader().await.map_err(|e| e.to_string())?;
let rows = reader
.query_all(knowledge_corpus(ns).tail_exists(model, s, "ann_tail_probe"))
.await
.map_err(|e| e.to_string())?;
match rows.first().and_then(|r| r.get("has_tail")) {
Some(SqlValue::Integer(n)) => Ok(*n != 0),
other => Err(format!("tail probe: unexpected value {other:?}")),
}
}
pub(super) async fn scope_counts(
rt: &KhiveRuntime,
ns: &str,
model: &str,
s: u64,
) -> Result<(u64, u64), String> {
let table_name = format!("vec_{}", sanitize_model_key(model));
let sql = rt.sql();
let mut reader = sql.reader().await.map_err(|e| e.to_string())?;
let rows = reader
.query_all(knowledge_corpus(ns).scope_counts(&table_name, model, s, "ann_scope_counts"))
.await
.map_err(|e| e.to_string())?;
let row = rows
.into_iter()
.next()
.ok_or("scope_counts returned no row")?;
let get = |col: &str| match row.get(col) {
Some(SqlValue::Integer(n)) => u64::try_from(*n).map_err(|_| format!("negative {col}")),
other => Err(format!("scope_counts {col}: unexpected value {other:?}")),
};
Ok((get("live")?, get("tail")?))
}
pub(super) struct ClassificationScopeCounts {
pub(super) live_lower_bound: u64,
pub(super) tail: u64,
pub(super) live_count_exact: bool,
}
pub(super) async fn classification_scope_counts(
rt: &KhiveRuntime,
ns: &str,
model: &str,
s: u64,
threshold: f64,
) -> Result<ClassificationScopeCounts, String> {
let multiplier = (2.0 / threshold).ceil();
let multiplier = if multiplier.is_finite() && multiplier < i64::MAX as f64 {
SqlValue::Integer(multiplier as i64)
} else {
SqlValue::Null
};
let table_name = format!("vec_{}", sanitize_model_key(model));
let sql = rt.sql();
let mut reader = sql.reader().await.map_err(|e| e.to_string())?;
let rows = reader
.query_all(knowledge_corpus(ns).classification_scope_counts(
&table_name,
model,
s,
multiplier,
"ann_classification_scope_counts",
))
.await
.map_err(|e| e.to_string())?;
let row = rows
.into_iter()
.next()
.ok_or("classification_scope_counts returned no row")?;
let get = |col: &str| match row.get(col) {
Some(SqlValue::Integer(n)) => u64::try_from(*n).map_err(|_| format!("negative {col}")),
other => Err(format!(
"classification_scope_counts {col}: unexpected value {other:?}"
)),
};
let live_lower_bound = get("live")?;
let tail = get("tail")?;
let cap = match row.get("cap") {
Some(SqlValue::Integer(n)) => *n,
other => return Err(format!("classification_scope_counts cap: {other:?}")),
};
Ok(ClassificationScopeCounts {
live_lower_bound,
tail,
live_count_exact: cap < 0 || live_lower_bound < cap as u64,
})
}