khive-db 0.10.0

SQLite storage backend: entities, edges, notes, events, FTS5, sqlite-vec vectors.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

#[tokio::test]
async fn ordinary_store_accessors_ignore_request_read_cancellation() {
    let backend = StorageBackend::memory().unwrap();
    let (_sender, receiver) = tokio::sync::watch::channel(true);
    khive_storage::scope_request_read_cancellation(receiver, async {
        backend.notes().expect("ordinary notes accessor");
        backend.events().expect("ordinary events accessor");
        #[cfg(feature = "vectors")]
        backend
            .vectors("ordinary_store", "ordinary-store", 8)
            .expect("ordinary vectors accessor");
    })
    .await;
}

#[tokio::test]
async fn admitted_store_constructor_finishes_ddl_after_cancellation() {
    let backend = StorageBackend::memory().unwrap();
    let (sender, receiver) = tokio::sync::watch::channel(false);
    let fired = Arc::new(std::sync::atomic::AtomicBool::new(false));
    {
        let writer = backend.pool.writer().unwrap();
        let fired = fired.clone();
        writer
            .conn()
            .authorizer(Some(move |_: rusqlite::hooks::AuthContext<'_>| {
                fired.store(true, Ordering::SeqCst);
                sender.send_replace(true);
                rusqlite::hooks::Authorization::Allow
            }))
            .unwrap();
    }
    let result = khive_storage::scope_request_read_cancellation(receiver, async {
        khive_storage::capture_request_read_context()
            .scope_store_acquisition("admitted_notes_store", || backend.notes())
    })
    .await;
    let writer = backend.pool.writer().unwrap();
    writer
        .conn()
        .authorizer(None::<fn(rusqlite::hooks::AuthContext<'_>) -> rusqlite::hooks::Authorization>)
        .unwrap();
    result.expect("request cancellation must not interrupt admitted constructor DDL");
    assert!(
        fired.load(Ordering::SeqCst),
        "cancellation must fire inside actual SQLite work"
    );
    assert_eq!(
        backend.notes_seq_repair_run_count(),
        1,
        "constructor must finish schema repair"
    );
    assert!(sqlite_table_exists(writer.conn(), "notes_seq").unwrap());
}

#[cfg(unix)]
use khive_storage::test_support::freeze_snapshot_sidecars;

#[tokio::test]
async fn hot_path_guard_g2_file_backed_read_suite_uses_only_pooled_readers() {
    let dir = tempfile::tempdir().unwrap();
    let backend = StorageBackend::sqlite_for_test(dir.path().join("hot_path_g2.db")).unwrap();
    backend.prepare_core_schema().unwrap();

    // Construct every store named by ADR-165 Slice 2 before the counter
    // baseline. Accessor-time DDL/validation is not request read traffic.
    let entities = backend.entities().unwrap();
    let notes = backend.notes().unwrap();
    let graph = backend.graph().unwrap();
    let events = backend.events().unwrap();
    let text = backend
        .text_with_tokenizer("hot_path_g2", "unicode61")
        .unwrap();
    let agents = backend.agents().unwrap();
    let attachments = backend.attachments().unwrap();
    let sparse = backend.sparse("hot_path_g2").unwrap();
    #[cfg(feature = "vectors")]
    let vectors = backend.vectors("hot_path_g2", "test-model", 2).unwrap();
    let sql = backend.sql();

    let before = backend.pool().reader_acquisition_snapshot();
    assert_eq!(
        entities
            .count_entities("local", EntityFilter::default())
            .await
            .unwrap(),
        0
    );
    assert_eq!(notes.count_notes("local", None).await.unwrap(), 0);
    assert_eq!(graph.count_edges(EdgeFilter::default()).await.unwrap(), 0);
    assert_eq!(
        events.count_events(EventFilter::default()).await.unwrap(),
        0
    );
    assert!(text
        .get_document("local", uuid::Uuid::new_v4())
        .await
        .unwrap()
        .is_none());
    assert!(agents.get("no-such-agent").await.unwrap().is_none());
    assert!(attachments
        .get_attachment(uuid::Uuid::new_v4(), "primary")
        .await
        .unwrap()
        .is_none());
    assert_eq!(sparse.count().await.unwrap(), 0);
    #[cfg(feature = "vectors")]
    assert_eq!(vectors.count().await.unwrap(), 0);

    let mut raw = sql.reader().await.unwrap();
    assert!(matches!(
        raw.query_scalar(SqlStatement {
            sql: "SELECT 1".into(),
            params: Vec::new(),
            label: None,
        })
        .await
        .unwrap(),
        Some(SqlValue::Integer(1))
    ));

    let after = backend.pool().reader_acquisition_snapshot();
    let expected_pooled_delta = 9 + u64::from(cfg!(feature = "vectors"));
    assert_eq!(
        after.pooled_checkouts - before.pooled_checkouts,
        expected_pooled_delta,
        "each ordinary file-backed read must check out exactly one pooled reader"
    );
    assert_eq!(
        after.standalone_opens, before.standalone_opens,
        "ADR-166 G2: ordinary file-backed read verbs must not open standalone readers"
    );
    assert_eq!(after.active_pooled_checkouts, 0);
    assert_eq!(
        after.completed_pooled_checkouts - before.completed_pooled_checkouts,
        expected_pooled_delta
    );
}