Struct meilisearch_sdk::search::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 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

#[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

matching_strategy: Option<MatchingStrategies>

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

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_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_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 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 copy 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.