README
- ::addPersistentDB::add
- ::checkpointPersistentDB::checkpoint
- ::compactPersistentDB::compact
- ::count_filteredPersistentDB::count_filtered
- ::deserializePersistentDB::deserialize
- ::dimPersistentDB::dim
- ::findPersistentDB::find
- ::from_snapshotPersistentDB::from_snapshot
- ::getPersistentDB::get
- ::hasPersistentDB::has
- ::in_memoryPersistentDB::in_memory
- ::in_memory_bruteforcePersistentDB::in_memory_bruteforce
- ::in_memory_hnswPersistentDB::in_memory_hnsw
- ::in_memory_ivfPersistentDB::in_memory_ivf
- ::initPersistentDB::init
- ::metricPersistentDB::metric
- ::raw_sizePersistentDB::raw_size
- ::removePersistentDB::remove
- ::scrollPersistentDB::scroll
- ::scroll_filteredPersistentDB::scroll_filtered
- ::searchPersistentDB::search
- ::search_with_exprPersistentDB::search_with_expr
- ::search_with_filterPersistentDB::search_with_filter
- ::serialize_snapshotPersistentDB::serialize_snapshot
- ::sizePersistentDB::size
- ::storePersistentDB::store
- ::strategyPersistentDB::strategy
- ::trainPersistentDB::train
- ::update_attrsPersistentDB::update_attrs
- ::upsertPersistentDB::upsert
- ::wal_byte_sizePersistentDB::wal_byte_size
- ::wal_record_countPersistentDB::wal_record_count
- ::addVectorDB::add
- ::compactVectorDB::compact
- ::count_filteredVectorDB::count_filtered
- ::deserializeVectorDB::deserialize
- ::dimVectorDB::dim
- ::export_jsonlVectorDB::export_jsonl
- ::findVectorDB::find
- ::from_storeVectorDB::from_store
- ::getVectorDB::get
- ::hasVectorDB::has
- ::metricVectorDB::metric
- ::newVectorDB::new
- ::raw_sizeVectorDB::raw_size
- ::removeVectorDB::remove
- ::scrollVectorDB::scroll
- ::scroll_filteredVectorDB::scroll_filtered
- ::searchVectorDB::search
- ::search_with_exprVectorDB::search_with_expr
- ::serializeVectorDB::serialize
- ::sizeVectorDB::size
- ::storeVectorDB::store
- ::strategyVectorDB::strategy
- ::trainVectorDB::train
- ::update_attrsVectorDB::update_attrs
- ::upsertVectorDB::upsert
- ::with_dimVectorDB::with_dim
- ::with_hnswVectorDB::with_hnsw
- ::with_ivfVectorDB::with_ivf
V
empty_attrs

#core/filter

Filter expression DSL for attribute-based filtering.

#Expression Types

#Leaf Expressions

Match(key, value): Exact match (key == value)
Range(key, range): Numeric range query
Exists(key): Key exists and is not null
IsNull(key): Key is null or doesn't exist

#Composite Expressions

Must([exprs]): All must match (AND)
MustNot([exprs]): None must match (AND NOT)
Should([exprs], min): At least N must match (OR with minimum)

#Filter Strategies

PreFilter: Filter before vector search (faster for selective filters)
PostFilter: Filter after vector search (simpler, always correct)
Auto: Automatically choose based on selectivity

#Usage

let filter = FilterExpr::must([
  FilterExpr::match_("category", @types.String("electronics")),
  FilterExpr::range("price", NumericRange::between(10.0, 100.0)),
])
let matches = filter.evaluate(attrs)

FilterExpr

source

pub(all) enum FilterExpr {
  Leaf(LeafExpr)
  Must(Array[FilterExpr])
  MustNot(Array[FilterExpr])
  Should(Array[FilterExpr], Int)
}

Filter expression (can be nested)

impl Show for FilterExpr

FilterExpr::exists

source

fn FilterExpr::exists(key : String) -> FilterExpr

Create an Exists filter

FilterExpr::is_null

source

fn FilterExpr::is_null(key : String) -> FilterExpr

Create an IsNull filter

FilterExpr::match_

source

fn FilterExpr::match_(key : String, value : @trkbt10/vcdb/core/types.AttrValue
AttrValue) -> FilterExpr

Create a Match filter

FilterExpr::must

source

fn FilterExpr::must(exprs : Array[FilterExpr]) -> FilterExpr

Create a Must (AND) filter

FilterExpr::must_not

source

fn FilterExpr::must_not(exprs : Array[FilterExpr]) -> FilterExpr

Create a MustNot (NOT) filter

FilterExpr::range

source

fn FilterExpr::range(key : String, range : @trkbt10/vcdb/core/types.NumericRange
NumericRange) -> FilterExpr

Create a Range filter

FilterExpr::should

source

fn FilterExpr::should(exprs : Array[FilterExpr], min? : Int) -> FilterExpr

Create a Should (OR) filter with minimum matches

FilterStrategy

source

pub(all) enum FilterStrategy {
  PreFilter
  PostFilter
  Auto
}

Filter strategy for search

impl Show for FilterStrategy

LeafExpr

source

pub(all) enum LeafExpr {
  Match(String, @trkbt10/vcdb/core/types.AttrValue
AttrValue)
  Range(String, @trkbt10/vcdb/core/types.NumericRange
NumericRange)
  Exists(String)
  IsNull(String)
}

Leaf expression types

impl Show for LeafExpr

compile_filter

source

fn compile_filter(expr : FilterExpr) -> ((@trkbt10/vcdb/core/types.VectorId
VectorId, @trkbt10/vcdb/core/types.Attrs
Attrs) -> Bool)

Compile a filter expression to a predicate function

eval_filter

source

fn eval_filter(expr : FilterExpr, attrs : @trkbt10/vcdb/core/types.Attrs
Attrs) -> Bool

Evaluate a filter expression against attrs

filter_to_json

source

fn filter_to_json(expr : FilterExpr) -> String

Serialize a FilterExpr to JSON string.

get_candidates_basic

source

fn get_candidates_basic(expr : FilterExpr, index : @trkbt10/vcdb/core/attr.BasicAttrIndex
BasicAttrIndex) -> Array[@trkbt10/vcdb/core/types.VectorId
VectorId]?

Get candidate IDs from a basic attribute index using a filter expression Returns None if pre-filtering is not possible (should use post-filter)

parse_filter_json

source

fn parse_filter_json(json : String) -> FilterExpr?

Parse a JSON string into a FilterExpr. Returns None for empty/invalid input.

resolve_candidates_bptree

source

fn resolve_candidates_bptree(expr : FilterExpr, index : @trkbt10/vcdb/core/attr.BPTreeAttrIndex
BPTreeAttrIndex) -> Array[@trkbt10/vcdb/core/types.VectorId
VectorId]

Resolve candidate IDs from a B+ tree attribute index. Every FilterExpr variant is resolved through the index — there is no fallback to post-filtering. This guarantees a single execution path regardless of the expression shape.

IsNull(key): complement of exists(key) against all indexed IDs
MustNot(exprs): complement of union(resolve(e)) against all IDs
Should(exprs, min>1): count per-ID and threshold