Struct elasticsearch::async_search::AsyncSearchSubmit

pub struct AsyncSearchSubmit<'a, 'b, B> { /* fields omitted */ }

Builder for the Async Search Submit API

Executes a search request asynchronously.

Implementations

impl<'a, 'b, B> AsyncSearchSubmit<'a, 'b, B> where
    B: Body, 

pub fn new(transport: &'a Transport, parts: AsyncSearchSubmitParts<'b>) -> Self

Creates a new instance of AsyncSearchSubmit with the specified API parts

pub fn _source(mut self: Self, _source: &'b [&'b str]) -> Self

True or false to return the _source field or not, or a list of fields to return

pub fn _source_excludes(mut self: Self, _source_excludes: &'b [&'b str]) -> Self

A list of fields to exclude from the returned _source field

pub fn _source_includes(mut self: Self, _source_includes: &'b [&'b str]) -> Self

A list of fields to extract and return from the _source field

pub fn allow_no_indices(mut self: Self, allow_no_indices: bool) -> Self

Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes _all string or when no indices have been specified)

pub fn allow_partial_search_results(
    mut self: Self,
    allow_partial_search_results: bool
) -> Self

Indicate if an error should be returned if there is a partial search failure or timeout

pub fn analyze_wildcard(mut self: Self, analyze_wildcard: bool) -> Self

Specify whether wildcard and prefix queries should be analyzed (default: false)

pub fn analyzer(mut self: Self, analyzer: &'b str) -> Self

The analyzer to use for the query string

pub fn batched_reduce_size(mut self: Self, batched_reduce_size: i64) -> Self

The number of shard results that should be reduced at once on the coordinating node. This value should be used as the granularity at which progress results will be made available.

pub fn body<T>(self, body: T) -> AsyncSearchSubmit<'a, 'b, JsonBody<T>> where
    T: Serialize, 

The body for the API call

pub fn default_operator(
    mut self: Self,
    default_operator: DefaultOperator
) -> Self

The default operator for query string query (AND or OR)

pub fn df(mut self: Self, df: &'b str) -> Self

The field to use as default where no field prefix is given in the query string

pub fn docvalue_fields(mut self: Self, docvalue_fields: &'b [&'b str]) -> Self

A comma-separated list of fields to return as the docvalue representation of a field for each hit

pub fn error_trace(mut self: Self, error_trace: bool) -> Self

Include the stack trace of returned errors.

pub fn expand_wildcards(
    mut self: Self,
    expand_wildcards: &'b [ExpandWildcards]
) -> Self

Whether to expand wildcard expression to concrete indices that are open, closed or both.

pub fn explain(mut self: Self, explain: bool) -> Self

Specify whether to return detailed information about score computation as part of a hit

pub fn filter_path(mut self: Self, filter_path: &'b [&'b str]) -> Self

A comma-separated list of filters used to reduce the response.

pub fn from(mut self: Self, from: i64) -> Self

Starting offset (default: 0)

pub fn header(mut self: Self, key: HeaderName, value: HeaderValue) -> Self

Adds a HTTP header

pub fn human(mut self: Self, human: bool) -> Self

Return human readable values for statistics.

pub fn ignore_throttled(mut self: Self, ignore_throttled: bool) -> Self

Whether specified concrete, expanded or aliased indices should be ignored when throttled

pub fn ignore_unavailable(mut self: Self, ignore_unavailable: bool) -> Self

Whether specified concrete indices should be ignored when unavailable (missing or closed)

pub fn keep_alive(mut self: Self, keep_alive: &'b str) -> Self

Update the time interval in which the results (partial or final) for this search will be available

pub fn keep_on_completion(mut self: Self, keep_on_completion: bool) -> Self

Control whether the response should be stored in the cluster if it completed within the provided [wait_for_completion] time (default: false)

pub fn lenient(mut self: Self, lenient: bool) -> Self

Specify whether format-based query failures (such as providing text to a numeric field) should be ignored

pub fn max_concurrent_shard_requests(
    mut self: Self,
    max_concurrent_shard_requests: i64
) -> Self

The number of concurrent shard requests per node this search executes concurrently. This value should be used to limit the impact of the search on the cluster in order to limit the number of concurrent shard requests

pub fn preference(mut self: Self, preference: &'b str) -> Self

Specify the node or shard the operation should be performed on (default: random)

pub fn pretty(mut self: Self, pretty: bool) -> Self

Pretty format the returned JSON response.

pub fn q(mut self: Self, q: &'b str) -> Self

Query in the Lucene query string syntax

pub fn request_cache(mut self: Self, request_cache: bool) -> Self

Specify if request cache should be used for this request or not, defaults to true

pub fn request_timeout(mut self: Self, timeout: Duration) -> Self

Sets a request timeout for this API call.

The timeout is applied from when the request starts connecting until the response body has finished.

pub fn routing(mut self: Self, routing: &'b [&'b str]) -> Self

A comma-separated list of specific routing values

pub fn search_type(mut self: Self, search_type: SearchType) -> Self

Search operation type

pub fn seq_no_primary_term(mut self: Self, seq_no_primary_term: bool) -> Self

Specify whether to return sequence number and primary term of the last modification of each hit

pub fn size(mut self: Self, size: i64) -> Self

Number of hits to return (default: 10)

pub fn sort(mut self: Self, sort: &'b [&'b str]) -> Self

A comma-separated list of : pairs

pub fn source(mut self: Self, source: &'b str) -> Self

The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

pub fn stats(mut self: Self, stats: &'b [&'b str]) -> Self

Specific 'tag' of the request for logging and statistical purposes

pub fn stored_fields(mut self: Self, stored_fields: &'b [&'b str]) -> Self

A comma-separated list of stored fields to return as part of a hit

pub fn suggest_field(mut self: Self, suggest_field: &'b str) -> Self

Specify which field to use for suggestions

pub fn suggest_mode(mut self: Self, suggest_mode: SuggestMode) -> Self

Specify suggest mode

pub fn suggest_size(mut self: Self, suggest_size: i64) -> Self

How many suggestions to return in response

pub fn suggest_text(mut self: Self, suggest_text: &'b str) -> Self

The source text for which the suggestions should be returned

pub fn terminate_after(mut self: Self, terminate_after: i64) -> Self

The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.

pub fn timeout(mut self: Self, timeout: &'b str) -> Self

Explicit operation timeout

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

Whether to calculate and return scores even if they are not used for sorting

pub fn track_total_hits<T: Into<TrackTotalHits>>(
    mut self: Self,
    track_total_hits: T
) -> Self

Indicate if the number of documents that match the query should be tracked

pub fn typed_keys(mut self: Self, typed_keys: bool) -> Self

Specify whether aggregation and suggester names should be prefixed by their respective types in the response

pub fn version(mut self: Self, version: bool) -> Self

Specify whether to return document version as part of a hit

pub fn wait_for_completion_timeout(
    mut self: Self,
    wait_for_completion_timeout: &'b str
) -> Self

Specify the time that the request should block waiting for the final response

pub async fn send(self) -> Result<Response, Error>

Creates an asynchronous call to the Async Search Submit API that can be awaited

Trait Implementations

impl<'a, 'b, B: Clone> Clone for AsyncSearchSubmit<'a, 'b, B>

fn clone(&self) -> AsyncSearchSubmit<'a, 'b, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, 'b, B: Debug> Debug for AsyncSearchSubmit<'a, 'b, B>

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

Formats the value using the given formatter.