nodedb-lite 0.1.0

Embedded edge client for NodeDB — offline vector search, graph traversal, and CRDT sync
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

// SPDX-License-Identifier: Apache-2.0

//! Test-only helpers shared by the per-submodule test modules. Builds an
//! in-memory `LiteQueryEngine` with all engine states wired up and a 1-dim,
//! 1-attr AST pair (`dim1_ast` / `attr1_ast`) used by most array tests.

use std::sync::{Arc, Mutex};

use nodedb_sql::types_array::{
    ArrayAttrAst, ArrayAttrType, ArrayDimAst, ArrayDimType, ArrayDomainBound,
};

use crate::PagedbStorageMem;
use crate::engine::array::engine::ArrayEngineState;
use crate::engine::columnar::ColumnarEngine;
use crate::engine::fts::FtsState;
use crate::engine::spatial::SpatialIndexManager;
use crate::engine::vector::VectorState;
use crate::query::engine::{LiteQueryEngine, LiteQueryEngineParams};

pub(super) async fn make_engine() -> LiteQueryEngine<PagedbStorageMem> {
    let storage = Arc::new(
        PagedbStorageMem::open_in_memory()
            .await
            .expect("in-memory pagedb"),
    );
    let crdt = Arc::new(Mutex::new(
        crate::engine::crdt::CrdtEngine::new(1).expect("crdt"),
    ));
    let governor = crate::query::engine::test_governor();
    let strict = Arc::new(crate::engine::strict::StrictEngine::new(Arc::clone(
        &storage,
    )));
    let columnar = Arc::new(ColumnarEngine::new(
        Arc::clone(&storage),
        crate::query::engine::test_scoped_memory(&governor, nodedb_mem::EngineId::Columnar),
    ));
    let htap = Arc::new(crate::engine::htap::HtapBridge::new());
    let timeseries = Arc::new(Mutex::new(
        crate::engine::timeseries::engine::TimeseriesEngine::new(),
    ));
    let vector_state = Arc::new(VectorState::new(
        Arc::clone(&storage),
        100,
        crate::query::engine::test_scoped_memory(&governor, nodedb_mem::EngineId::Vector),
    ));
    let array_state = Arc::new(tokio::sync::Mutex::new(
        ArrayEngineState::open(&storage).await.expect("array"),
    ));
    let fts_state = Arc::new(FtsState::new(Arc::clone(&governor)));
    let spatial = Arc::new(Mutex::new(SpatialIndexManager::new(
        crate::query::engine::test_scoped_memory(&governor, nodedb_mem::EngineId::Spatial),
    )));
    LiteQueryEngine::new(LiteQueryEngineParams {
        crdt,
        strict,
        columnar,
        htap,
        storage,
        timeseries,
        vector_state,
        array_state,
        fts_state,
        sparse_state: Arc::new(crate::engine::sparse_vector::SparseVectorState::new()),
        spatial,
        csr: Arc::new(Mutex::new(std::collections::HashMap::new())),
        governor,
        kv_local: crate::query::engine::test_kv_local(),
    })
}

pub(super) fn dim1_ast() -> Vec<ArrayDimAst> {
    vec![ArrayDimAst {
        name: "x".to_string(),
        dtype: ArrayDimType::Int64,
        lo: ArrayDomainBound::Int64(0),
        hi: ArrayDomainBound::Int64(15),
    }]
}

pub(super) fn attr1_ast() -> Vec<ArrayAttrAst> {
    vec![ArrayAttrAst {
        name: "v".to_string(),
        dtype: ArrayAttrType::Int64,
        nullable: false,
    }]
}