Struct Search 

pub struct Search<T> { /* private fields */ }

A typed query against one index — a plain, client-free value.

Built from FlussoDocument::query (or Search::new(index, hash) by hand). Clauses accumulate into a bool query: query/should score, filter/must_not don’t. Because no client (and no lifetime) is involved, a Search can be named, stored, cloned, and reused; a Client appears only at the terminals — Search::send for a page of hits, Search::ids for a page of bare document ids, Search::count for just the number of matches (all &self, so running consumes nothing) — or several searches go in one round-trip via Client::msearch.

Implementations

impl<T> Search<T>

pub fn new(index: impl Into<String>, hash: impl Into<String>) -> Self

Start a query against index (the logical name) and its schema hash.

pub fn query(self, query: impl AsQuery<Root>) -> Self

A scoring clause (bool.must). Accepts any root-scope AsQuery; an absent one (e.g. a None optional) adds nothing.

pub fn filter(self, query: impl AsQuery<Root>) -> Self

A non-scoring, cacheable clause (bool.filter). An absent clause adds nothing — so filter(opt.map(|v| handle.eq(v))) is a conditional filter.

pub fn must_not(self, query: impl AsQuery<Root>) -> Self

An exclusion clause (bool.must_not). An absent clause excludes nothing.

pub fn should(self, query: impl AsQuery<Root>) -> Self

An optional, scoring clause (bool.should). An absent clause adds nothing.

pub fn min_should_match(self, value: impl Into<MinimumShouldMatch>) -> Self

Require at least this many should clauses to match. Beside query / filter clauses, should defaults to non-constraining (scoring only); setting this makes a top-level should-group a real filter. Accepts a count (1) or MinimumShouldMatch::percent / raw.

pub fn sort(self, sort: Sort) -> Self

pub fn min_score(self, min_score: f32) -> Self

Drop hits scoring below min_score.

pub fn track_total_hits(self, track: impl Into<Value>) -> Self

Control how the hit total is counted. true counts exactly, false disables counting, an integer caps accuracy at that many (e.g. 10_000).

pub fn track_scores(self, track: bool) -> Self

Compute relevance scores even when sorting by a field.

pub fn search_after( self, values: impl IntoIterator<Item = impl Into<Value>>, ) -> Self

Deep-paginate after the given sort values (the last hit’s sort array from the previous page). Pair with a deterministic sort.

pub fn collapse(self, field: impl Into<String>) -> Self

Collapse hits so only the top hit per field value is returned.

pub fn post_filter(self, query: impl AsQuery<Root>) -> Self

A filter applied after scoring/aggregation — narrows the returned hits without affecting scores or aggregations.

pub fn highlight(self, highlight: Highlight) -> Self

Attach match highlighting (see Highlight).

pub fn from(self, from: u64) -> Self

Offset of the first hit to return.

pub fn size(self, size: u64) -> Self

Maximum number of hits to return.

pub fn raw(self, query: Value) -> Self

Replace the query body with a raw OpenSearch query DSL value. The pressure-release valve for anything the typed builder can’t express; results still deserialize into T.

pub fn filter_nested(self, projection: NestedProjection) -> Self

Shape a nested array in the results (built via Nested::matching / Nested::project). Each hit’s source.<path> is replaced with the matching subset; this does not change which parents match.

pub fn body(&self) -> Value

The request body this search will POST to _search. Pure — useful for tests and debugging.

pub fn count_body(&self) -> Value

The request body count will POST to _count: just the query. Sort, from/size, and filter_nested projections are dropped — _count accepts none of them, and none of them changes which documents match. Pure — useful for tests and debugging.

pub fn ids_body(&self) -> Value

The request body ids will POST to _search: the query plus sort and pagination, with _source: false so hits carry only their _id and nothing is fetched from stored source. filter_nested projections are dropped — they shape returned sources, and there are none. Pure — useful for tests and debugging.

pub async fn ids(&self, client: &Client) -> Result<Vec<String>>

Execute the search and return only the matching document ids (the root primary keys, stringified by OpenSearch) — no sources are fetched, so this is the cheap way to feed another lookup (e.g. load the rows from Postgres). Sort, from, and size apply as in send; the page’s ids are returned in order.

pub async fn count(&self, client: &Client) -> Result<u64>

Execute the query as a count: how many documents match, without fetching (or scoring) any hits — cheaper than send when only the total is needed. Sort, pagination, and nested projections are ignored (see count_body).

impl<T> Search<T>

where T: DeserializeOwned,

pub async fn send(&self, client: &Client) -> Result<SearchResponse<T>>

Execute the search and decode the hits into SearchResponse<T>.

Trait Implementations

impl<T: Clone> Clone for Search<T>

fn clone(&self) -> Search<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Search<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.