khive-db 0.20.0

SQLite storage backend: entities, edges, notes, events, FTS5, sqlite-vec vectors.
Documentation
use super::*;

const KINDS: [StoreSchemaKind; 5] = [
    StoreSchemaKind::Entities,
    StoreSchemaKind::Graph,
    StoreSchemaKind::Notes,
    StoreSchemaKind::Events,
    StoreSchemaKind::Agents,
];

fn schema_attempts(backend: &StorageBackend, kind: StoreSchemaKind) -> usize {
    backend.store_schemas[kind as usize]
        .attempts
        .load(Ordering::Relaxed)
}

fn index_exists(backend: &StorageBackend, name: &str) -> bool {
    let reader = backend.pool.reader().unwrap();
    reader
        .conn()
        .query_row(
            "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = ?1)",
            [name],
            |row| row.get(0),
        )
        .unwrap()
}

#[test]
fn serving_store_schemas_run_every_ensure_once_and_leave_accessors_warm() {
    let dir = tempfile::tempdir().unwrap();
    let backend = StorageBackend::sqlite_for_test(dir.path().join("prepare.db")).unwrap();

    backend.prepare_serving_store_schemas().unwrap();
    backend.prepare_serving_store_schemas().unwrap();
    for kind in KINDS {
        assert_eq!(schema_attempts(&backend, kind), 1, "{kind:?}");
    }

    let before = backend.pool.writer_acquisition_snapshot();
    backend.entities_for_namespace("local").unwrap();
    backend.graph_for_namespace("local").unwrap();
    backend.events_for_namespace("local").unwrap();
    backend.agents().unwrap();
    let after = backend.pool.writer_acquisition_snapshot();
    assert_eq!(
        after.pooled_acquisitions, before.pooled_acquisitions,
        "a prepared store accessor takes no writer"
    );
    for kind in KINDS {
        assert_eq!(schema_attempts(&backend, kind), 1, "{kind:?}");
    }
    assert_eq!(backend.notes_seq_repair_run_count(), 0);
}

#[test]
fn notes_seq_repair_reports_the_rows_it_inserted_once() {
    let dir = tempfile::tempdir().unwrap();
    let backend = StorageBackend::sqlite_for_test(dir.path().join("notes-seq.db")).unwrap();
    {
        let writer = backend.pool.try_writer().unwrap();
        note::ensure_notes_schema(writer.conn()).unwrap();
        writer
            .conn()
            .execute_batch(
                "INSERT INTO notes(id, namespace, kind, content, created_at, updated_at) VALUES \
                 ('legacy-a', 'local', 'observation', 'a', 1, 1), \
                 ('legacy-b', 'local', 'observation', 'b', 2, 2), \
                 ('legacy-c', 'local', 'observation', 'c', 3, 3); \
                 DELETE FROM notes_seq WHERE note_id IN ('legacy-a', 'legacy-b');",
            )
            .unwrap();
    }

    assert_eq!(backend.repair_notes_seq_once().unwrap(), Some(2));
    assert_eq!(backend.repair_notes_seq_once().unwrap(), None);
    backend.notes().unwrap();
    assert_eq!(backend.notes_seq_repair_run_count(), 1);

    let reader = backend.pool.reader().unwrap();
    let mapped: i64 = reader
        .conn()
        .query_row(
            "SELECT COUNT(*) FROM notes_seq WHERE note_id IN ('legacy-a', 'legacy-b', 'legacy-c')",
            [],
            |row| row.get(0),
        )
        .unwrap();
    assert_eq!(mapped, 3);
}

#[test]
fn notes_seq_repair_after_a_notes_acquisition_does_not_run_again() {
    let dir = tempfile::tempdir().unwrap();
    let backend = StorageBackend::sqlite_for_test(dir.path().join("notes-first.db")).unwrap();
    backend.notes().unwrap();
    assert_eq!(backend.repair_notes_seq_once().unwrap(), None);
    assert_eq!(backend.notes_seq_repair_run_count(), 1);
}

#[test]
fn mapped_text_table_keys_list_only_tables_with_a_rowid_map() {
    let dir = tempfile::tempdir().unwrap();
    let backend = StorageBackend::sqlite_for_test(dir.path().join("mapped.db")).unwrap();
    backend.text("alpha").unwrap();
    backend.text("beta").unwrap();
    {
        let writer = backend.pool.try_writer().unwrap();
        writer
            .conn()
            .execute_batch("CREATE VIRTUAL TABLE fts_triggered USING fts5(body);")
            .unwrap();
    }

    let keys = backend.mapped_text_table_keys().unwrap();
    assert!(keys.iter().any(|key| key == "alpha"), "{keys:?}");
    assert!(keys.iter().any(|key| key == "beta"), "{keys:?}");
    assert!(!keys.iter().any(|key| key == "triggered"), "{keys:?}");
    assert!(
        keys.iter().all(|key| !key.ends_with("_rowids")
            && !key.ends_with("_rowids_state")
            && !key.ends_with("_data")),
        "only FTS tables themselves are listed: {keys:?}"
    );
}

#[test]
fn forced_index_check_rebuilds_a_dropped_index_and_then_reads_clean() {
    let dir = tempfile::tempdir().unwrap();
    let backend = StorageBackend::sqlite_for_test(dir.path().join("forced.db")).unwrap();
    backend.prepare_serving_store_schemas().unwrap();

    let clean = backend.check_serving_forced_indexes().unwrap();
    assert_eq!(clean.checked, 7);
    assert!(clean.rebuilt.is_empty(), "{clean:?}");

    {
        let writer = backend.pool.try_writer().unwrap();
        writer
            .conn()
            .execute_batch(
                "DROP INDEX idx_graph_edges_ns_src_rel; \
                 DROP INDEX idx_notes_message_recipient_direction;",
            )
            .unwrap();
    }
    let repaired = backend.check_serving_forced_indexes().unwrap();
    assert_eq!(
        repaired.rebuilt,
        vec![
            "idx_graph_edges_ns_src_rel",
            "idx_notes_message_recipient_direction"
        ]
    );
    assert!(index_exists(&backend, "idx_graph_edges_ns_src_rel"));
    assert!(index_exists(
        &backend,
        "idx_notes_message_recipient_direction"
    ));
    assert_eq!(schema_attempts(&backend, StoreSchemaKind::Graph), 2);
    assert_eq!(schema_attempts(&backend, StoreSchemaKind::Notes), 2);
    assert_eq!(schema_attempts(&backend, StoreSchemaKind::Entities), 1);

    let again = backend.check_serving_forced_indexes().unwrap();
    assert!(again.rebuilt.is_empty(), "{again:?}");
}

#[test]
fn forced_index_check_on_a_read_only_store_names_the_missing_index() {
    let dir = tempfile::tempdir().unwrap();
    let path = dir.path().join("forced-ro.db");
    {
        let writable = StorageBackend::sqlite_for_test(&path).unwrap();
        writable.prepare_serving_store_schemas().unwrap();
        let writer = writable.pool.try_writer().unwrap();
        writer
            .conn()
            .execute_batch("DROP INDEX idx_notes_created;")
            .unwrap();
    }
    let readonly = StorageBackend::sqlite_read_only_for_test(&path).unwrap();
    let error = readonly.check_serving_forced_indexes().unwrap_err();
    assert!(error.to_string().contains("idx_notes_created"), "{error}");
}