🥮 mooncakes.io
README

Lucius646/MoonSearch/query does not have a README file

#
Query

source
pub(open) trait Query {
  fn weight(Self, SearchStatistics) -> &Weight
}

Describes matching intent and builds query-and-snapshot-specific state.

The trait is open so applications can add query types without changing Searcher. Concrete queries create one Weight from global SearchStatistics, and each Weight creates a comparable segment-local Scorer.

#
Scorer

source
pub(open) trait Scorer {
  fn advance(Self) -> Bool
  fn advance_to(Self, 
DocId) -> Bool
  fn doc(Self) -> 
DocId
  fn score(Self) -> Double
}

Ordered iterator over matching segment-local documents and their scores.

#
Weight

source
pub(open) trait Weight {
  fn scorer(Self, 
Segment) -> &Scorer
}

Query state that can create a Scorer for an immutable segment.

#
QueryStringError

source
pub(all) suberror QueryStringError {
  Failure(QueryStringErrorKind, Int, Int)
} derive(Eq, 
Debug)

Query-string errors carry half-open UTF-8 byte offsets into the original input. The offsets remain portable across native, JS, Wasm, and WasmGC.

#
QueryStringError::end_offset

source
fn QueryStringError::end_offset(self : QueryStringError) -> Int

#
QueryStringError::kind

source

#
QueryStringError::start_offset

source
fn QueryStringError::start_offset(self : QueryStringError) -> Int

#
BlockMaxWandQuery

source
pub struct BlockMaxWandQuery {
  terms : ReadOnlyArray[
Term]
}

A disjunction of scored terms with an optimized WAND Top-K entry point.

#
BlockMaxWandQuery::new

source

#
Bm25Config

source
pub struct Bm25Config {
  k1 : Double
  b : Double
}

Tunable BM25 parameters. Defaults match Tantivy/Lucene conventions.

#
Bm25Config::b

source
fn Bm25Config::b(self : Bm25Config) -> Double

#
Bm25Config::default

source
fn Bm25Config::default() -> Bm25Config

#
Bm25Config::k1

source
fn Bm25Config::k1(self : Bm25Config) -> Double

#
Bm25Config::new

source
fn Bm25Config::new(k1 : Double, b : Double) -> Bm25Config

#
Bm25Scorer

source
pub struct Bm25Scorer {
  field_id : 
FieldId
  idf : Double
  average_length : Double
  k1 : Double
  b : Double
}

BM25 scorer using the common defaults k1=1.2 and b=0.75.

Query Weight implementations construct it from snapshot-wide statistics and use it while producing comparable segment-local Scorer results.

#
Bm25Scorer::average_field_length

source
fn Bm25Scorer::average_field_length(self : Bm25Scorer) -> Double

#
Bm25Scorer::from_statistics

source
fn Bm25Scorer::from_statistics(statistics : SearchStatistics, term : 
Term) -> Bm25Scorer

Builds query state from the complete Searcher snapshot.

#
Bm25Scorer::from_statistics_with_config

source
fn Bm25Scorer::from_statistics_with_config(statistics : SearchStatistics, term : 
Term, config : Bm25Config) -> Bm25Scorer

#
Bm25Scorer::idf

source
fn Bm25Scorer::idf(self : Bm25Scorer) -> Double

#
Bm25Scorer::new

source

Builds single-Segment BM25 state. Retained for M1-M3 API compatibility.

#
Bm25Scorer::score

source

#
BooleanClause

source
pub struct BooleanClause {
  occur : Occur
  query : &Query
}

One query and its occurrence rule in a BooleanQuery.

#
BooleanClause::new

source
fn BooleanClause::new(occur : Occur, query : &Query) -> BooleanClause

#
BooleanQuery

source
pub struct BooleanQuery {
  clauses : ReadOnlyArray[BooleanClause]
}

#
BooleanQuery::new

source

#
BoostQuery

source
pub struct BoostQuery {
  query : &Query
  boost : Double
}

Multiplies every score produced by a child query.
impl Query for BoostQuery

#
BoostQuery::new

source
fn BoostQuery::new(query : &Query, boost : Double) -> BoostQuery

#
ConfiguredTermQuery

source
pub struct ConfiguredTermQuery {
  term : 
Term
  config : Bm25Config
  boost : Double
}

Term query with explicit BM25 parameters and a field-level score boost.

#
ConfiguredTermQuery::new

source

#
ConstantScoreQuery

source
pub struct ConstantScoreQuery {
  query : &Query
  score : Double
}

#
ConstantScoreQuery::new

source
fn ConstantScoreQuery::new(query : &Query, score : Double) -> ConstantScoreQuery

#
CountCollector

source
pub struct CountCollector {
  enabled : Bool
}

#
CountCollector::new

source

#
DisjunctionMaxQuery

source
pub struct DisjunctionMaxQuery {
  disjuncts : ReadOnlyArray[&Query]
  tie_breaker : Double
}

#
DisjunctionMaxQuery::new

source
fn DisjunctionMaxQuery::new(disjuncts : Array[&Query], tie_breaker : Double) -> DisjunctionMaxQuery

#
ExactQuery

source

#
ExistsQuery

source
pub struct ExistsQuery {
  field_id : 
FieldId
}

#
ExistsQuery::new

source

#
Explanation

source
pub struct Explanation {
  matched : Bool
  value : Double
  description : String
  details : ReadOnlyArray[Explanation]
}

One node in a machine-readable score explanation tree.

#
Explanation::description

source
fn Explanation::description(self : Explanation) -> String

#
Explanation::details

source
fn Explanation::details(self : Explanation) -> ReadOnlyArray[Explanation]

#
Explanation::matched

source
fn Explanation::matched(self : Explanation) -> Bool

#
Explanation::value

source
fn Explanation::value(self : Explanation) -> Double

#
FacetCount

source
pub(all) struct FacetCount {
  value : String
  count : Int
} derive(Eq, 
Debug)

#
FunctionScoreQuery

source
pub struct FunctionScoreQuery {
  query : &Query
  function : ScoreFunction
}

#
FunctionScoreQuery::new

source
fn FunctionScoreQuery::new(query : &Query, function : ScoreFunction) -> FunctionScoreQuery

#
FuzzyQuery

source
pub struct FuzzyQuery {
  field_id : 
FieldId
  text : String
  max_distance : Int
  transpositions : Bool
  max_expansions : Int
}

impl Query for FuzzyQuery

#
FuzzyQuery::new

source
fn FuzzyQuery::new(field_id : 
FieldId, text : String, max_distance : Int) -> FuzzyQuery

#
HighlightFragment

source
pub(all) struct HighlightFragment {
  text : String
  start_offset : Int
  end_offset : Int
  matches : ReadOnlyArray[HighlightSpan]
  prefix_omitted : Bool
  suffix_omitted : Bool
} derive(Eq, 
Debug)

One UTF-8-safe source fragment. Match offsets remain relative to the full source value so callers can map them back without losing provenance.

#
HighlightFragment::render

source
fn HighlightFragment::render(self : HighlightFragment, before : String, after : String) -> String

Inserts caller-provided markers around matches without applying an HTML or terminal escaping policy. Callers remain responsible for output escaping.

#
HighlightMode

source
pub(all) enum HighlightMode {
  Terms
  Phrase
} derive(Eq, 
Debug)

Matching policy used while reconstructing highlights from analyzed text.

#
HighlightOptions

source
pub struct HighlightOptions {
  mode : HighlightMode
  max_chars : Int
}

Configuration for one highlight operation.

#
HighlightOptions::new

source

Creates term-oriented highlighting with a 160-Unicode-scalar fragment.

#
HighlightOptions::with_max_chars

source
fn HighlightOptions::with_max_chars(self : HighlightOptions, max_chars : Int) -> HighlightOptions

#
HighlightOptions::with_mode

source

#
HighlightSpan

source
pub(all) struct HighlightSpan {
  start_offset : Int
  end_offset : Int
} derive(Eq, 
Debug)

One match in source-text UTF-8 byte offsets.

#
Highlighter

source
pub struct Highlighter {
  parser : QueryParser
}

Analyzer-driven highlighter. Like QueryParser, it snapshots the tokenizer registry so subsequent application mutations cannot change its behavior.

#
Highlighter::highlight

source
fn Highlighter::highlight(self : Highlighter, field_id : 
FieldId, query_text : String, source_text : String, options : HighlightOptions) -> HighlightFragment? raise 
AnalysisError

Re-analyzes query and source text using the field's configured tokenizer, then returns one deterministic best fragment when at least one match exists.

#
Highlighter::highlight_postings

source
fn Highlighter::highlight_postings(_self : Highlighter, segment : 
Segment, doc_id : 
DocId, field_id : 
FieldId, terms : ReadOnlyArray[String], source_text : String, value_index? : Int, options? : HighlightOptions) -> HighlightFragment?

Builds a fragment directly from persisted posting offsets, avoiding source re-analysis. value_index selects one value of a multi-valued text field.

#
Highlighter::new

source

#
HistogramBucket

source
pub(all) struct HistogramBucket {
  key : Double
  count : Int
} derive(
Debug)

#
LenientQueryResult

source
pub struct LenientQueryResult {
  query : &Query
  warnings : ReadOnlyArray[String]
  recovered : Bool
}

#
LenientQueryResult::query

source

#
LenientQueryResult::recovered

source
fn LenientQueryResult::recovered(self : LenientQueryResult) -> Bool

#
LenientQueryResult::warnings

source
fn LenientQueryResult::warnings(self : LenientQueryResult) -> ReadOnlyArray[String]

#
MatchAllQuery

source
pub struct MatchAllQuery {
}

#
MatchAllQuery::new

source

#
MissingValueOrder

source
pub(all) enum MissingValueOrder {
  MissingFirst
  MissingLast
} derive(Eq, 
Debug)

#
MultiCollector

source
pub struct MultiCollector {
  top_docs_limit : Int
  include_count : Bool
}

Runs count and TopDocs in one scorer pass.

#
MultiCollector::new

source
fn MultiCollector::new(top_docs : TopDocsCollector, include_count : Bool) -> MultiCollector

#
MultiCollectorResult

source
pub(all) struct MultiCollectorResult {
  top_docs : ReadOnlyArray[SearchHit]
  count : Int
} derive(
Debug)

#
MultiTermRewrite

source
pub(all) enum MultiTermRewrite {
  ScoringBoolean
  ConstantScore
} derive(Eq, 
Debug)

Rewrite strategy shared by term-dictionary expanding queries. Expansion is deterministic and capped to keep adversarial patterns bounded.

#
NumericAggregation

source
pub(all) struct NumericAggregation {
  count : Int
  min : Double?
  max : Double?
  sum : Double
  avg : Double?
  histogram : ReadOnlyArray[HistogramBucket]
} derive(
Debug)

#
Occur

source
pub(all) enum Occur {
  Must
  Filter
  Should
  MustNot
} derive(Eq, 
Debug)

Boolean occurrence semantics modeled after Lucene and Tantivy.

#
PhrasePrefixQuery

source
pub struct PhrasePrefixQuery {
  field_id : 
FieldId
  exact_texts : ReadOnlyArray[String]
  final_prefix : String
  slop : Int
  max_expansions : Int
}

Phrase query whose final token is expanded from the segment term dictionary. This is the primitive behind search-as-you-type query strings.

#
PhrasePrefixQuery::new

source
fn PhrasePrefixQuery::new(field_id : 
FieldId, exact_texts : Array[String], final_prefix : String) -> PhrasePrefixQuery

#
PhrasePrefixQuery::with_options

source
fn PhrasePrefixQuery::with_options(self : PhrasePrefixQuery, slop : Int, max_expansions : Int) -> PhrasePrefixQuery

#
PhraseQuery

source
pub struct PhraseQuery {
  field_id : 
FieldId
  texts : ReadOnlyArray[String]
  positions : ReadOnlyArray[Int]
  slop : Int
}

Exact zero-slop phrase query within one field.

#
PhraseQuery::new

source

#
PhraseQuery::slop

source
fn PhraseQuery::slop(self : PhraseQuery) -> Int

#
PhraseQuery::with_positions

source
fn PhraseQuery::with_positions(field_id : 
FieldId, texts : Array[String], positions : Array[Int]) -> PhraseQuery

Creates a phrase with explicit relative token positions, preserving gaps introduced during query-time analysis.

#
PhraseQuery::with_slop

source
fn PhraseQuery::with_slop(self : PhraseQuery, slop : Int) -> PhraseQuery

Allows the ordered phrase to consume up to slop positional moves. A value of zero preserves exact phrase semantics.

#
PrefixQuery

source
pub struct PrefixQuery {
  field_id : 
FieldId
  prefix : String
  rewrite : MultiTermRewrite
  max_expansions : Int
}

#
PrefixQuery::new

source
fn PrefixQuery::new(field_id : 
FieldId, prefix : String) -> PrefixQuery

#
PrefixQuery::with_rewrite

source
fn PrefixQuery::with_rewrite(self : PrefixQuery, rewrite : MultiTermRewrite, max_expansions : Int) -> PrefixQuery

#
QueryLiteralMode

source
pub(all) enum QueryLiteralMode {
  Plain
  PhraseMode
  RegexMode
} derive(Eq, 
Debug)

#
QueryParser

source
pub struct QueryParser {
  schema : 
Schema
  tokenizers : 
TokenizerManager
  conjunction_by_default : Bool
}

Minimal field-aware query-time analysis. Query syntax parsing remains a separate concern; this type converts raw text into existing Query objects.

#
QueryParser::analyze

source

#
QueryParser::new

source

#
QueryParser::parse_phrase

source

Analyzes raw text and preserves analyzer positions in a PhraseQuery.

#
QueryParser::parse_phrase_with_slop

source
fn QueryParser::parse_phrase_with_slop(self : QueryParser, field_id : 
FieldId, text : String, slop : Int) -> &Query raise 
AnalysisError

Phrase parser variant that applies ordered positional slop to every Token Graph path produced by the configured analyzer.

#
QueryParser::parse_query

source

Analyzes raw text and creates one TermQuery or a BooleanQuery. Multiple terms are disjunctive by default, matching Tantivy's default parser mode.

#
QueryParser::set_conjunction_by_default

source
fn QueryParser::set_conjunction_by_default(self : QueryParser, conjunction : Bool) -> Unit

#
QueryStringErrorKind

source
pub(all) enum QueryStringErrorKind {
  EmptyQuery
  UnexpectedToken(String)
  UnsupportedSyntax(String)
  UnterminatedPhrase
  DanglingEscape
  InvalidBoost(String)
  InvalidFieldValue(String, String)
  UnknownField(String)
  InvalidDefaultField(Int)
  FieldNotIndexed(String)
  NoDefaultField
  AnalysisFailure(String)
  NegativeOnlyQuery
  LimitExceeded(String, Int)
} derive(Eq, 
Debug)

Stable categories reported by the strict Query-string parser.

#
QueryStringParser

source
pub struct QueryStringParser {
  schema : 
Schema
  tokenizers : 
TokenizerManager
  default_fields : ReadOnlyArray[
FieldId]
  conjunction_by_default : Bool
}

Strict human-query parser. Syntax parsing is Schema-independent; semantic binding resolves fields and invokes each field's configured Analyzer.

#
QueryStringParser::build_query_from_ast

source
fn QueryStringParser::build_query_from_ast(self : QueryStringParser, ast : UserQueryAst) -> &Query raise QueryStringError

#
QueryStringParser::highlight_query

source
fn QueryStringParser::highlight_query(self : QueryStringParser, highlighter : Highlighter, segment : 
Segment, doc_id : 
DocId, field_id : 
FieldId, query_text : String, source_text : String, value_index? : Int, options? : HighlightOptions) -> HighlightFragment? raise QueryStringError

Query-string-aware persisted-offset highlighting. The AST controls field scope and excludes prohibited clauses; wildcard/regex literals are expanded against the exact segment dictionary before offsets are read.

#
QueryStringParser::new

source

#
QueryStringParser::parse_ast

source
fn QueryStringParser::parse_ast(self : QueryStringParser, text : String) -> UserQueryAst raise QueryStringError

#
QueryStringParser::parse_query

source
fn QueryStringParser::parse_query(self : QueryStringParser, text : String) -> &Query raise QueryStringError

#
QueryStringParser::parse_query_lenient

source
fn QueryStringParser::parse_query_lenient(self : QueryStringParser, text : String) -> LenientQueryResult raise QueryStringError

Error-tolerant entry point. Strict parsing is attempted first; on failure, structural punctuation is removed and the remaining text is analyzed over the configured default fields. The original diagnostic is preserved.

#
QueryStringParser::set_conjunction_by_default

source
fn QueryStringParser::set_conjunction_by_default(self : QueryStringParser, conjunction : Bool) -> Unit

#
RangeFacet

source
pub struct RangeFacet {
  label : String
  lower : 
FieldValue?
  lower_inclusive : Bool
  upper : 
FieldValue?
  upper_inclusive : Bool
}

#
RangeFacet::new

source
fn RangeFacet::new(label : String, lower : 
FieldValue?, lower_inclusive : Bool, upper : 
FieldValue?, upper_inclusive : Bool) -> RangeFacet

#
RangeFacetCount

source
pub(all) struct RangeFacetCount {
  label : String
  count : Int
} derive(Eq, 
Debug)

#
RangeQuery

source
pub struct RangeQuery {
  field_id : 
FieldId
  lower : 
FieldValue?
  lower_inclusive : Bool
  upper : 
FieldValue?
  upper_inclusive : Bool
}

impl Query for RangeQuery

#
RangeQuery::new

source

#
RegexQuery

source
pub struct RegexQuery {
  field_id : 
FieldId
  pattern : String
  regex : 
Regex
  rewrite : MultiTermRewrite
  max_expansions : Int
}

impl Query for RegexQuery

#
RegexQuery::new

source
fn RegexQuery::new(field_id : 
FieldId, pattern : String) -> RegexQuery raise

#
RegexQuery::pattern

source
fn RegexQuery::pattern(self : RegexQuery) -> String

#
ScoreFunction

source
pub(all) enum ScoreFunction {
  MultiplyFastField(
FieldId, Double, Double)
  AddFastField(
FieldId, Double, Double)
} derive(Eq, 
Debug)

#
SearchHit

source
pub(all) struct SearchHit {
  address : 
DocAddress
  score : Double
} derive(
Debug)

One scored document returned by a collector.

#
SearchStatistics

source
pub struct SearchStatistics {
  segments : ReadOnlyArray[
SnapshotSegment]
  live_document_count : Int
  field_cache_ids : Array[
FieldId]
  field_cache_doc_counts : Array[Int]
  field_cache_total_lengths : Array[Int]
  term_cache_terms : Array[
Term]
  term_cache_frequencies : Array[Int]
}

Read-only collection statistics for one Searcher snapshot.

Query implementations use these global values while constructing Weight. A Weight can then create comparable Scorers for every immutable Segment.

#
SearchStatistics::average_field_length

source
fn SearchStatistics::average_field_length(self : SearchStatistics, field_id : 
FieldId) -> Double

#
SearchStatistics::doc_count

source
fn SearchStatistics::doc_count(self : SearchStatistics) -> Int

#
SearchStatistics::document_frequency

source
fn SearchStatistics::document_frequency(self : SearchStatistics, term : 
Term) -> Int

#
SearchStatistics::field_doc_count

source
fn SearchStatistics::field_doc_count(self : SearchStatistics, field_id : 
FieldId) -> Int

#
SearchStatistics::segment_count

source
fn SearchStatistics::segment_count(self : SearchStatistics) -> Int

#
Searcher

source
pub struct Searcher {
  segments : ReadOnlyArray[
SnapshotSegment]
  statistics : SearchStatistics
}

Stable read view over one immutable Segment set.

Searchers keep the exact Segment array and tombstones captured by their IndexReader generation. Later commits cannot mutate this view.

#
Searcher::aggregate

source
fn Searcher::aggregate(self : Searcher, query : &Query, field_id : 
FieldId, histogram_interval : Double?) -> NumericAggregation

#
Searcher::collect

source
fn Searcher::collect(self : Searcher, query : &Query, collector : MultiCollector) -> MultiCollectorResult

#
Searcher::count

source
fn Searcher::count(self : Searcher, query : &Query, collector : CountCollector) -> Int

#
Searcher::doc

source

Loads a stored document from the Segment addressed by this snapshot.

#
Searcher::doc_count

source
fn Searcher::doc_count(self : Searcher) -> Int

Returns the number of live documents visible in this Searcher snapshot.

#
Searcher::explain

source

Explains the final score produced by any query at one stable DocAddress.

#
Searcher::explain_term

source

Detailed BM25 explanation for an exact term query.

#
Searcher::from_segments

source
fn Searcher::from_segments(segments : ReadOnlyArray[
SnapshotSegment]) -> Searcher

#
Searcher::new

source

Creates a Searcher for one in-memory Segment.

#
Searcher::range_facet

source
fn Searcher::range_facet(self : Searcher, query : &Query, field_id : 
FieldId, ranges : ReadOnlyArray[RangeFacet]) -> ReadOnlyArray[RangeFacetCount]

#
Searcher::search

source
fn Searcher::search(self : Searcher, query : &Query, collector : TopKCollector) -> ReadOnlyArray[SearchHit]

Builds one Weight from snapshot-wide statistics, runs a Scorer against every Segment, then performs one global Top-K selection.

#
Searcher::search_sorted

source
fn Searcher::search_sorted(self : Searcher, query : &Query, sort : Sort, limit : Int) -> ReadOnlyArray[SearchHit]

#
Searcher::search_wand

source
fn Searcher::search_wand(self : Searcher, query : BlockMaxWandQuery, collector : TopKCollector) -> WandSearchResult

Runs safe WAND pruning using exact per-term upper bounds. Returned hits are identical to the ordinary disjunction and deterministic Top-K tie-break.

#
Searcher::search_with_executor

source
fn Searcher::search_with_executor(self : Searcher, query : &Query, collector : TopKCollector, executor : SegmentSearchExecutor) -> ReadOnlyArray[SearchHit]

Runs per-segment collection through the executor contract and performs a deterministic global Top-K reduction. Lane-local heaps bound intermediate memory and make this reduction directly reusable by a native pool.

#
Searcher::segment_count

source
fn Searcher::segment_count(self : Searcher) -> Int

#
Searcher::terms_facet

source
fn Searcher::terms_facet(self : Searcher, query : &Query, field_id : 
FieldId) -> ReadOnlyArray[FacetCount]

#
Searcher::top_docs

source
fn Searcher::top_docs(self : Searcher, query : &Query, collector : TopDocsCollector) -> ReadOnlyArray[SearchHit]

#
SegmentSearchExecutor

source
pub struct SegmentSearchExecutor {
  requested_parallelism : Int
  effective_parallelism : Int
}

Backend-neutral segment execution policy. The built-in implementation deterministically partitions work into lanes and executes them cooperatively. A native thread-pool can preserve the same lane contract.

#
SegmentSearchExecutor::effective_parallelism

source
fn SegmentSearchExecutor::effective_parallelism(self : SegmentSearchExecutor) -> Int

#
SegmentSearchExecutor::is_degraded

source
fn SegmentSearchExecutor::is_degraded(self : SegmentSearchExecutor) -> Bool

#
SegmentSearchExecutor::portable

source
fn SegmentSearchExecutor::portable(requested_parallelism : Int) -> SegmentSearchExecutor

#
SegmentSearchExecutor::requested_parallelism

source
fn SegmentSearchExecutor::requested_parallelism(self : SegmentSearchExecutor) -> Int

#
Sort

source
pub struct Sort {
  fields : ReadOnlyArray[SortField]
}

#
Sort::new

source
fn Sort::new(fields : Array[SortField]) -> Sort

#
SortField

source
pub struct SortField {
  field_id : 
FieldId
  order : SortOrder
  missing : MissingValueOrder
}

#
SortField::new

source

#
SortOrder

source
pub(all) enum SortOrder {
  Ascending
  Descending
} derive(Eq, 
Debug)

#
TermQuery

source
pub struct TermQuery {
  term : 
Term
}

Exact field-qualified term query.

The term is already analyzed. QueryParser is the higher-level entry point for raw field text; callers can keep using TermQuery for exact control.
impl Query for TermQuery

#
TermQuery::new

source

#
TermQuery::term

source

#
TermRangeQuery

source
pub struct TermRangeQuery {
  field_id : 
FieldId
  lower : String?
  lower_inclusive : Bool
  upper : String?
  upper_inclusive : Bool
  max_expansions : Int
}

Lexicographic term range for analyzed or keyword terms. Typed numeric/date ranges continue to use RangeQuery.

#
TermRangeQuery::new

source
fn TermRangeQuery::new(field_id : 
FieldId, lower : String?, lower_inclusive : Bool, upper : String?, upper_inclusive : Bool) -> TermRangeQuery

#
TermSetQuery

source
pub struct TermSetQuery {
  terms : ReadOnlyArray[
Term]
  score : Double
}

#
TermSetQuery::new

source

#
TermSetQuery::with_score

source
fn TermSetQuery::with_score(self : TermSetQuery, score : Double) -> TermSetQuery

#
TopDocsCollector

source
pub struct TopDocsCollector {
  limit : Int
}

Tantivy-style score-ordered top documents collector.

#
TopDocsCollector::new

source
fn TopDocsCollector::new(limit : Int) -> TopDocsCollector

#
TopKCollector

source
pub struct TopKCollector {
  limit : Int
}

Collector that retains at most the highest-scoring K documents.

#
TopKCollector::new

source
fn TopKCollector::new(limit : Int) -> TopKCollector

#
UserQueryAst

source
pub struct UserQueryAst {
  nodes : ReadOnlyArray[UserQueryNode]
  root : Int
  source_length : Int
}

Schema-independent syntax tree. Its representation is intentionally opaque; applications can parse once and bind it against a parser configuration.

#
UserQueryAst::node_count

source
fn UserQueryAst::node_count(self : UserQueryAst) -> Int

#
UserQueryAst::source_length

source
fn UserQueryAst::source_length(self : UserQueryAst) -> Int

#
UserQueryNode

source
pub struct UserQueryNode {
  kind : UserQueryNodeKind
  start_offset : Int
  end_offset : Int
}

#
UserQueryNodeKind

source
pub(all) enum UserQueryNodeKind {
  Literal(String, QueryLiteralMode)
  Range(String?, String?, Bool, Bool)
  FieldScope(String, Int, Int, Int)
  Conjunction(Array[Int])
  Disjunction(Array[Int])
  Required(Int)
  Prohibited(Int)
  Boost(Int, Double)
  Proximity(Int, Int)
  Group(Int)
}

#
WandSearchResult

source
pub(all) struct WandSearchResult {
  hits : ReadOnlyArray[SearchHit]
  evaluated_candidates : Int
  skipped_candidates : Int
} derive(
Debug)

#
WildcardQuery

source
pub struct WildcardQuery {
  field_id : 
FieldId
  pattern : String
  rewrite : MultiTermRewrite
  max_expansions : Int
}

#
WildcardQuery::new

source

#
WildcardQuery::with_rewrite

source
fn WildcardQuery::with_rewrite(self : WildcardQuery, rewrite : MultiTermRewrite, max_expansions : Int) -> WildcardQuery

#
compare_field_values

source

Compares two values of the same logical field type.

#
field_value_as_double

source
fn field_value_as_double(value : 
FieldValue) -> Double?

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io