kevy 3.18.0

kevy — a pure-Rust, zero-dependency, Redis-compatible KV server.
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

//! v2.5 — IDX.* read surface: the extension fan-out halves
//! (per-shard op + origin reduce) and the query grammar. Split from
//! [`crate::cmd_index`] under the 500-LOC house rule; v3.18 re-split
//! into submodules ([`args`] grammar, [`ops`] ranked/agg/compose ops,
//! [`query`] scalar query + admin, [`wire`] chunk/cursor encoding).

mod args;
mod ops;
mod query;
mod wire;

pub(crate) use args::{ComposeQuery, HybridArgs, KnnArgs, MatchArgs, Query, parse_groups_args};
pub(crate) use wire::{decode_value, decode_view_cursor, encode_value, hex};

use kevy_store::Store;

/// One hit's hydrated field values (None = field absent).
pub(crate) type Hydrated = Vec<Option<Vec<u8>>>;

// ---------- extension fan-out (reads) ----------

pub(crate) const ST_OK: u8 = 0;
pub(crate) const ST_BUILDING: u8 = 1;
pub(crate) const ST_NOINDEX: u8 = 2;
pub(crate) const ST_BADARGS: u8 = 3;
pub(crate) const ST_OVERBUDGET: u8 = 4;

/// Per-shard half: parse the IDX.* argv, run against this shard's
/// segment, emit a status-tagged chunk.
pub(crate) fn extension_op(store: &mut Store, argv: &[Vec<u8>]) -> Vec<u8> {
    let verb = argv.first().map(Vec::as_slice).unwrap_or(b"");
    if verb.eq_ignore_ascii_case(b"IDX.LIST") {
        return query::op_list(store);
    }
    if argv.get(1).is_some_and(|a| a.eq_ignore_ascii_case(b"HYBRID")) {
        return ops::op_hybrid(store, argv);
    }
    if argv.get(1).is_some_and(|a| a.eq_ignore_ascii_case(b"COMPOSE")) {
        return ops::op_compose(store, argv);
    }
    // v3.10: IDX.EXPLAIN <name> <shape…> — the exact IDX.QUERY parse,
    // ZERO execution.
    if verb.eq_ignore_ascii_case(b"IDX.EXPLAIN") {
        return query::op_explain(store, argv);
    }
    // v2.7: IDX.QUERY <name> MATCH <text> [LIMIT n] [FIELDS f…]
    if argv.get(2).is_some_and(|a| a.eq_ignore_ascii_case(b"MATCH")) {
        return ops::op_match(store, argv);
    }
    // v2.8: IDX.QUERY <name> KNN <vec> [LIMIT k] [FIELDS f…]
    if argv.get(2).is_some_and(|a| a.eq_ignore_ascii_case(b"KNN")) {
        return ops::op_knn(store, argv);
    }
    // v3.1: IDX.QUERY <name> GROUP <g> | GROUPS [BY m] [LIMIT n]
    if argv.get(2).is_some_and(|a| a.eq_ignore_ascii_case(b"GROUP") || a.eq_ignore_ascii_case(b"GROUPS")) {
        return ops::op_agg(store, argv);
    }
    // v3.1 phase 2 (internal): AGG.FETCH <name> <g…> — exact partials
    // for the candidate groups that survived phase-1 ranking.
    if argv.first().is_some_and(|v| v.eq_ignore_ascii_case(b"AGG.FETCH")) {
        return ops::op_agg_fetch(store, argv);
    }
    // v2.8: IDX.REBUILD <name> (ANN tombstone compaction)
    if argv
        .first()
        .is_some_and(|v| v.eq_ignore_ascii_case(b"IDX.REBUILD"))
    {
        return ops::op_rebuild(store, argv);
    }
    query::op_query(store, argv, verb)
}