Struct SearchQuery

pub struct SearchQuery<'a, Http: HttpClient> {

    pub query: Option<&'a str>,
    pub offset: Option<usize>,
    pub limit: Option<usize>,
    pub page: Option<usize>,
    pub hits_per_page: Option<usize>,
    pub filter: Option<Filter<'a>>,
    pub facets: Option<Selectors<&'a [&'a str]>>,
    pub sort: Option<&'a [&'a str]>,
    pub attributes_to_search_on: Option<&'a [&'a str]>,
    pub attributes_to_retrieve: Option<Selectors<&'a [&'a str]>>,
    pub attributes_to_crop: Option<Selectors<&'a [(&'a str, Option<usize>)]>>,
    pub crop_length: Option<usize>,
    pub crop_marker: Option<&'a str>,
    pub attributes_to_highlight: Option<Selectors<&'a [&'a str]>>,
    pub highlight_pre_tag: Option<&'a str>,
    pub highlight_post_tag: Option<&'a str>,
    pub show_matches_position: Option<bool>,
    pub show_ranking_score: Option<bool>,
    pub show_ranking_score_details: Option<bool>,
    pub matching_strategy: Option<MatchingStrategies>,
    pub distinct: Option<&'a str>,
    pub ranking_score_threshold: Option<f64>,
    pub locales: Option<&'a [&'a str]>,
    pub hybrid: Option<HybridSearch<'a>>,
    pub vector: Option<&'a [f32]>,
    pub retrieve_vectors: Option<bool>,
    /* private fields */
}

A struct representing a query.

You can add search parameters using the builder syntax.

See this page for the official list and description of all parameters.

Examples

#[derive(Serialize, Deserialize, Debug)]
struct Movie {
    name: String,
    description: String,
}

let mut res = SearchQuery::new(&index)
    .with_query("space")
    .with_offset(42)
    .with_limit(21)
    .execute::<Movie>()
    .await
    .unwrap();

assert_eq!(res.limit, Some(21));

let query = index.search()
    .with_query("space")
    .with_offset(42)
    .with_limit(21)
    .build(); // you can also execute() instead of build()

Fields

query: Option<&'a str>

The text that will be searched for among the documents.

offset: Option<usize>

The number of documents to skip.

If the value of the parameter offset is n, the n first documents (ordered by relevance) will not be returned. This is helpful for pagination.

Example: If you want to skip the first document, set offset to 1.

limit: Option<usize>

The maximum number of documents returned.

If the value of the parameter limit is n, there will never be more than n documents in the response. This is helpful for pagination.

Example: If you don’t want to get more than two documents, set limit to 2.

Default: 20

page: Option<usize>

The page number on which you paginate.

Pagination starts at 1. If page is 0, no results are returned.

Default: None unless hits_per_page is defined, in which case page is 1

hits_per_page: Option<usize>

The maximum number of results in a page. A page can contain less results than the number of hits_per_page.

Default: None unless page is defined, in which case 20

filter: Option<Filter<'a>>

Filter applied to documents.

Read the dedicated guide to learn the syntax.

facets: Option<Selectors<&'a [&'a str]>>

Facets for which to retrieve the matching count.

Can be set to a wildcard value that will select all existing attributes.

Default: all attributes found in the documents.

sort: Option<&'a [&'a str]>

Attributes to sort.

attributes_to_search_on: Option<&'a [&'a str]>

Attributes to perform the search on.

Specify the subset of searchableAttributes for a search without modifying Meilisearch’s index settings.

Default: all searchable attributes found in the documents.

attributes_to_retrieve: Option<Selectors<&'a [&'a str]>>

Attributes to display in the returned documents.

Can be set to a wildcard value that will select all existing attributes.

Default: all attributes found in the documents.

attributes_to_crop: Option<Selectors<&'a [(&'a str, Option<usize>)]>>

Attributes whose values have to be cropped.

Attributes are composed by the attribute name and an optional usize that overwrites the crop_length parameter.

Can be set to a wildcard value that will select all existing attributes.

crop_length: Option<usize>

Maximum number of words including the matched query term(s) contained in the returned cropped value(s).

See attributes_to_crop.

Default: 10

crop_marker: Option<&'a str>

Marker at the start and the end of a cropped value.

ex: ...middle of a crop...

Default: ...

attributes_to_highlight: Option<Selectors<&'a [&'a str]>>

Attributes whose values will contain highlighted matching terms.

Can be set to a wildcard value that will select all existing attributes.

highlight_pre_tag: Option<&'a str>

Tag in front of a highlighted term.

ex: <mytag>hello world

Default: <em>

highlight_post_tag: Option<&'a str>

Tag after a highlighted term.

ex: hello world</ mytag>

Default: </em>

show_matches_position: Option<bool>

Defines whether an object that contains information about the matches should be returned or not.

Default: false

show_ranking_score: Option<bool>

Defines whether to show the relevancy score of the match.

Default: false

show_ranking_score_details: Option<bool>

Adds a detailed global ranking score field to each document.

Default: false

matching_strategy: Option<MatchingStrategies>

Defines the strategy on how to handle queries containing multiple words.

distinct: Option<&'a str>

Defines one attribute in the filterableAttributes list as a distinct attribute.

ranking_score_threshold: Option<f64>

Excludes results below the specified ranking score.

locales: Option<&'a [&'a str]>

Defines the language of the search query.

hybrid: Option<HybridSearch<'a>>

Configures Meilisearch to return search results based on a query’s meaning and context.

vector: Option<&'a [f32]>

Use a custom vector to perform a search query.

retrieve_vectors: Option<bool>

Defines whether document embeddings are returned with search results.

Implementations

impl<'a, Http: HttpClient> SearchQuery<'a, Http>

pub fn new(index: &'a Index<Http>) -> SearchQuery<'a, Http>

pub fn with_query<'b>( &'b mut self, query: &'a str, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_offset<'b>( &'b mut self, offset: usize, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_limit<'b>( &'b mut self, limit: usize, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_page<'b>(&'b mut self, page: usize) -> &'b mut SearchQuery<'a, Http>

Add the page number on which to paginate.

Example

let mut index = client.index("search_with_page");

let mut query = SearchQuery::new(&index);
query.with_query("").with_page(2);
let res = query.execute::<Movie>().await.unwrap();

pub fn with_hits_per_page<'b>( &'b mut self, hits_per_page: usize, ) -> &'b mut SearchQuery<'a, Http>

Add the maximum number of results per page.

Example

let mut index = client.index("search_with_hits_per_page");

let mut query = SearchQuery::new(&index);
query.with_query("").with_hits_per_page(2);
let res = query.execute::<Movie>().await.unwrap();

pub fn with_filter<'b>( &'b mut self, filter: &'a str, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_array_filter<'b>( &'b mut self, filter: Vec<&'a str>, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_retrieve_vectors<'b>( &'b mut self, retrieve_vectors: bool, ) -> &'b mut SearchQuery<'a, Http>

Defines whether document embeddings are returned with search results.

pub fn with_facets<'b>( &'b mut self, facets: Selectors<&'a [&'a str]>, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_sort<'b>( &'b mut self, sort: &'a [&'a str], ) -> &'b mut SearchQuery<'a, Http>

pub fn with_attributes_to_search_on<'b>( &'b mut self, attributes_to_search_on: &'a [&'a str], ) -> &'b mut SearchQuery<'a, Http>

pub fn with_attributes_to_retrieve<'b>( &'b mut self, attributes_to_retrieve: Selectors<&'a [&'a str]>, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_attributes_to_crop<'b>( &'b mut self, attributes_to_crop: Selectors<&'a [(&'a str, Option<usize>)]>, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_crop_length<'b>( &'b mut self, crop_length: usize, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_crop_marker<'b>( &'b mut self, crop_marker: &'a str, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_attributes_to_highlight<'b>( &'b mut self, attributes_to_highlight: Selectors<&'a [&'a str]>, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_highlight_pre_tag<'b>( &'b mut self, highlight_pre_tag: &'a str, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_highlight_post_tag<'b>( &'b mut self, highlight_post_tag: &'a str, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_show_matches_position<'b>( &'b mut self, show_matches_position: bool, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_show_ranking_score<'b>( &'b mut self, show_ranking_score: bool, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_show_ranking_score_details<'b>( &'b mut self, show_ranking_score_details: bool, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_matching_strategy<'b>( &'b mut self, matching_strategy: MatchingStrategies, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_index_uid<'b>(&'b mut self) -> &'b mut SearchQuery<'a, Http>

pub fn with_hybrid<'b>( &'b mut self, embedder: &'a str, semantic_ratio: f32, ) -> &'b mut SearchQuery<'a, Http>

Configures Meilisearch to return search results based on a query’s meaning and context

pub fn with_vector<'b>( &'b mut self, vector: &'a [f32], ) -> &'b mut SearchQuery<'a, Http>

Use a custom vector to perform a search query

vector is mandatory when performing searches with userProvided embedders. You may also use vector to override an embedder’s automatic vector generation.

vector dimensions must match the dimensions of the embedder.

pub fn with_distinct<'b>( &'b mut self, distinct: &'a str, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_ranking_score_threshold<'b>( &'b mut self, ranking_score_threshold: f64, ) -> &'b mut SearchQuery<'a, Http>

pub fn with_locales<'b>( &'b mut self, locales: &'a [&'a str], ) -> &'b mut SearchQuery<'a, Http>

pub fn build(&mut self) -> SearchQuery<'a, Http>

pub async fn execute<T: 'static + DeserializeOwned + Send + Sync>( &'a self, ) -> Result<SearchResults<T>, Error>

Execute the query and fetch the results.

Trait Implementations

impl<'a, Http: Clone + HttpClient> Clone for SearchQuery<'a, Http>

fn clone(&self) -> SearchQuery<'a, Http>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, Http: Debug + HttpClient> Debug for SearchQuery<'a, Http>

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

Formats the value using the given formatter.

impl<'a, Http: HttpClient> Serialize for SearchQuery<'a, Http>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.