Struct DistributedQueryEngine 

pub struct DistributedQueryEngine { /* private fields */ }

Distributed query engine implementing two-phase TF-IDF.

This engine executes queries across multiple shards by:

1. First collecting term frequencies from all shards
2. Computing global document frequencies
3. Re-executing queries with the global DF for accurate scoring
4. Merging and normalizing results across shards

Implementations

impl DistributedQueryEngine

pub fn new(config: DistributedHybridConfig) -> Self

Create a new distributed query engine with the given configuration.

pub fn with_defaults() -> Self

Create a query engine with default configuration.

pub fn config(&self) -> &DistributedHybridConfig

Get the configuration.

pub fn get_local_term_frequencies( &self, shard: &ShardedColony, terms: &[String], ) -> HashMap<String, u64>

Phase 1: Get term frequencies from a shard.

Collects how many documents in this shard contain each query term. This is used to compute local document frequencies.

pub fn aggregate_global_df( &self, local_dfs: Vec<HashMap<String, u64>>, ) -> HashMap<String, u64>

Phase 2: Aggregate global document frequencies.

Combines local document frequencies from all shards to compute the global DF for each term across the entire distributed graph.

pub fn execute_local_query( &self, shard: &ShardedColony, request: &LocalQueryRequest, ) -> LocalQueryResult

Phase 3: Execute local query with global DF.

Computes TF-IDF scores for nodes in a single shard using the global document frequencies for accurate IDF computation.

pub fn merge_results(&self, results: Vec<LocalQueryResult>) -> Vec<ScoredNode>

Phase 4: Merge results from all shards.

Combines results from multiple shards, normalizes scores across shards, sorts by score, and returns the top-k results.

pub fn distributed_query( &self, shards: &[&ShardedColony], query_text: &str, ) -> Vec<ScoredNode>

Execute a full distributed query across multiple shards.

This is the main entry point for distributed queries. It coordinates all four phases of the two-phase TF-IDF algorithm:

1. Collects local term frequencies from each shard
2. Aggregates them into global document frequencies
3. Executes local queries on each shard with global DF
4. Merges and normalizes results

Arguments

• shards - Slice of shard references to query
• query_text - The raw query text to search for

Returns

A vector of scored nodes, sorted by relevance (highest first).

pub fn local_query( &self, shard: &ShardedColony, query_text: &str, ) -> Vec<ScoredNode>

Execute a query on a single shard (for non-distributed use).

This is useful for testing or when the data resides in a single shard.