brainwires-storage 0.8.0

Backend-agnostic storage, tiered memory, and document management for the Brainwires Agent Framework
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

//! Integration tests for the unified database layer.
//!
//! These tests exercise `LanceDatabase` through trait objects to verify
//! that the `StorageBackend` and `VectorDatabase` dyn-safety works as
//! expected in real consumer code.

#[cfg(feature = "lance-backend")]
mod lance_integration {
    use std::sync::Arc;

    use brainwires_storage::databases::capabilities::BackendCapabilities;
    use brainwires_storage::databases::lance::LanceDatabase;
    use brainwires_storage::databases::traits::StorageBackend;
    use brainwires_storage::databases::types::{FieldDef, FieldType, FieldValue, Filter};

    /// Verify that `LanceDatabase` can be used as `Arc<dyn StorageBackend>`
    /// and that basic CRUD operations work through the trait object.
    #[tokio::test]
    async fn test_trait_object_crud() {
        let temp = tempfile::TempDir::new().unwrap();
        let db_path = temp.path().join("integration.lance");
        let db: Arc<dyn StorageBackend> =
            Arc::new(LanceDatabase::new(db_path.to_str().unwrap()).await.unwrap());

        // ensure_table
        let schema = vec![
            FieldDef::required("key", FieldType::Utf8),
            FieldDef::required("val", FieldType::Int64),
        ];
        db.ensure_table("items", &schema).await.unwrap();

        // insert
        let records = vec![
            vec![
                ("key".to_string(), FieldValue::Utf8(Some("x".to_string()))),
                ("val".to_string(), FieldValue::Int64(Some(10))),
            ],
            vec![
                ("key".to_string(), FieldValue::Utf8(Some("y".to_string()))),
                ("val".to_string(), FieldValue::Int64(Some(20))),
            ],
        ];
        db.insert("items", records).await.unwrap();

        // count (all)
        let total = db.count("items", None).await.unwrap();
        assert_eq!(total, 2);

        // query with filter
        let filter = Filter::Eq("key".into(), FieldValue::Utf8(Some("x".into())));
        let rows = db.query("items", Some(&filter), None).await.unwrap();
        assert_eq!(rows.len(), 1);
        let val = rows[0]
            .iter()
            .find(|(n, _)| n == "val")
            .and_then(|(_, v)| v.as_i64())
            .unwrap();
        assert_eq!(val, 10);

        // delete
        db.delete("items", &filter).await.unwrap();
        let remaining = db.count("items", None).await.unwrap();
        assert_eq!(remaining, 1);
    }

    /// Verify that `BackendCapabilities` reports correctly for LanceDatabase.
    #[tokio::test]
    async fn test_backend_capabilities_lance() {
        let temp = tempfile::TempDir::new().unwrap();
        let db_path = temp.path().join("caps_int.lance");
        let db = LanceDatabase::new(db_path.to_str().unwrap()).await.unwrap();

        let caps = db.capabilities();
        assert_eq!(
            caps,
            BackendCapabilities {
                vector_search: true,
            }
        );

        // Also verify the Default impl (which should match LanceDB's advertised caps).
        assert_eq!(caps, BackendCapabilities::default());
    }
}