Struct DocumentsQuery 

pub struct DocumentsQuery<'a, Http: HttpClient> {
    pub index: &'a Index<Http>,
    pub offset: Option<usize>,
    pub limit: Option<usize>,
    pub fields: Option<Vec<&'a str>>,
    pub sort: Option<Vec<&'a str>>,
    pub filter: Option<&'a str>,
    pub ids: Option<Vec<&'a str>>,
}

Fields

index: &'a Index<Http>

offset: Option<usize>

The number of documents to skip.

If the value of the parameter offset is n, the n first documents 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

fields: Option<Vec<&'a str>>

The fields that should appear in the documents. By default, all of the fields are present.

sort: Option<Vec<&'a str>>

Attributes used to sort the returned documents.

Available since v1.16 of Meilisearch.

filter: Option<&'a str>

Filters to apply.

Available since v1.2 of Meilisearch Read the dedicated guide to learn the syntax.

ids: Option<Vec<&'a str>>

Retrieve documents by their IDs.

When ids is provided, the SDK will call the /documents/fetch endpoint with a POST request.

Note: IDs are represented as strings to keep consistency with Index::get_document. If your IDs are numeric, pass them as strings (e.g., "1", "2").

Implementations

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

pub fn new(index: &Index<Http>) -> DocumentsQuery<'_, Http>

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

Specify the offset.

Example

let index = client.index("my_index");

let mut documents_query = DocumentsQuery::new(&index).with_offset(1);

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

Specify the limit.

Example

let index = client.index("my_index");

let mut documents_query = DocumentsQuery::new(&index);

documents_query.with_limit(1);

pub fn with_fields( &mut self, fields: impl IntoIterator<Item = &'a str>, ) -> &mut DocumentsQuery<'a, Http>

Specify the fields to return in the documents.

Example

let index = client.index("my_index");

let mut documents_query = DocumentsQuery::new(&index);

documents_query.with_fields(["title"]);

pub fn with_sort( &mut self, sort: impl IntoIterator<Item = &'a str>, ) -> &mut DocumentsQuery<'a, Http>

Specify the sort order of the returned documents.

Example

let index = client.index("documents_with_sort");

let mut documents_query = DocumentsQuery::new(&index);

documents_query.with_sort(["release_date:desc"]);

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

pub fn with_ids( &mut self, ids: impl IntoIterator<Item = &'a str>, ) -> &mut DocumentsQuery<'a, Http>

Specify a list of document IDs to retrieve.

Example

let index = client.index("get_documents_by_ids_example");
let mut query = DocumentsQuery::new(&index);
query.with_ids(["1", "2"]);

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

Execute the get documents query.

Example

#[derive(Debug, Serialize, Deserialize, PartialEq)]
struct MyObject {
    id: Option<usize>,
    kind: String,
}
let index = client.index("documents_query_execute");

let document = DocumentsQuery::new(&index)
    .with_offset(1)
    .execute::<MyObject>()
    .await
    .unwrap();

Trait Implementations

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

fn clone(&self) -> DocumentsQuery<'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 DocumentsQuery<'a, Http>

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

Formats the value using the given formatter.

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.