Struct FtsCollectionManager 

pub struct FtsCollectionManager { /* private fields */ }

Manages per-collection (and per-field) in-memory full-text search indexes.

Each (collection, field) pair gets its own FtsIndex<MemoryBackend>. The bare "{collection}" key holds whole-document text (all string fields concatenated), searched when a caller names no field.

Implementations

impl FtsCollectionManager

pub fn set_collection_analyzer( &mut self, collection: &str, analyzer_name: &str, ) -> Result<(), LiteError>

Bind analyzer_name to every index belonging to collection, and retain it so indexes created later inherit the same analyzer.

Unrecognized names fall back to the standard analyzer inside nodedb-fts at resolve time, matching Origin’s behavior. Fails when an index cannot record the binding.

pub fn set_collection_fuzzy( &mut self, collection: &str, fuzzy: bool, ) -> Result<(), LiteError>

Bind the default fuzzy-matching flag to every index belonging to collection, and retain it so indexes created later inherit it. Fails when an index cannot record the binding.

impl FtsCollectionManager

pub fn index_document_fields( &mut self, collection: &str, doc_id: &str, fields: &HashMap<String, Value>, ) -> Result<Vec<(String, String)>, LiteError>

Index a schemaless document: its whole-document text under the bare "{collection}" key and each top-level string field under "{collection}:{field}".

Replaces whatever the document held before. The document is retracted from every other field index of the collection, so a field it no longer carries as a string stops matching. A field with an empty name has no key of its own and is searchable through the whole-document index only.

Returns the indexed (field, text) pairs sorted by field name, without empty field names. The list is empty when the document holds no indexable string field.

pub fn remove_document_fields( &self, collection: &str, doc_id: &str, ) -> Result<(), LiteError>

Remove a document from every index of collection: the whole-document index and each per-field index.

pub fn index_document( &mut self, collection: &str, doc_id: &str, text: &str, ) -> Result<(), LiteError>

Index text as a document’s whole-document entry.

The document is stored under the bare "{collection}" key. Calling again with the same doc_id replaces the previous entry.

Empty text is a removal, not a no-op: a document updated until it has no indexable words must stop matching the words it used to contain.

pub fn remove_document( &self, collection: &str, doc_id: &str, ) -> Result<(), LiteError>

Remove a document from the whole-document index.

pub fn index_field( &mut self, collection: &str, field: &str, doc_id: &str, text: &str, ) -> Result<(), LiteError>

Index a single field value for a document.

Key is "{collection}:{field}". Calling again with the same doc_id replaces the previous entry (upsert semantics).

Empty text is a removal, not a no-op: clearing a field must stop the document matching the words that field used to contain.

pub fn remove_field( &self, collection: &str, field: &str, doc_id: &str, ) -> Result<(), LiteError>

Remove a document’s entry from the field index of a collection.

pub fn register_origin_surrogate( &mut self, origin_surrogate: Surrogate, doc_id: &str, )

Register an association between an Origin global surrogate and the Lite string doc_id. Called from the FtsIndexDoc execution arm so FtsDeleteDoc can later resolve the Origin surrogate to a string doc_id and call the proper single-doc removal instead of dropping the collection.

pub fn remove_by_origin_surrogate( &mut self, collection: &str, origin_surrogate: Surrogate, ) -> Result<Option<String>, LiteError>

Remove a single document identified by its Origin-assigned surrogate.

Returns the removed doc_id, or None if the surrogate has no known Lite mapping (e.g. it was never indexed via this Lite instance).

impl FtsCollectionManager

pub fn phrase_search( &self, collection: &str, field: &str, terms: &[String], top_k: usize, params: &TextSearchParams, ) -> Result<Vec<FtsResult>, LiteError>

Search the field index for documents where terms appear as an exact consecutive phrase. An empty field searches the whole-document index.

The phrase runs through the index’s analyzer first, so it matches the same stemmed, lower-cased tokens the documents were indexed as. Candidates are the documents holding every token at consecutive positions. Each one scores its BM25 score for the phrase with an earlier-position bonus.

impl FtsCollectionManager

pub fn new(governor: Arc<MemoryGovernor>) -> Self

pub fn is_empty(&self) -> bool

Returns true if no collections are indexed.

pub fn collection_count(&self) -> usize

Number of distinct collection prefixes with active indexes.

pub fn has_text_index(&self, collection: &str) -> bool

Whether any document of collection was ever text-indexed.

pub fn drop_collection(&mut self, collection: &str)

Drop all FTS indexes for a collection (called on collection drop/truncate).

impl FtsCollectionManager

pub fn search( &self, collection: &str, field: &str, query: &str, top_k: usize, params: &TextSearchParams, ) -> Result<Vec<FtsResult>, LiteError>

Search the collection’s field index. An empty field searches the whole-document index. Collections without indexed text return an empty list.

TextSearchParams controls boolean mode and fuzzy matching. Queries without matching documents return an empty list. Read errors propagate.

pub fn scan_all_with_scores( &self, collection: &str, field: &str, query: &str, params: &TextSearchParams, allowed: Option<&HashSet<String>>, ) -> Result<Vec<(String, f32)>, LiteError>

Return every document the field index of collection holds, with its BM25 score against query. Documents outside the BM25 hit set score 0.0. This powers the score columns of text reads.

allowed restricts the documents to the named ones. The query’s AND-mode fallback is then decided over those documents only.