khive-pack-knowledge 0.15.0

Knowledge verb pack — lore corpus (atoms/domains), TF-IDF retrieval, concept registration
Documentation
use super::*;

fn assert_same(actual: SqlStatement, expected: SqlStatement) {
    assert_eq!(actual.sql.as_bytes(), expected.sql.as_bytes());
    assert_eq!(
        serde_json::to_value(&actual.params).unwrap(),
        serde_json::to_value(&expected.params).unwrap()
    );
    assert_eq!(actual.label, expected.label);
}

#[test]
fn tail_exists_preserves_literal_sql_params_and_label() {
    for ns in ["local", "", "tenant:'quoted/知识"] {
        for model in ["model", "model.with-unsafe/标记'quoted"] {
            for s in [0, 1, i64::MAX as u64, u64::MAX] {
                let actual = knowledge_corpus(ns).tail_exists(model, s, "ann_tail_probe");
                let expected = SqlStatement {
                    sql: "SELECT EXISTS(SELECT 1 FROM ann_write_log \
                  WHERE namespace = ?1 AND embedding_model = ?2 \
                    AND field = 'knowledge.atom' AND seq > ?3) AS has_tail"
                        .into(),
                    params: vec![
                        SqlValue::Text(ns.to_owned()),
                        SqlValue::Text(model.to_owned()),
                        SqlValue::Integer(s as i64),
                    ],
                    label: Some("ann_tail_probe".into()),
                };
                assert_same(actual, expected);
            }
        }
    }
}

#[test]
fn scope_counts_preserves_literal_sql_params_and_label() {
    for ns in ["local", "", "tenant:'quoted/知识"] {
        for model in ["model", "model.with-unsafe/标记'quoted"] {
            for s in [0, 1, i64::MAX as u64, u64::MAX] {
                let table_name = format!("vec_{}", sanitize_model_key(model));
                let actual =
                    knowledge_corpus(ns).scope_counts(&table_name, model, s, "ann_scope_counts");
                let expected = SqlStatement {
                    sql: format!(
                        "SELECT \
                   (SELECT COUNT(*) FROM {table_name} \
                     WHERE namespace = ?1 AND embedding_model = ?2 \
                       AND field = 'knowledge.atom') AS live, \
                   (SELECT COUNT(*) FROM ann_write_log \
                     WHERE namespace = ?1 AND embedding_model = ?2 \
                       AND field = 'knowledge.atom' AND seq > ?3) AS tail"
                    ),
                    params: vec![
                        SqlValue::Text(ns.to_owned()),
                        SqlValue::Text(model.to_owned()),
                        SqlValue::Integer(s as i64),
                    ],
                    label: Some("ann_scope_counts".into()),
                };
                assert_same(actual, expected);
            }
        }
    }
}

#[test]
fn classification_scope_counts_preserves_literal_sql_params_and_label() {
    for ns in ["local", "", "tenant:'quoted/知识"] {
        for model in ["model", "model.with-unsafe/标记'quoted"] {
            for s in [0, 1, i64::MAX as u64, u64::MAX] {
                let table_name = format!("vec_{}", sanitize_model_key(model));
                for multiplier in [
                    SqlValue::Null,
                    SqlValue::Integer(0),
                    SqlValue::Integer(8),
                    SqlValue::Integer(i64::MAX),
                ] {
                    let actual = knowledge_corpus(ns).classification_scope_counts(
                        &table_name,
                        model,
                        s,
                        multiplier.clone(),
                        "ann_classification_scope_counts",
                    );
                    let expected = SqlStatement {
                        sql: format!(
                            "WITH tail AS MATERIALIZED (\
                   SELECT COUNT(*) AS tail_rows FROM ann_write_log \
                   WHERE namespace = ?1 AND embedding_model = ?2 \
                     AND field = 'knowledge.atom' AND seq > ?3\
                 ), cap AS MATERIALIZED (\
                   SELECT CASE \
                     WHEN tail_rows = 1 THEN 1 \
                     WHEN tail_rows = 0 OR ?4 IS NULL \
                       OR tail_rows > 9223372036854775807 / ?4 THEN -1 \
                     ELSE tail_rows * ?4 END AS max_rows FROM tail\
                 ), live AS (\
                   SELECT COUNT(*) AS live_rows FROM (\
                     SELECT 1 FROM {table_name} \
                     WHERE namespace = ?1 AND embedding_model = ?2 \
                       AND field = 'knowledge.atom' \
                     LIMIT (SELECT max_rows FROM cap)\
                   )\
                 ) \
                 SELECT live.live_rows AS live, tail.tail_rows AS tail, \
                        cap.max_rows AS cap FROM live CROSS JOIN tail CROSS JOIN cap"
                        ),
                        params: vec![
                            SqlValue::Text(ns.to_owned()),
                            SqlValue::Text(model.to_owned()),
                            SqlValue::Integer(s as i64),
                            multiplier,
                        ],
                        label: Some("ann_classification_scope_counts".into()),
                    };
                    assert_same(actual, expected);
                }
            }
        }
    }
}

#[test]
fn compaction_keeps_its_registry_scope() {
    for ns in ["local", "", "tenant:'quoted/知识"] {
        assert_eq!(
            knowledge_corpus(ns).compaction_scope(),
            khive_retrieval::ann::registry::CompactionScope::Namespace(ns.to_owned())
        );
    }
}