Struct meilisearch_sdk::search::SearchQuery

pub struct SearchQuery<'a> {

    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_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 matching_strategy: Option<MatchingStrategies>,
    /* 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

use serde::{Serialize, Deserialize};
#[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_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 the 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

matching_strategy: Option<MatchingStrategies>

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

Implementations

impl<'a> SearchQuery<'a>

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

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

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

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

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

Add the page number on which to paginate.

use serde::{Serialize, Deserialize};
let client = Client::new(MEILISEARCH_URL, MEILISEARCH_API_KEY);
#[derive(Serialize, Deserialize, Debug)]
struct Movie {
    name: String,
    description: String,
}
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>

Add the maximum number of results per page.

use serde::{Serialize, Deserialize};
let client = Client::new(MEILISEARCH_URL, MEILISEARCH_API_KEY);
#[derive(Serialize, Deserialize, Debug)]
struct Movie {
    name: String,
    description: String,
}
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>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Execute the query and fetch the results.

Trait Implementations

impl<'a> Clone for SearchQuery<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SearchQuery<'a>

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

Formats the value using the given formatter.

impl<'a> Serialize for SearchQuery<'a>

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

Serialize this value into the given Serde serializer.